darkwallet/darkwallet

View on GitHub
src/vendors/bitcoinjs-lib/bitcoinjs.js

Summary

Maintainability
F
3 mos
Test Coverage

File bitcoinjs.js has 6471 lines of code (exceeds 250 allowed). Consider refactoring.
Open

!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.bitcoin=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
// (public) Constructor
function BigInteger(a, b, c) {
  if (!(this instanceof BigInteger))
    return new BigInteger(a, b, c)
Severity: Major
Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 wks to fix

    Function 1 has 1186 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.bitcoin=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
    // (public) Constructor
    function BigInteger(a, b, c) {
      if (!(this instanceof BigInteger))
        return new BigInteger(a, b, c)
    Severity: Major
    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 5 days to fix

      Function 46 has 839 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      },{}],46:[function(require,module,exports){
      /*!
       * The buffer module from node.js, for the browser.
       *
       * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
      Severity: Major
      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 4 days to fix

        Function 68 has 431 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        },{}],68:[function(require,module,exports){
        (function (process,global){
        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        Severity: Major
        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 days to fix

          Function 43 has 254 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          },{"buffer":46}],43:[function(require,module,exports){
          (function (Buffer){
          var assert = require('assert')
          var bufferutils = require('./bufferutils')
          var crypto = require('crypto')
          Severity: Major
          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 day to fix

            Function 40 has 242 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            },{"./ecsignature":33,"./opcodes":37,"./script":38,"./types":42,"assert":44,"buffer":46,"ecurve":24}],40:[function(require,module,exports){
            (function (Buffer){
            var assert = require('assert')
            var bufferutils = require('./bufferutils')
            var crypto = require('./crypto')
            Severity: Major
            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 day to fix

              Function 44 has 209 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              },{"./address":27,"./bufferutils":28,"./hdnode":34,"./networks":36,"./script":38,"./transaction_builder":41,"./types":42,"assert":44,"buffer":46,"crypto":10}],44:[function(require,module,exports){
              // http://wiki.commonjs.org/wiki/Unit_Testing/1.0
              //
              // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
              //
              Severity: Major
              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 day to fix

                Function 19 has 200 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                },{"util":68}],19:[function(require,module,exports){
                var inherits = require('util').inherits
                
                module.exports = function (Buffer, Hash) {
                  var K = [
                Severity: Major
                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 day to fix

                  Function exports has 197 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  module.exports = function (Buffer, Hash) {
                    var K = [
                      0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
                      0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
                      0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
                  Severity: Major
                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 7 hrs to fix

                    Function 39 has 196 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    },{"./bufferutils":28,"./crypto":29,"./opcodes":37,"./types":42,"assert":44,"buffer":46}],39:[function(require,module,exports){
                    (function (Buffer){
                    var assert = require('assert')
                    var enforceType = require('./types')
                    var ops = require('./opcodes')
                    Severity: Major
                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 7 hrs to fix

                      Function 41 has 193 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      },{"./address":27,"./bufferutils":28,"./crypto":29,"./ecsignature":33,"./opcodes":37,"./script":38,"./scripts":39,"./types":42,"assert":44,"buffer":46}],41:[function(require,module,exports){
                      (function (Buffer){
                      var assert = require('assert')
                      var scripts = require('./scripts')
                      
                      
                      Severity: Major
                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 7 hrs to fix

                        Function 34 has 192 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        },{"./types":42,"assert":44,"bigi":3,"buffer":46}],34:[function(require,module,exports){
                        (function (Buffer){
                        var assert = require('assert')
                        var base58check = require('bs58check')
                        var crypto = require('./crypto')
                        Severity: Major
                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 7 hrs to fix

                          Function 26 has 176 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          },{"./curve":22,"./curves":23,"bigi":3}],26:[function(require,module,exports){
                          (function (Buffer){
                          var assert = require('assert')
                          var BigInteger = require('bigi')
                          
                          
                          Severity: Major
                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 7 hrs to fix

                            Function 14 has 150 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            },{"buffer":46}],14:[function(require,module,exports){
                            (function (Buffer){
                            
                            module.exports = ripemd160
                            
                            
                            Severity: Major
                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 6 hrs to fix

                              Function 28 has 126 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                              },{"./networks":36,"./scripts":39,"./types":42,"assert":44,"bs58check":6,"buffer":46}],28:[function(require,module,exports){
                              (function (Buffer){
                              var assert = require('assert')
                              var opcodes = require('./opcodes')
                              
                              
                              Severity: Major
                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 5 hrs to fix

                                Function 11 has 119 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                },{"./create-hash":7,"./create-hmac":8,"./pbkdf2":20,"./rng":21,"buffer":46}],11:[function(require,module,exports){
                                /*
                                 * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
                                 * Digest Algorithm, as defined in RFC 1321.
                                 * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.
                                Severity: Major
                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 4 hrs to fix

                                  Function 37 has 118 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                  },{}],37:[function(require,module,exports){
                                  module.exports = {
                                    // push value
                                    OP_FALSE     : 0,
                                    OP_0         : 0,
                                  Severity: Major
                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 4 hrs to fix

                                    Function 36 has 113 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                    },{"./bufferutils":28,"./crypto":29,"./ecdsa":30,"./ecpubkey":32,"./ecsignature":33,"./networks":36,"bigi":3,"buffer":46,"ecurve":24}],36:[function(require,module,exports){
                                    // https://en.bitcoin.it/wiki/List_of_address_prefixes
                                    // Dogecoin BIP32 is a proposed standard: https://bitcointalk.org/index.php?topic=409731
                                    
                                    var networks = {
                                    Severity: Major
                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 4 hrs to fix

                                      Function 18 has 106 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                      },{"util":68}],18:[function(require,module,exports){
                                      
                                      /**
                                       * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
                                       * in FIPS 180-2
                                      Severity: Major
                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 4 hrs to fix

                                        Function exports has 103 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                        module.exports = function (Buffer, Hash) {
                                        
                                          var K = [
                                              0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
                                              0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
                                        Severity: Major
                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 4 hrs to fix

                                          Function 30 has 101 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                          },{"crypto":10}],30:[function(require,module,exports){
                                          (function (Buffer){
                                          var assert = require('assert')
                                          var crypto = require('./crypto')
                                          var enforceType = require('./types')
                                          Severity: Major
                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 4 hrs to fix

                                            Function _update has 100 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                              Sha512.prototype._update = function(M) {
                                            
                                                var W = this._w
                                                var a, b, c, d, e, f, g, h
                                                var al, bl, cl, dl, el, fl, gl, hl
                                            Severity: Major
                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 4 hrs to fix

                                              Function 38 has 98 lines of code (exceeds 25 allowed). Consider refactoring.
                                              Open

                                              },{}],38:[function(require,module,exports){
                                              (function (Buffer){
                                              var assert = require('assert')
                                              var bufferutils = require('./bufferutils')
                                              var crypto = require('./crypto')
                                              Severity: Major
                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 3 hrs to fix

                                                Function 47 has 90 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                },{"base64-js":47,"ieee754":48,"is-array":49}],47:[function(require,module,exports){
                                                var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
                                                
                                                ;(function (exports) {
                                                    'use strict';
                                                Severity: Major
                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 3 hrs to fix

                                                  Function 33 has 86 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                  },{"./address":27,"./crypto":29,"./ecdsa":30,"./networks":36,"./types":42,"buffer":46,"ecurve":24}],33:[function(require,module,exports){
                                                  (function (Buffer){
                                                  var assert = require('assert')
                                                  var enforceType = require('./types')
                                                  
                                                  
                                                  Severity: Major
                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 3 hrs to fix

                                                    Function 17 has 84 lines of code (exceeds 25 allowed). Consider refactoring.
                                                    Open

                                                    },{"./hash":15,"./sha1":17,"./sha256":18,"./sha512":19,"buffer":46}],17:[function(require,module,exports){
                                                    /*
                                                     * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
                                                     * in FIPS PUB 180-1
                                                     * Version 2.1a Copyright Paul Johnston 2000 - 2002.
                                                    Severity: Major
                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 3 hrs to fix

                                                      Function core_md5 has 82 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                      function core_md5(x, len)
                                                      {
                                                        /* append padding */
                                                        x[len >> 5] |= 0x80 << ((len) % 32);
                                                        x[(((len + 64) >>> 9) << 4) + 14] = len;
                                                      Severity: Major
                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 3 hrs to fix

                                                        Function exports has 81 lines of code (exceeds 25 allowed). Consider refactoring.
                                                        Open

                                                        module.exports = function (Buffer, Hash) {
                                                        
                                                          var A = 0|0
                                                          var B = 4|0
                                                          var C = 8|0
                                                        Severity: Major
                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 3 hrs to fix

                                                          Function bnModPow has 78 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                          function bnModPow(e, m) {
                                                            var i = e.bitLength(),
                                                              k, r = nbv(1),
                                                              z
                                                            if (i <= 0) return r
                                                          Severity: Major
                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 3 hrs to fix

                                                            Function formatValue has 78 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                            function formatValue(ctx, value, recurseTimes) {
                                                              // Provide a hook for user-specified inspect functions.
                                                              // Check that value is an object with an inspect function on it
                                                              if (ctx.customInspect &&
                                                                  value &&
                                                            Severity: Major
                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 3 hrs to fix

                                                              Function 48 has 73 lines of code (exceeds 25 allowed). Consider refactoring.
                                                              Open

                                                              },{}],48:[function(require,module,exports){
                                                              exports.read = function(buffer, offset, isLE, mLen, nBytes) {
                                                                var e, m,
                                                                    eLen = nBytes * 8 - mLen - 1,
                                                                    eMax = (1 << eLen) - 1,
                                                              Severity: Major
                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                Function 66 has 69 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                Open

                                                                },{}],66:[function(require,module,exports){
                                                                // shim for using process in browser
                                                                
                                                                var process = module.exports = {};
                                                                
                                                                
                                                                Severity: Major
                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                  Function 13 has 65 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                  Open

                                                                  },{"./pbkdf2":13,"crypto":53}],13:[function(require,module,exports){
                                                                  (function (Buffer){
                                                                  module.exports = function(crypto) {
                                                                    function pbkdf2(password, salt, iterations, keylen, digest, callback) {
                                                                      if ('function' === typeof digest) {
                                                                  Severity: Major
                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                    Function 23 has 65 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                    Open

                                                                    },{"./point":26,"assert":44,"bigi":3}],23:[function(require,module,exports){
                                                                    module.exports={
                                                                      "secp128r1": {
                                                                        "p": "fffffffdffffffffffffffffffffffff",
                                                                        "a": "fffffffdfffffffffffffffffffffffc",
                                                                    Severity: Major
                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                      Function processBlock has 64 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                      Open

                                                                      var processBlock = function (H, M, offset) {
                                                                      
                                                                        // Swap endian
                                                                        for (var i = 0; i < 16; i++) {
                                                                          var offset_i = offset + i;
                                                                      Severity: Major
                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                        Function exports has 61 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                        Open

                                                                        module.exports = function(crypto) {
                                                                          function pbkdf2(password, salt, iterations, keylen, digest, callback) {
                                                                            if ('function' === typeof digest) {
                                                                              callback = digest
                                                                              digest = undefined
                                                                        Severity: Major
                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                          Function 4 has 61 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                          Open

                                                                          },{"./bigi":1,"./convert":2}],4:[function(require,module,exports){
                                                                          module.exports={
                                                                            "name": "bigi",
                                                                            "version": "1.3.0",
                                                                            "description": "Big integers.",
                                                                          Severity: Major
                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                            Function fromTransaction has 57 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                            Open

                                                                            TransactionBuilder.fromTransaction = function(transaction) {
                                                                              var txb = new TransactionBuilder()
                                                                            
                                                                              // Extract/add inputs
                                                                              transaction.ins.forEach(function(txin) {
                                                                            Severity: Major
                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                              Function 31 has 57 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                              Open

                                                                              },{"./crypto":29,"./ecsignature":33,"./types":42,"assert":44,"bigi":3,"buffer":46}],31:[function(require,module,exports){
                                                                              (function (Buffer){
                                                                              var assert = require('assert')
                                                                              var base58check = require('bs58check')
                                                                              var crypto = require('crypto')
                                                                              Severity: Major
                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                                Function bnpDivRemTo has 55 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                Open

                                                                                function bnpDivRemTo(m, q, r) {
                                                                                  var self = this
                                                                                  var pm = m.abs()
                                                                                  if (pm.t <= 0) return
                                                                                  var pt = self.abs()
                                                                                Severity: Major
                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                                  Function formatProperty has 54 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                  Open

                                                                                  function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
                                                                                    var name, str, desc;
                                                                                    desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
                                                                                    if (desc.get) {
                                                                                      if (desc.set) {
                                                                                  Severity: Major
                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                                    Function 15 has 53 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                    Open

                                                                                    },{"buffer":46}],15:[function(require,module,exports){
                                                                                    module.exports = function (Buffer) {
                                                                                    
                                                                                      //prototype class for hash functions
                                                                                      function Hash (blockSize, finalSize) {
                                                                                    Severity: Major
                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                                      Function 5 has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                      Open

                                                                                      },{}],5:[function(require,module,exports){
                                                                                      // Base58 encoding/decoding
                                                                                      // Originally written by Mike Hearn for BitcoinJ
                                                                                      // Copyright (c) 2011 Google Inc
                                                                                      // Ported to JavaScript by Stefan Thomas
                                                                                      Severity: Major
                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                                        Function exports has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                        Open

                                                                                        module.exports = function (Buffer) {
                                                                                        
                                                                                          //prototype class for hash functions
                                                                                          function Hash (blockSize, finalSize) {
                                                                                            this._block = new Buffer(blockSize) //new Uint32Array(blockSize/4)
                                                                                        Severity: Major
                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                                          Function write has 50 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                          Open

                                                                                          Buffer.prototype.write = function (string, offset, length, encoding) {
                                                                                            // Support both (string, offset, length, encoding)
                                                                                            // and the legacy (string, encoding, offset, length)
                                                                                            if (isFinite(offset)) {
                                                                                              if (!isFinite(length)) {
                                                                                          Severity: Minor
                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 2 hrs to fix

                                                                                            Function fromBuffer has 49 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                            Open

                                                                                            Transaction.fromBuffer = function(buffer) {
                                                                                              var offset = 0
                                                                                              function readSlice(n) {
                                                                                                offset += n
                                                                                                return buffer.slice(offset - n, offset)
                                                                                            Severity: Minor
                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                              Function 27 has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                              Open

                                                                                              },{"assert":44,"bigi":3,"buffer":46}],27:[function(require,module,exports){
                                                                                              (function (Buffer){
                                                                                              var assert = require('assert')
                                                                                              var base58check = require('bs58check')
                                                                                              var enforceType = require('./types')
                                                                                              Severity: Minor
                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                Function toBuffer has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                Open

                                                                                                Transaction.prototype.toBuffer = function () {
                                                                                                  var txInSize = this.ins.reduce(function(a, x) {
                                                                                                    return a + (40 + bufferutils.varIntSize(x.script.buffer.length) + x.script.buffer.length)
                                                                                                  }, 0)
                                                                                                
                                                                                                
                                                                                                Severity: Minor
                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                  Function bnModInverse has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function bnModInverse(m) {
                                                                                                    var ac = m.isEven()
                                                                                                    if ((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO
                                                                                                    var u = m.clone(),
                                                                                                      v = this.clone()
                                                                                                  Severity: Minor
                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                    Function 22 has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                    Open

                                                                                                    },{"buffer":46,"crypto":45}],22:[function(require,module,exports){
                                                                                                    var assert = require('assert')
                                                                                                    var BigInteger = require('bigi')
                                                                                                    
                                                                                                    var Point = require('./point')
                                                                                                    Severity: Minor
                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                      Function nextTick has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                      Open

                                                                                                      process.nextTick = (function () {
                                                                                                          var canSetImmediate = typeof window !== 'undefined'
                                                                                                          && window.setImmediate;
                                                                                                          var canMutationObserver = typeof window !== 'undefined'
                                                                                                          && window.MutationObserver;
                                                                                                      Severity: Minor
                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                        Function Buffer has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                        Open

                                                                                                        function Buffer (subject, encoding, noZero) {
                                                                                                          if (!(this instanceof Buffer))
                                                                                                            return new Buffer(subject, encoding, noZero)
                                                                                                        
                                                                                                          var type = typeof subject
                                                                                                        Severity: Minor
                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                          Function 10 has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                          Open

                                                                                                          },{"buffer":46}],10:[function(require,module,exports){
                                                                                                          (function (Buffer){
                                                                                                          var rng = require('./rng')
                                                                                                          
                                                                                                          function error () {
                                                                                                          Severity: Minor
                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                            Function _augment has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                            Open

                                                                                                            Buffer._augment = function (arr) {
                                                                                                              arr._isBuffer = true
                                                                                                            
                                                                                                              // save reference to original Uint8Array get/set methods before overwriting
                                                                                                              arr._get = arr.get
                                                                                                            Severity: Minor
                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                              Function 35 has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                              Open

                                                                                                              },{"./crypto":29,"./eckey":31,"./ecpubkey":32,"./networks":36,"./types":42,"assert":44,"bigi":3,"bs58check":6,"buffer":46,"ecurve":24}],35:[function(require,module,exports){
                                                                                                              (function (Buffer){
                                                                                                              var bufferutils = require('./bufferutils')
                                                                                                              var crypto = require('./crypto')
                                                                                                              var ecdsa = require('./ecdsa')
                                                                                                              Severity: Minor
                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                Function createTransaction has 43 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                Open

                                                                                                                Wallet.prototype.createTransaction = function(to, value, options) {
                                                                                                                  // FIXME: remove in 2.0.0
                                                                                                                  if (typeof options !== 'object') {
                                                                                                                    if (options !== undefined) {
                                                                                                                      console.warn('Non options object parameters are deprecated, use options object instead')
                                                                                                                Severity: Minor
                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                  Function write has 43 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                  Open

                                                                                                                  exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
                                                                                                                    var e, m, c,
                                                                                                                        eLen = nBytes * 8 - mLen - 1,
                                                                                                                        eMax = (1 << eLen) - 1,
                                                                                                                        eBias = eMax >> 1,
                                                                                                                  Severity: Minor
                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                    Function __processTx has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                    Open

                                                                                                                    Wallet.prototype.__processTx = function(tx, isPending) {
                                                                                                                      console.warn('processTransaction is considered harmful, see issue #260 for more information')
                                                                                                                    
                                                                                                                      var txId = tx.getId()
                                                                                                                      var txHash = tx.getHash()
                                                                                                                    Severity: Minor
                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                      Function derive has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                      Open

                                                                                                                      HDNode.prototype.derive = function(index) {
                                                                                                                        var isHardened = index >= HDNode.HIGHEST_BIT
                                                                                                                        var indexBuffer = new Buffer(4)
                                                                                                                        indexBuffer.writeUInt32BE(index, 0)
                                                                                                                      
                                                                                                                      
                                                                                                                      Severity: Minor
                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                        Function 2 has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                        Open

                                                                                                                        },{"../package.json":4}],2:[function(require,module,exports){
                                                                                                                        (function (Buffer){
                                                                                                                        // FIXME: Kind of a weird way to throw exceptions, consider removing
                                                                                                                        var assert = require('assert')
                                                                                                                        var BigInteger = require('./bigi')
                                                                                                                        Severity: Minor
                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                          Function bnpFromString has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                          Open

                                                                                                                          function bnpFromString(s, b) {
                                                                                                                            var self = this
                                                                                                                          
                                                                                                                            var k
                                                                                                                            if (b == 16) k = 4
                                                                                                                          Severity: Minor
                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                            Function sign has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                            Open

                                                                                                                            TransactionBuilder.prototype.sign = function(index, privKey, redeemScript, hashType) {
                                                                                                                              assert(this.tx.ins.length >= index, 'No input at index: ' + index)
                                                                                                                              hashType = hashType || Transaction.SIGHASH_ALL
                                                                                                                            
                                                                                                                              var prevOutScript = this.prevOutScripts[index]
                                                                                                                            Severity: Minor
                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                              Function pbkdf2Sync has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                              Open

                                                                                                                                function pbkdf2Sync(password, salt, iterations, keylen, digest) {
                                                                                                                                  if ('number' !== typeof iterations)
                                                                                                                                    throw new TypeError('Iterations not a number')
                                                                                                                              
                                                                                                                                  if (iterations < 0)
                                                                                                                              Severity: Minor
                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                Function 32 has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                Open

                                                                                                                                },{"./ecdsa":30,"./ecpubkey":32,"./networks":36,"./types":42,"assert":44,"bigi":3,"bs58check":6,"buffer":46,"crypto":10,"ecurve":24}],32:[function(require,module,exports){
                                                                                                                                (function (Buffer){
                                                                                                                                var crypto = require('./crypto')
                                                                                                                                var ecdsa = require('./ecdsa')
                                                                                                                                var enforceType = require('./types')
                                                                                                                                Severity: Minor
                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                  Function __build has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                  Open

                                                                                                                                  TransactionBuilder.prototype.__build = function(allowIncomplete) {
                                                                                                                                    if (!allowIncomplete) {
                                                                                                                                      assert(this.tx.ins.length > 0, 'Transaction has no inputs')
                                                                                                                                      assert(this.tx.outs.length > 0, 'Transaction has no outputs')
                                                                                                                                      assert(this.signatures.length > 0, 'Transaction has no signatures')
                                                                                                                                  Severity: Minor
                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                    Function bnToString has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                    Open

                                                                                                                                    function bnToString(b) {
                                                                                                                                      var self = this
                                                                                                                                      if (self.s < 0) return "-" + self.negate()
                                                                                                                                        .toString(b)
                                                                                                                                      var k
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                      Function format has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                      Open

                                                                                                                                      exports.format = function(f) {
                                                                                                                                        if (!isString(f)) {
                                                                                                                                          var objects = [];
                                                                                                                                          for (var i = 0; i < arguments.length; i++) {
                                                                                                                                            objects.push(inspect(arguments[i]));
                                                                                                                                      Severity: Minor
                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                        Function 42 has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                        Open

                                                                                                                                        },{"./ecpubkey":32,"./ecsignature":33,"./script":38,"./scripts":39,"./transaction":40,"assert":44,"buffer":46}],42:[function(require,module,exports){
                                                                                                                                        (function (Buffer){
                                                                                                                                        module.exports = function enforce(type, value) {
                                                                                                                                          switch (type) {
                                                                                                                                            case 'Array': {
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                          Function 8 has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                          Open

                                                                                                                                          },{"./md5":11,"buffer":46,"ripemd160":14,"sha.js":16}],8:[function(require,module,exports){
                                                                                                                                          (function (Buffer){
                                                                                                                                          var createHash = require('./create-hash')
                                                                                                                                          
                                                                                                                                          var zeroBuffer = new Buffer(128)
                                                                                                                                          Severity: Minor
                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                            Function setUnspentOutputs has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                            Open

                                                                                                                                            Wallet.prototype.setUnspentOutputs = function(unspents) {
                                                                                                                                              this.unspentMap = {}
                                                                                                                                              this.unspents = unspents.map(function(unspent) {
                                                                                                                                                // FIXME: remove unspent.hash in 2.0.0
                                                                                                                                                var txId = unspent.txId || unspent.hash
                                                                                                                                            Severity: Minor
                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                              Function toString has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                              Open

                                                                                                                                              Buffer.prototype.toString = function (encoding, start, end) {
                                                                                                                                                var loweredCase = false
                                                                                                                                              
                                                                                                                                                start = start >>> 0
                                                                                                                                                end = end === undefined || end === Infinity ? this.length : end >>> 0
                                                                                                                                              Severity: Minor
                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                Function bnpAddTo has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                Open

                                                                                                                                                function bnpAddTo(a, r) {
                                                                                                                                                  var self = this
                                                                                                                                                
                                                                                                                                                  var i = 0,
                                                                                                                                                    c = 0,
                                                                                                                                                Severity: Minor
                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                  Function 29 has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                  Open

                                                                                                                                                  },{"./opcodes":37,"assert":44,"buffer":46}],29:[function(require,module,exports){
                                                                                                                                                  var crypto = require('crypto')
                                                                                                                                                  
                                                                                                                                                  function hash160(buffer) {
                                                                                                                                                    return ripemd160(sha256(buffer))
                                                                                                                                                  Severity: Minor
                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                    Function objEquiv has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                    Open

                                                                                                                                                    function objEquiv(a, b) {
                                                                                                                                                      if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
                                                                                                                                                        return false;
                                                                                                                                                      // an identical 'prototype' property.
                                                                                                                                                      if (a.prototype !== b.prototype) return false;
                                                                                                                                                    Severity: Minor
                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                      Function bnpSubTo has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                      Open

                                                                                                                                                      function bnpSubTo(a, r) {
                                                                                                                                                        var self = this
                                                                                                                                                        var i = 0,
                                                                                                                                                          c = 0,
                                                                                                                                                          m = Math.min(a.t, self.t)
                                                                                                                                                      Severity: Minor
                                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                        Function 9 has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                        Open

                                                                                                                                                        },{"./create-hash":7,"buffer":46}],9:[function(require,module,exports){
                                                                                                                                                        (function (Buffer){
                                                                                                                                                        var intSize = 4;
                                                                                                                                                        var zeroBuffer = new Buffer(intSize); zeroBuffer.fill(0);
                                                                                                                                                        var chrsz = 8;
                                                                                                                                                        Severity: Minor
                                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                          Function fromBuffer has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                          Open

                                                                                                                                                          HDNode.fromBuffer = function(buffer, __ignoreDeprecation) {
                                                                                                                                                            if (!__ignoreDeprecation) {
                                                                                                                                                              console.warn('HDNode.fromBuffer() is deprecated for removal in 2.x.y, use fromBase58 instead')
                                                                                                                                                            }
                                                                                                                                                          
                                                                                                                                                          
                                                                                                                                                          Severity: Minor
                                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                            Function hashForSignature has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                            Open

                                                                                                                                                            Transaction.prototype.hashForSignature = function(inIndex, prevOutScript, hashType) {
                                                                                                                                                              // FIXME: remove in 2.x.y
                                                                                                                                                              if (arguments[0] instanceof Script) {
                                                                                                                                                                console.warn('hashForSignature(prevOutScript, inIndex, ...) has been deprecated. Use hashForSignature(inIndex, prevOutScript, ...)')
                                                                                                                                                            
                                                                                                                                                            
                                                                                                                                                            Severity: Minor
                                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                              Function unspents has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                this.unspents = unspents.map(function(unspent) {
                                                                                                                                                                  // FIXME: remove unspent.hash in 2.0.0
                                                                                                                                                                  var txId = unspent.txId || unspent.hash
                                                                                                                                                                  var index = unspent.index
                                                                                                                                                              
                                                                                                                                                              
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                Function uint8ToBase64 has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                Open

                                                                                                                                                                    function uint8ToBase64 (uint8) {
                                                                                                                                                                        var i,
                                                                                                                                                                            extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
                                                                                                                                                                            output = "",
                                                                                                                                                                            temp, length
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                  Function slice has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                  Open

                                                                                                                                                                  Buffer.prototype.slice = function (start, end) {
                                                                                                                                                                    var len = this.length
                                                                                                                                                                    start = ~~start
                                                                                                                                                                    end = end === undefined ? len : ~~end
                                                                                                                                                                  
                                                                                                                                                                  
                                                                                                                                                                  Severity: Minor
                                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                    Function 6 has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                    Open

                                                                                                                                                                    },{}],6:[function(require,module,exports){
                                                                                                                                                                    (function (Buffer){
                                                                                                                                                                    'use strict';
                                                                                                                                                                    
                                                                                                                                                                    var assert = require('assert')
                                                                                                                                                                    Severity: Minor
                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                      Function 7 has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                      Open

                                                                                                                                                                      },{"assert":44,"bs58":5,"buffer":46,"crypto":53}],7:[function(require,module,exports){
                                                                                                                                                                      (function (Buffer){
                                                                                                                                                                      var createHash = require('sha.js')
                                                                                                                                                                      
                                                                                                                                                                      var md5 = toConstructor(require('./md5'))
                                                                                                                                                                      Severity: Minor
                                                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                        Function AssertionError has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                        Open

                                                                                                                                                                        assert.AssertionError = function AssertionError(options) {
                                                                                                                                                                          this.name = 'AssertionError';
                                                                                                                                                                          this.actual = options.actual;
                                                                                                                                                                          this.expected = options.expected;
                                                                                                                                                                          this.operator = options.operator;
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                          Function bnGCD has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                          Open

                                                                                                                                                                          function bnGCD(a) {
                                                                                                                                                                            var x = (this.s < 0) ? this.negate() : this.clone()
                                                                                                                                                                            var y = (a.s < 0) ? a.negate() : a.clone()
                                                                                                                                                                            if (x.compareTo(y) < 0) {
                                                                                                                                                                              var t = x
                                                                                                                                                                          Severity: Minor
                                                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                            Function byteLength has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                            Open

                                                                                                                                                                            Buffer.byteLength = function (str, encoding) {
                                                                                                                                                                              var ret
                                                                                                                                                                              str = str + ''
                                                                                                                                                                              switch (encoding || 'utf8') {
                                                                                                                                                                                case 'ascii':
                                                                                                                                                                            Severity: Minor
                                                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                              Function Wallet has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                              Open

                                                                                                                                                                              function Wallet(seed, network) {
                                                                                                                                                                                seed = seed || crypto.randomBytes(32)
                                                                                                                                                                                network = network || networks.bitcoin
                                                                                                                                                                              
                                                                                                                                                                                // Stored in a closure to make accidental serialization less likely
                                                                                                                                                                              Severity: Minor
                                                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                                Function _update has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                                Open

                                                                                                                                                                                  Sha256.prototype._update = function(M) {
                                                                                                                                                                                
                                                                                                                                                                                    var W = this._w
                                                                                                                                                                                    var a, b, c, d, e, f, g, h
                                                                                                                                                                                    var T1, T2
                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                                  Function b64ToByteArray has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                                  Open

                                                                                                                                                                                      function b64ToByteArray (b64) {
                                                                                                                                                                                          var i, j, l, tmp, placeHolders, arr
                                                                                                                                                                                  
                                                                                                                                                                                          if (b64.length % 4 > 0) {
                                                                                                                                                                                              throw new Error('Invalid string. Length must be a multiple of 4')
                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                                    Function bnpFromRadix has 27 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                                    Open

                                                                                                                                                                                    function bnpFromRadix(s, b) {
                                                                                                                                                                                      var self = this
                                                                                                                                                                                      self.fromInt(0)
                                                                                                                                                                                      if (b == null) b = 10
                                                                                                                                                                                      var cs = self.chunkSize(b)
                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                                      Function read has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                                      Open

                                                                                                                                                                                      exports.read = function(buffer, offset, isLE, mLen, nBytes) {
                                                                                                                                                                                        var e, m,
                                                                                                                                                                                            eLen = nBytes * 8 - mLen - 1,
                                                                                                                                                                                            eMax = (1 << eLen) - 1,
                                                                                                                                                                                            eBias = eMax >> 1,
                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                                        Function bnToByteArray has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                                        Open

                                                                                                                                                                                        function bnToByteArray() {
                                                                                                                                                                                          var self = this
                                                                                                                                                                                          var i = self.t,
                                                                                                                                                                                            r = new Array()
                                                                                                                                                                                          r[0] = self.s
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                                          Function enforce has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                                          Open

                                                                                                                                                                                          module.exports = function enforce(type, value) {
                                                                                                                                                                                            switch (type) {
                                                                                                                                                                                              case 'Array': {
                                                                                                                                                                                                if (Array.isArray(value)) return
                                                                                                                                                                                                break
                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 1 hr to fix

                                                                                                                                                                                            Function Curve has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                            Open

                                                                                                                                                                                            function Curve(p, a, b, Gx, Gy, n, h) {
                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 50 mins to fix

                                                                                                                                                                                              Function md5_gg has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                              Open

                                                                                                                                                                                              function md5_gg(a, b, c, d, x, s, t)
                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 50 mins to fix

                                                                                                                                                                                                Function md5_ff has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                Open

                                                                                                                                                                                                function md5_ff(a, b, c, d, x, s, t)
                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 50 mins to fix

                                                                                                                                                                                                  Function md5_hh has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                  Open

                                                                                                                                                                                                  function md5_hh(a, b, c, d, x, s, t)
                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 50 mins to fix

                                                                                                                                                                                                    Function md5_ii has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                    Open

                                                                                                                                                                                                    function md5_ii(a, b, c, d, x, s, t)
                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 50 mins to fix

                                                                                                                                                                                                      Function md5_cmn has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                      Open

                                                                                                                                                                                                      function md5_cmn(q, a, b, x, s, t)
                                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 45 mins to fix

                                                                                                                                                                                                        Function am3 has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                        Open

                                                                                                                                                                                                        function am3(i, x, w, j, c, n) {
                                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 45 mins to fix

                                                                                                                                                                                                          Function am1 has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                          Open

                                                                                                                                                                                                          function am1(i, x, w, j, c, n) {
                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 45 mins to fix

                                                                                                                                                                                                            Function am2 has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                            Open

                                                                                                                                                                                                            function am2(i, x, w, j, c, n) {
                                                                                                                                                                                                            Severity: Minor
                                                                                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 45 mins to fix

                                                                                                                                                                                                              Function pbkdf2 has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                              Open

                                                                                                                                                                                                                function pbkdf2(password, salt, iterations, keylen, digest, callback) {
                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 45 mins to fix

                                                                                                                                                                                                                Function checkInt has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                Open

                                                                                                                                                                                                                function checkInt (buf, value, offset, ext, max, min) {
                                                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 45 mins to fix

                                                                                                                                                                                                                  Function write has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                  exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
                                                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 45 mins to fix

                                                                                                                                                                                                                    Function checkIEEE754 has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                    function checkIEEE754 (buf, value, offset, ext, max, min) {
                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 45 mins to fix

                                                                                                                                                                                                                      Function formatProperty has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                      function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
                                                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 45 mins to fix

                                                                                                                                                                                                                        Consider simplifying this complex logical expression.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                          if (ctx.customInspect &&
                                                                                                                                                                                                                              value &&
                                                                                                                                                                                                                              isFunction(value.inspect) &&
                                                                                                                                                                                                                              // Filter out the util module, it's inspect function is special
                                                                                                                                                                                                                              value.inspect !== exports.inspect &&
                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 40 mins to fix

                                                                                                                                                                                                                          Consider simplifying this complex logical expression.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                            } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
                                                                                                                                                                                                                              return actual.source === expected.source &&
                                                                                                                                                                                                                                     actual.global === expected.global &&
                                                                                                                                                                                                                                     actual.multiline === expected.multiline &&
                                                                                                                                                                                                                                     actual.lastIndex === expected.lastIndex &&
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 40 mins to fix

                                                                                                                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                              if ((shouldThrow && actual && expected &&
                                                                                                                                                                                                                                  !expectedException(actual, expected)) || (!shouldThrow && actual)) {
                                                                                                                                                                                                                                throw actual;
                                                                                                                                                                                                                              }
                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 40 mins to fix

                                                                                                                                                                                                                              Function writeDouble has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                              function writeDouble (buf, value, offset, littleEndian, noAssert) {
                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 35 mins to fix

                                                                                                                                                                                                                                Function writeFloat has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                function writeFloat (buf, value, offset, littleEndian, noAssert) {
                                                                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 35 mins to fix

                                                                                                                                                                                                                                  Function formatArray has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                  function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
                                                                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 35 mins to fix

                                                                                                                                                                                                                                    Function read has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                    exports.read = function(buffer, offset, isLE, mLen, nBytes) {
                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 35 mins to fix

                                                                                                                                                                                                                                      Function pbkdf2Sync has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                        function pbkdf2Sync(password, salt, iterations, keylen, digest) {
                                                                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 35 mins to fix

                                                                                                                                                                                                                                        Function fail has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                        function fail(actual, expected, message, operator, stackStartFunction) {
                                                                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 35 mins to fix

                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                            else return d
                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                              if (mOp > ops.OP_16) return false
                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                return pubKeys.every(isCanonicalPubKey)
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                    return actual == expected;
                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                        return ctx.stylize('[Object]', 'special');
                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                      return v.signum() === 0
                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                        if (nOp > ops.OP_16) return false
                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                            return actual.getTime() === expected.getTime();
                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              return ctx.stylize('null', 'null');
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                              if (nOp === ops.OP_0) return false
                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                          return code - UPPER
                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                    return 'nulldata'
                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                      return actual.source === expected.source &&
                                                                                                                                                                                                                                                                             actual.global === expected.global &&
                                                                                                                                                                                                                                                                             actual.multiline === expected.multiline &&
                                                                                                                                                                                                                                                                             actual.lastIndex === expected.lastIndex &&
                                                                                                                                                                                                                                                                             actual.ignoreCase === expected.ignoreCase;
                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                        return objEquiv(actual, expected);
                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                        return new Point(this.curve, x3, y3, z3)
                                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                          if (n < m) return false
                                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                return false;
                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                              return true;
                                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                  return braces[0] + base + braces[1];
                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                    if (!_deepEqual(a[key], b[key])) return false;
                                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                      return false;
                                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                      return false;
                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                        return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0]
                                                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                          return 'nonstandard'
                                                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                                      return code - LOWER + 26
                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                              if (d.signum() < 0) return d.add(m)
                                                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                                return reduceToSingleString(output, base, braces);
                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                                      if (typeof value === 'string') return
                                                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                                        if (getName(value.constructor) === getName(type)) return
                                                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                        return false;
                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                                            return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
                                                                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                                                                      Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                                              return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
                                                                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                                                                        Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                                            if (nOp < ops.OP_1) return false
                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                          Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                                              if (n < pubKeys.length) return false
                                                                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                                                                            Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                                                return 'nonstandard'
                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                              Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                                                      return ctx.stylize(Date.prototype.toString.call(value), 'date');
                                                                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                                                                Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                                                        return formatError(value);
                                                                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                                                                  Found in src/vendors/bitcoinjs-lib/bitcoinjs.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      for (var i = 0; i < 80; i += 1) {
                                                                                                                                                                                                                                                                                                                        t = (al +  M[offset+zl[i]])|0;
                                                                                                                                                                                                                                                                                                                        if (i<16){
                                                                                                                                                                                                                                                                                                                            t +=  f1(bl,cl,dl) + hl[0];
                                                                                                                                                                                                                                                                                                                        } else if (i<32) {
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4155..4197

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 561.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.bitcoin=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    // (public) Constructor
                                                                                                                                                                                                                                                                                                                    function BigInteger(a, b, c) {
                                                                                                                                                                                                                                                                                                                      if (!(this instanceof BigInteger))
                                                                                                                                                                                                                                                                                                                        return new BigInteger(a, b, c)
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 1..6576

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 292.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (a.t < self.t) {
                                                                                                                                                                                                                                                                                                                        c += a.s
                                                                                                                                                                                                                                                                                                                        while (i < self.t) {
                                                                                                                                                                                                                                                                                                                          c += self[i]
                                                                                                                                                                                                                                                                                                                          r[i++] = c & self.DM
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 351..367

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 183.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (a.t < self.t) {
                                                                                                                                                                                                                                                                                                                        c -= a.s
                                                                                                                                                                                                                                                                                                                        while (i < self.t) {
                                                                                                                                                                                                                                                                                                                          c += self[i]
                                                                                                                                                                                                                                                                                                                          r[i++] = c & self.DM
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 1003..1019

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 183.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                        while (v.isEven()) {
                                                                                                                                                                                                                                                                                                                          v.rShiftTo(1, v)
                                                                                                                                                                                                                                                                                                                          if (ac) {
                                                                                                                                                                                                                                                                                                                            if (!c.isEven() || !d.isEven()) {
                                                                                                                                                                                                                                                                                                                              c.addTo(this, c)
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 1347..1357

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 136.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                        while (u.isEven()) {
                                                                                                                                                                                                                                                                                                                          u.rShiftTo(1, u)
                                                                                                                                                                                                                                                                                                                          if (ac) {
                                                                                                                                                                                                                                                                                                                            if (!a.isEven() || !b.isEven()) {
                                                                                                                                                                                                                                                                                                                              a.addTo(this, a)
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 1358..1368

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 136.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Buffer.prototype.readUInt32LE = function (offset, noAssert) {
                                                                                                                                                                                                                                                                                                                      if (!noAssert)
                                                                                                                                                                                                                                                                                                                        checkOffset(offset, 4, this.length)
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                      return ((this[offset]) |
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7268..7276

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 96.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Buffer.prototype.readInt32LE = function (offset, noAssert) {
                                                                                                                                                                                                                                                                                                                      if (!noAssert)
                                                                                                                                                                                                                                                                                                                        checkOffset(offset, 4, this.length)
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                      return (this[offset]) |
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7226..7234

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 96.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Wallet.prototype.generateAddress = function() {
                                                                                                                                                                                                                                                                                                                      var k = this.addresses.length
                                                                                                                                                                                                                                                                                                                      var address = this.getExternalAccount().derive(k).getAddress()
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                      this.addresses.push(address.toString())
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6156..6163

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 96.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Wallet.prototype.generateChangeAddress = function() {
                                                                                                                                                                                                                                                                                                                      var k = this.changeAddresses.length
                                                                                                                                                                                                                                                                                                                      var address = this.getInternalAccount().derive(k).getAddress()
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                      this.changeAddresses.push(address.toString())
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6147..6154

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 96.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (Buffer.TYPED_ARRAY_SUPPORT) {
                                                                                                                                                                                                                                                                                                                        this[offset] = (value >>> 24)
                                                                                                                                                                                                                                                                                                                        this[offset + 1] = (value >>> 16)
                                                                                                                                                                                                                                                                                                                        this[offset + 2] = (value >>> 8)
                                                                                                                                                                                                                                                                                                                        this[offset + 3] = value
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7450..7455

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 90.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (Buffer.TYPED_ARRAY_SUPPORT) {
                                                                                                                                                                                                                                                                                                                        this[offset] = (value >>> 24)
                                                                                                                                                                                                                                                                                                                        this[offset + 1] = (value >>> 16)
                                                                                                                                                                                                                                                                                                                        this[offset + 2] = (value >>> 8)
                                                                                                                                                                                                                                                                                                                        this[offset + 3] = value
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7386..7391

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 90.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    var sl = [
                                                                                                                                                                                                                                                                                                                         11, 14, 15, 12,  5,  8,  7,  9, 11, 13, 14, 15,  6,  7,  9,  8,
                                                                                                                                                                                                                                                                                                                        7, 6,   8, 13, 11,  9,  7, 15,  7, 12, 15,  9, 11,  7, 13, 12,
                                                                                                                                                                                                                                                                                                                        11, 13,  6,  7, 14,  9, 13, 15, 14,  8, 13,  6,  5, 12,  7,  5,
                                                                                                                                                                                                                                                                                                                          11, 12, 14, 15, 14, 15,  9,  8,  9, 14,  5,  6,  8,  6,  5, 12,
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2201..2206
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2213..2218

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 88.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    var sr = [
                                                                                                                                                                                                                                                                                                                        8,  9,  9, 11, 13, 15, 15,  5,  7,  7,  8, 11, 14, 14, 12,  6,
                                                                                                                                                                                                                                                                                                                        9, 13, 15,  7, 12,  8,  9, 11,  7,  7, 12,  7,  6, 15, 13, 11,
                                                                                                                                                                                                                                                                                                                        9,  7, 15, 11,  8,  6,  6, 14, 12, 13,  5, 14, 13, 13,  7,  5,
                                                                                                                                                                                                                                                                                                                        15,  5,  8, 11, 14, 14,  6, 14,  6,  9, 12,  9, 12,  5, 15,  8,
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2201..2206
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2207..2212

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 88.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    var zr = [
                                                                                                                                                                                                                                                                                                                        5, 14,  7,  0,  9,  2, 11,  4, 13,  6, 15,  8,  1, 10,  3, 12,
                                                                                                                                                                                                                                                                                                                        6, 11,  3,  7,  0, 13,  5, 10, 14, 15,  8, 12,  4,  9,  1,  2,
                                                                                                                                                                                                                                                                                                                        15,  5,  1,  3,  7, 14,  6,  9, 11,  8, 12,  2, 10,  0,  4, 13,
                                                                                                                                                                                                                                                                                                                        8,  6,  4,  1,  3, 11, 15,  0,  5, 12,  2, 13,  9,  7, 10, 14,
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2207..2212
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2213..2218

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 88.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    var wordsToBytes = function (words) {
                                                                                                                                                                                                                                                                                                                      var bytes = [];
                                                                                                                                                                                                                                                                                                                      for (var b = 0; b < words.length * 32; b += 8) {
                                                                                                                                                                                                                                                                                                                        bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                                                                                    src/js/util/convert.js on lines 172..178

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 83.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      var txOutSize = this.outs.reduce(function(a, x) {
                                                                                                                                                                                                                                                                                                                        return a + (8 + bufferutils.varIntSize(x.script.buffer.length) + x.script.buffer.length)
                                                                                                                                                                                                                                                                                                                      }, 0)
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 5383..5385

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 74.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      var txInSize = this.ins.reduce(function(a, x) {
                                                                                                                                                                                                                                                                                                                        return a + (40 + bufferutils.varIntSize(x.script.buffer.length) + x.script.buffer.length)
                                                                                                                                                                                                                                                                                                                      }, 0)
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 5387..5389

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 74.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      litecoin: {
                                                                                                                                                                                                                                                                                                                        magicPrefix: '\x19Litecoin Signed Message:\n',
                                                                                                                                                                                                                                                                                                                        bip32: {
                                                                                                                                                                                                                                                                                                                          public: 0x019da462,
                                                                                                                                                                                                                                                                                                                          private: 0x019d9cfe
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4647..4660

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 72.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Wallet.prototype.getAddress = function() {
                                                                                                                                                                                                                                                                                                                      if (this.addresses.length === 0) {
                                                                                                                                                                                                                                                                                                                        this.generateAddress()
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6187..6193

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 72.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Wallet.prototype.getChangeAddress = function() {
                                                                                                                                                                                                                                                                                                                      if (this.changeAddresses.length === 0) {
                                                                                                                                                                                                                                                                                                                        this.generateChangeAddress()
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6165..6171

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 72.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      dogecoin: {
                                                                                                                                                                                                                                                                                                                        magicPrefix: '\x19Dogecoin Signed Message:\n',
                                                                                                                                                                                                                                                                                                                        bip32: {
                                                                                                                                                                                                                                                                                                                          public: 0x02facafd,
                                                                                                                                                                                                                                                                                                                          private: 0x02fac398
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4661..4674

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 72.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      for (var i = 0, b = 0; i < bytes.length; i++, b += 8) {
                                                                                                                                                                                                                                                                                                                        words[b >>> 5] |= bytes[i] << (24 - b % 32);
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/js/util/convert.js on lines 166..168

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 70.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      for (var i = 0; i < 5; i++) {
                                                                                                                                                                                                                                                                                                                          // Shortcut
                                                                                                                                                                                                                                                                                                                        var H_i = H[i];
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                        // Swap
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4231..4238

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 68.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      var u = other.y.multiply(this.z).subtract(this.y.multiply(other.z)).mod(this.curve.p)
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 3285..3285

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 65.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                                tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7793..7793

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 65.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      bitcoin: {
                                                                                                                                                                                                                                                                                                                        magicPrefix: '\x18Bitcoin Signed Message:\n',
                                                                                                                                                                                                                                                                                                                        bip32: {
                                                                                                                                                                                                                                                                                                                          public: 0x0488b21e,
                                                                                                                                                                                                                                                                                                                          private: 0x0488ade4
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4716..4728

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 65.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      var v = other.x.multiply(this.z).subtract(this.x.multiply(other.z)).mod(this.curve.p)
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 3280..3280

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 65.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                                tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7803..7803

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 65.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      zetacoin: {
                                                                                                                                                                                                                                                                                                                        magicPrefix: '\x18Zetacoin Signed Message:\n',
                                                                                                                                                                                                                                                                                                                        bip32: {
                                                                                                                                                                                                                                                                                                                          public: 0x0488b21e,
                                                                                                                                                                                                                                                                                                                          private: 0x0488ade4
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4634..4646

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 65.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Object.defineProperty(Point.prototype, 'affineX', {
                                                                                                                                                                                                                                                                                                                      get: function() {
                                                                                                                                                                                                                                                                                                                        return this.x.multiply(this.zInv).mod(this.curve.p)
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    })
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 3264..3268

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 63.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      m[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
                                                                                                                                                                                                                                                                                                                          (((nBitsTotal << 8)  | (nBitsTotal >>> 24)) & 0x00ff00ff) |
                                                                                                                                                                                                                                                                                                                          (((nBitsTotal << 24) | (nBitsTotal >>> 8))  & 0xff00ff00)
                                                                                                                                                                                                                                                                                                                      );
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2719..2722
                                                                                                                                                                                                                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 2723..2726
                                                                                                                                                                                                                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4217..4220

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 63.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Object.defineProperty(Point.prototype, 'affineY', {
                                                                                                                                                                                                                                                                                                                      get: function() {
                                                                                                                                                                                                                                                                                                                        return this.y.multiply(this.zInv).mod(this.curve.p)
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    })
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 3258..3262

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 63.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    },{"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/helpers.js":9,"buffer":46}],53:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    module.exports=require(10)
                                                                                                                                                                                                                                                                                                                    },{"./create-hash":50,"./create-hmac":51,"./pbkdf2":63,"./rng":64,"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/index.js":10,"buffer":46}],54:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7994..7996

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 62.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      while (i < m) {
                                                                                                                                                                                                                                                                                                                        c += self[i] + a[i]
                                                                                                                                                                                                                                                                                                                        r[i++] = c & self.DM
                                                                                                                                                                                                                                                                                                                        c >>= self.DB
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 346..350

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 62.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      while (i < m) {
                                                                                                                                                                                                                                                                                                                        c += self[i] - a[i]
                                                                                                                                                                                                                                                                                                                        r[i++] = c & self.DM
                                                                                                                                                                                                                                                                                                                        c >>= self.DB
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 998..1002

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 62.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    },{"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/node_modules/sha.js/hash.js":15}],59:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    module.exports=require(16)
                                                                                                                                                                                                                                                                                                                    },{"./hash":58,"./sha1":60,"./sha256":61,"./sha512":62,"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/node_modules/sha.js/index.js":16,"buffer":46}],60:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7982..7984

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 62.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    function bnShiftRight(n) {
                                                                                                                                                                                                                                                                                                                      var r = new BigInteger()
                                                                                                                                                                                                                                                                                                                      if (n < 0) this.lShiftTo(-n, r)
                                                                                                                                                                                                                                                                                                                      else this.rShiftTo(n, r)
                                                                                                                                                                                                                                                                                                                      return r
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 897..902

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 61.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    function bnShiftLeft(n) {
                                                                                                                                                                                                                                                                                                                      var r = new BigInteger()
                                                                                                                                                                                                                                                                                                                      if (n < 0) this.rShiftTo(-n, r)
                                                                                                                                                                                                                                                                                                                      else this.lShiftTo(n, r)
                                                                                                                                                                                                                                                                                                                      return r
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 905..910

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 61.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      return this.unspents.filter(function(unspent) {
                                                                                                                                                                                                                                                                                                                        return unspent.confirmations >= minConf
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                      // FIXME: remove spent filter in 2.0.0
                                                                                                                                                                                                                                                                                                                      }).filter(function(unspent) {
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6220..6238

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 60.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      return this.unspents.filter(function(unspent) {
                                                                                                                                                                                                                                                                                                                        return unspent.confirmations >= minConf
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                      // FIXME: remove spent filter in 2.0.0
                                                                                                                                                                                                                                                                                                                      }).filter(function(unspent) {
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6176..6184

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 60.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      } else if (isScriptHashOutput(script)) {
                                                                                                                                                                                                                                                                                                                        return 'scripthash'
                                                                                                                                                                                                                                                                                                                      } else if (isMultisigOutput(script)) {
                                                                                                                                                                                                                                                                                                                        return 'multisig'
                                                                                                                                                                                                                                                                                                                      } else if (isPubKeyOutput(script)) {
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 5171..5179

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 59.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (isPubKeyHashInput(script)) {
                                                                                                                                                                                                                                                                                                                        return 'pubkeyhash'
                                                                                                                                                                                                                                                                                                                      } else if (isScriptHashInput(script)) {
                                                                                                                                                                                                                                                                                                                        return 'scripthash'
                                                                                                                                                                                                                                                                                                                      } else if (isMultisigInput(script)) {
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 5155..5163

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 59.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Buffer.prototype.readDoubleLE = function (offset, noAssert) {
                                                                                                                                                                                                                                                                                                                      if (!noAssert)
                                                                                                                                                                                                                                                                                                                        checkOffset(offset, 8, this.length)
                                                                                                                                                                                                                                                                                                                      return ieee754.read(this, offset, true, 52, 8)
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7288..7292
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7294..7298
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7306..7310

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Buffer.prototype.readFloatLE = function (offset, noAssert) {
                                                                                                                                                                                                                                                                                                                      if (!noAssert)
                                                                                                                                                                                                                                                                                                                        checkOffset(offset, 4, this.length)
                                                                                                                                                                                                                                                                                                                      return ieee754.read(this, offset, true, 23, 4)
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7294..7298
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7300..7304
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7306..7310

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    function writeDouble (buf, value, offset, littleEndian, noAssert) {
                                                                                                                                                                                                                                                                                                                      if (!noAssert)
                                                                                                                                                                                                                                                                                                                        checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
                                                                                                                                                                                                                                                                                                                      ieee754.write(buf, value, offset, littleEndian, 52, 8)
                                                                                                                                                                                                                                                                                                                      return offset + 8
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7464..7469

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Buffer.prototype.readDoubleBE = function (offset, noAssert) {
                                                                                                                                                                                                                                                                                                                      if (!noAssert)
                                                                                                                                                                                                                                                                                                                        checkOffset(offset, 8, this.length)
                                                                                                                                                                                                                                                                                                                      return ieee754.read(this, offset, false, 52, 8)
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7288..7292
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7294..7298
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7300..7304

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    Buffer.prototype.readFloatBE = function (offset, noAssert) {
                                                                                                                                                                                                                                                                                                                      if (!noAssert)
                                                                                                                                                                                                                                                                                                                        checkOffset(offset, 4, this.length)
                                                                                                                                                                                                                                                                                                                      return ieee754.read(this, offset, false, 23, 4)
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7288..7292
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7300..7304
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7306..7310

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    function writeFloat (buf, value, offset, littleEndian, noAssert) {
                                                                                                                                                                                                                                                                                                                      if (!noAssert)
                                                                                                                                                                                                                                                                                                                        checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
                                                                                                                                                                                                                                                                                                                      ieee754.write(buf, value, offset, littleEndian, 23, 4)
                                                                                                                                                                                                                                                                                                                      return offset + 4
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7479..7484

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 56.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      var u = y2.multiply(this.z).subtract(y1.multiply(b.z)).mod(this.curve.p)
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 3308..3308

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 54.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      var v = x2.multiply(this.z).subtract(x1.multiply(b.z)).mod(this.curve.p)
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 3306..3306

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 54.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    assert.strictEqual = function strictEqual(actual, expected, message) {
                                                                                                                                                                                                                                                                                                                      if (actual !== expected) {
                                                                                                                                                                                                                                                                                                                        fail(actual, expected, message, '===', assert.strictEqual);
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6476..6480

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    assert.notEqual = function notEqual(actual, expected, message) {
                                                                                                                                                                                                                                                                                                                      if (actual == expected) {
                                                                                                                                                                                                                                                                                                                        fail(actual, expected, message, '!=', assert.notEqual);
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6595..6599

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 53.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (Buffer.TYPED_ARRAY_SUPPORT) {
                                                                                                                                                                                                                                                                                                                        this[offset] = (value >>> 8)
                                                                                                                                                                                                                                                                                                                        this[offset + 1] = value
                                                                                                                                                                                                                                                                                                                      } else objectWriteUInt16(this, value, offset, false)
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7423..7426

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    },{"./ecdsa":30,"./ecpubkey":32,"./networks":36,"./types":42,"assert":44,"bigi":3,"bs58check":6,"buffer":46,"crypto":10,"ecurve":24}],32:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 3 other locations - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4570..4570
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 5635..5635
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6317..6317

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (end < 0) {
                                                                                                                                                                                                                                                                                                                        end += len
                                                                                                                                                                                                                                                                                                                        if (end < 0)
                                                                                                                                                                                                                                                                                                                          end = 0
                                                                                                                                                                                                                                                                                                                      } else if (end > len) {
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7167..7173

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (start < 0) {
                                                                                                                                                                                                                                                                                                                        start += len;
                                                                                                                                                                                                                                                                                                                        if (start < 0)
                                                                                                                                                                                                                                                                                                                          start = 0
                                                                                                                                                                                                                                                                                                                      } else if (start > len) {
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7175..7181

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (Buffer.TYPED_ARRAY_SUPPORT) {
                                                                                                                                                                                                                                                                                                                        this[offset] = (value >>> 8)
                                                                                                                                                                                                                                                                                                                        this[offset + 1] = value
                                                                                                                                                                                                                                                                                                                      } else objectWriteUInt16(this, value, offset, false)
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7353..7356

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    },{"./address":27,"./bufferutils":28,"./crypto":29,"./ecsignature":33,"./opcodes":37,"./script":38,"./scripts":39,"./types":42,"assert":44,"buffer":46}],41:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 3 other locations - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4072..4072
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4570..4570
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6317..6317

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    },{"./address":27,"./bufferutils":28,"./hdnode":34,"./networks":36,"./script":38,"./transaction_builder":41,"./types":42,"assert":44,"buffer":46,"crypto":10}],44:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 3 other locations - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4072..4072
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4570..4570
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 5635..5635

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (Buffer.TYPED_ARRAY_SUPPORT) {
                                                                                                                                                                                                                                                                                                                        this[offset] = value
                                                                                                                                                                                                                                                                                                                        this[offset + 1] = (value >>> 8)
                                                                                                                                                                                                                                                                                                                      } else objectWriteUInt16(this, value, offset, true)
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7341..7344

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (Buffer.TYPED_ARRAY_SUPPORT) {
                                                                                                                                                                                                                                                                                                                        this[offset] = value
                                                                                                                                                                                                                                                                                                                        this[offset + 1] = (value >>> 8)
                                                                                                                                                                                                                                                                                                                      } else objectWriteUInt16(this, value, offset, true)
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7411..7414

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 4 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    },{"./crypto":29,"./eckey":31,"./ecpubkey":32,"./networks":36,"./types":42,"assert":44,"bigi":3,"bs58check":6,"buffer":46,"ecurve":24}],35:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 3 other locations - About 50 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4072..4072
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 5635..5635
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 6317..6317

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 52.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                        this._c = (this._c + c + ((this._cl >>> 0) < (cl >>> 0) ? 1 : 0)) | 0
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 7 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2973..2973
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2974..2974
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2976..2976
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2977..2977
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2978..2978
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2979..2979
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2980..2980

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 49.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                        this._f = (this._f + f + ((this._fl >>> 0) < (fl >>> 0) ? 1 : 0)) | 0
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 7 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2973..2973
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2974..2974
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2975..2975
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2976..2976
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2977..2977
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2979..2979
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2980..2980

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 49.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                        this._g = (this._g + g + ((this._gl >>> 0) < (gl >>> 0) ? 1 : 0)) | 0
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 7 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2973..2973
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2974..2974
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2975..2975
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2976..2976
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2977..2977
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2978..2978
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2980..2980

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 49.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                        this._h = (this._h + h + ((this._hl >>> 0) < (hl >>> 0) ? 1 : 0)) | 0
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 7 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2973..2973
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2974..2974
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2975..2975
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2976..2976
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2977..2977
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2978..2978
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2979..2979

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 49.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                        this._e = (this._e + e + ((this._el >>> 0) < (el >>> 0) ? 1 : 0)) | 0
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 7 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2973..2973
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2974..2974
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2975..2975
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2976..2976
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2978..2978
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2979..2979
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2980..2980

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 49.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                        this._b = (this._b + b + ((this._bl >>> 0) < (bl >>> 0) ? 1 : 0)) | 0
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 7 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2973..2973
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2975..2975
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2976..2976
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2977..2977
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2978..2978
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2979..2979
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2980..2980

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 49.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                        this._a = (this._a + a + ((this._al >>> 0) < (al >>> 0) ? 1 : 0)) | 0
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 7 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2974..2974
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2975..2975
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2976..2976
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2977..2977
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2978..2978
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2979..2979
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2980..2980

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 49.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 8 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                        this._d = (this._d + d + ((this._dl >>> 0) < (dl >>> 0) ? 1 : 0)) | 0
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 7 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2973..2973
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2974..2974
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2975..2975
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2977..2977
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2978..2978
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2979..2979
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 2980..2980

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 49.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    },{"./md5":54,"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/create-hash.js":7,"buffer":46,"ripemd160":57,"sha.js":59}],51:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    module.exports=require(8)
                                                                                                                                                                                                                                                                                                                    },{"./create-hash":50,"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/create-hmac.js":8,"buffer":46}],52:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 2 other locations - About 35 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7986..7988
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 8004..8006

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    module.exports = {
                                                                                                                                                                                                                                                                                                                      pushDataSize: pushDataSize,
                                                                                                                                                                                                                                                                                                                      readPushDataInt: readPushDataInt,
                                                                                                                                                                                                                                                                                                                      readUInt64LE: readUInt64LE,
                                                                                                                                                                                                                                                                                                                      readVarInt: readVarInt,
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                                                                                    src/js/model/tx.js on lines 112..112

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    },{"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/pbkdf2.js":20,"pbkdf2-compat":55}],64:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    module.exports=require(21)
                                                                                                                                                                                                                                                                                                                    },{"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/rng.js":21,"buffer":46,"crypto":45}],65:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 2 other locations - About 35 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7978..7980
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7986..7988

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (rLen > 1 && rB.readUInt8(0) === 0x00) {
                                                                                                                                                                                                                                                                                                                        assert(rB.readUInt8(1) & 0x80, 'R value excessively padded')
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4189..4191

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                      if (sLen > 1 && sB.readUInt8(0) === 0x00) {
                                                                                                                                                                                                                                                                                                                        assert(sB.readUInt8(1) & 0x80, 'S value excessively padded')
                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 4185..4187

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    },{"./helpers":52,"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/md5.js":11}],55:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    module.exports=require(12)
                                                                                                                                                                                                                                                                                                                    },{"./pbkdf2":56,"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/node_modules/pbkdf2-compat/index.js":12,"crypto":53}],56:[function(require,module,exports){
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 2 other locations - About 35 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 7978..7980
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 8004..8006

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 47.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                            : rol(w[j - 3] ^ w[j -  8] ^ w[j - 14] ^ w[j - 16], 1)
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/crypto-js/cryptojs.js on lines 4372..4372

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 45.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    function bnByteValue() {
                                                                                                                                                                                                                                                                                                                      return (this.t == 0) ? this.s : (this[0] << 24) >> 24
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 687..689

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 45.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                    function bnShortValue() {
                                                                                                                                                                                                                                                                                                                      return (this.t == 0) ? this.s : (this[0] << 16) >> 16
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                                    Found in src/vendors/bitcoinjs-lib/bitcoinjs.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                                                                                    src/vendors/bitcoinjs-lib/bitcoinjs.js on lines 682..684

                                                                                                                                                                                                                                                                                                                    Duplicated Code

                                                                                                                                                                                                                                                                                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                    Tuning

                                                                                                                                                                                                                                                                                                                    This issue has a mass of 45.

                                                                                                                                                                                                                                                                                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                    Refactorings

                                                                                                                                                                                                                                                                                                                    Further Reading

                                                                                                                                                                                                                                                                                                                    There are no issues that match your filters.

                                                                                                                                                                                                                                                                                                                    Category
                                                                                                                                                                                                                                                                                                                    Status