# All files / src utils.js

76.47% Statements 39/51
73.81% Branches 31/42
92.31% Functions 12/13
75% Lines 36/48

Press n or j to go to the next uncovered block, b, p or k for the previous block.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156

    1x

    8x

    7x

    5x

    26x
    1x

    26x

    78x
    78x

    26x
    123x

    123x
    2x

    24x

    45x

    45x
    44x

    44x
    1x

    1x

    15x
    15x
    15x

    87x

    20x
    20x

    20x
    620x
    620x
    620x

    32x
    32x

    32x
    32x

    32x

    32x

     /* @flow */
    import url from 'url'
    import { ECPair, address, crypto } from 'bitcoinjs-lib'
    import { config } from './config'

    export const BLOCKSTACK_HANDLER = 'blockstack'
    /**
     * Time
     * @private
     */

    export function nextYear() {
      return new Date(
        new Date().setFullYear(
          new Date().getFullYear() + 1
        )
      )
    }

    export function nextMonth() {
      return new Date(
        new Date().setMonth(
          new Date().getMonth() + 1
        )
      )
    }

    export function nextHour() {
      return new Date(
        new Date().setHours(
          new Date().getHours() + 1
        )
      )
    }

    /**
     * Query Strings
     * @private
     */

    export function updateQueryStringParameter(uri: string, key: string, value: string) {
      const re = new RegExp(`([?&])${key}=.*?(&|$)`, 'i')
      const separator = uri.indexOf('?') !== -1 ? '&' : '?'
      if (uri.match(re)) {
        return uri.replace(re, `$1${key}=${value}$2`)
      } else {
        return `${uri}${separator}${key}=${value}`
      }
    }

    /**
     * Versioning
     * @param {string} v1 - the left half of the version inequality
     * @param {string} v2 - right half of the version inequality
     * @returns {bool} iff v1 >= v2
     * @private
     */

    export function isLaterVersion(v1: string, v2: string) {
      if (v1 === undefined) {
        v1 = '0.0.0'
      }

      Iif (v2 === undefined) {
        v2 = '0.0.0'
      }

      const v1tuple = v1.split('.').map(x => parseInt(x, 10))
      const v2tuple = v2.split('.').map(x => parseInt(x, 10))

      for (let index = 0; index < v2.length; index++) {
        Iif (index >= v1.length) {
          v2tuple.push(0)
        }
        if (v1tuple[index] < v2tuple[index]) {
          return false
        }
      }
      return true
    }

    export function hexStringToECPair(skHex: string) {
      const ecPairOptions = {
        network: config.network.layer1,
        compressed: true
      }

      if (skHex.length === 66) {
        Iif (skHex.slice(64) !== '01') {
          throw new Error('Improperly formatted private-key hex string. 66-length hex usually '
                          + 'indicates compressed key, but last byte must be == 1')
        }
        return ECPair.fromPrivateKey(new Buffer(skHex.slice(0, 64), 'hex'), ecPairOptions)
      } else Iif (skHex.length === 64) {
        ecPairOptions.compressed = false
        return ECPair.fromPrivateKey(new Buffer(skHex, 'hex'), ecPairOptions)
      } else {
        throw new Error('Improperly formatted private-key hex string: length should be 64 or 66.')
      }
    }

    export function ecPairToHexString(secretKey: ECPair) {
      const ecPointHex = secretKey.privateKey.toString('hex')
      Eif (secretKey.compressed) {
        return `${ecPointHex}01`
      } else {
        return ecPointHex
      }
    }

    export function ecPairToAddress(keyPair: ECPair) {
      return address.toBase58Check(crypto.hash160(keyPair.publicKey), keyPair.network.pubKeyHash)
    }

    /**
     * UUIDs
     * @private
     */

    export function makeUUID4() {
      let d = new Date().getTime()
      Iif (typeof performance !== 'undefined' && typeof performance.now === 'function') {
        d += performance.now() // use high-precision timer if available
      }
      return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
        const r = (d + Math.random() * 16) % 16 | 0
        d = Math.floor(d / 16)
        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16)
      })
    }

    /**
     * Checks if both urls pass the same origin check & are absolute
     * @param  {[type]}  uri1 first uri to check
     * @param  {[type]}  uri2 second uri to check
     * @return {Boolean} true if they pass the same origin check
     * @private
     */
    export function isSameOriginAbsoluteUrl(uri1: string, uri2: string) {
      const parsedUri1 = url.parse(uri1)
      const parsedUri2 = url.parse(uri2)

      const port1 = parseInt(parsedUri1.port, 10) | 0 || (parsedUri1.protocol === 'https:' ? 443 : 80)
      const port2 = parseInt(parsedUri2.port, 10) | 0 || (parsedUri2.protocol === 'https:' ? 443 : 80)

      const match = {
        scheme: parsedUri1.protocol === parsedUri2.protocol,
        hostname: parsedUri1.hostname === parsedUri2.hostname,
        port: port1 === port2,
        absolute: (uri1.includes('http://') || uri1.includes('https://'))
        && (uri2.includes('http://') || uri2.includes('https://'))
      }

      return match.scheme && match.hostname && match.port && match.absolute
    }