src/vendors/bitcoinjs-lib/bitcoinjs.js
!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)
if (a != null) {
if ("number" == typeof a) this.fromNumber(a, b, c)
else if (b == null && "string" != typeof a) this.fromString(a, 256)
else this.fromString(a, b)
}
}
var proto = BigInteger.prototype
// duck-typed isBigInteger
proto.__bigi = require('../package.json').version
BigInteger.isBigInteger = function (obj, check_ver) {
return obj && obj.__bigi && (!check_ver || obj.__bigi === proto.__bigi)
}
// Bits per digit
var dbits
// am: Compute w_j += (x*this_i), propagate carries,
// c is initial carry, returns final carry.
// c < 3*dvalue, x < 2*dvalue, this_i < dvalue
// We need to select the fastest one that works in this environment.
// am1: use a single mult and divide to get the high bits,
// max digit bits should be 26 because
// max internal value = 2*dvalue^2-2*dvalue (< 2^53)
function am1(i, x, w, j, c, n) {
while (--n >= 0) {
var v = x * this[i++] + w[j] + c
c = Math.floor(v / 0x4000000)
w[j++] = v & 0x3ffffff
}
return c
}
// am2 avoids a big mult-and-extract completely.
// Max digit bits should be <= 30 because we do bitwise ops
// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)
function am2(i, x, w, j, c, n) {
var xl = x & 0x7fff,
xh = x >> 15
while (--n >= 0) {
var l = this[i] & 0x7fff
var h = this[i++] >> 15
var m = xh * l + h * xl
l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff)
c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30)
w[j++] = l & 0x3fffffff
}
return c
}
// Alternately, set max digit bits to 28 since some
// browsers slow down when dealing with 32-bit numbers.
function am3(i, x, w, j, c, n) {
var xl = x & 0x3fff,
xh = x >> 14
while (--n >= 0) {
var l = this[i] & 0x3fff
var h = this[i++] >> 14
var m = xh * l + h * xl
l = xl * l + ((m & 0x3fff) << 14) + w[j] + c
c = (l >> 28) + (m >> 14) + xh * h
w[j++] = l & 0xfffffff
}
return c
}
// wtf?
BigInteger.prototype.am = am1
dbits = 26
BigInteger.prototype.DB = dbits
BigInteger.prototype.DM = ((1 << dbits) - 1)
var DV = BigInteger.prototype.DV = (1 << dbits)
var BI_FP = 52
BigInteger.prototype.FV = Math.pow(2, BI_FP)
BigInteger.prototype.F1 = BI_FP - dbits
BigInteger.prototype.F2 = 2 * dbits - BI_FP
// Digit conversions
var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz"
var BI_RC = new Array()
var rr, vv
rr = "0".charCodeAt(0)
for (vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv
rr = "a".charCodeAt(0)
for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv
rr = "A".charCodeAt(0)
for (vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv
function int2char(n) {
return BI_RM.charAt(n)
}
function intAt(s, i) {
var c = BI_RC[s.charCodeAt(i)]
return (c == null) ? -1 : c
}
// (protected) copy this to r
function bnpCopyTo(r) {
for (var i = this.t - 1; i >= 0; --i) r[i] = this[i]
r.t = this.t
r.s = this.s
}
// (protected) set from integer value x, -DV <= x < DV
function bnpFromInt(x) {
this.t = 1
this.s = (x < 0) ? -1 : 0
if (x > 0) this[0] = x
else if (x < -1) this[0] = x + DV
else this.t = 0
}
// return bigint initialized to value
function nbv(i) {
var r = new BigInteger()
r.fromInt(i)
return r
}
// (protected) set from string and radix
function bnpFromString(s, b) {
var self = this
var k
if (b == 16) k = 4
else if (b == 8) k = 3
else if (b == 256) k = 8; // byte array
else if (b == 2) k = 1
else if (b == 32) k = 5
else if (b == 4) k = 2
else {
self.fromRadix(s, b)
return
}
self.t = 0
self.s = 0
var i = s.length,
mi = false,
sh = 0
while (--i >= 0) {
var x = (k == 8) ? s[i] & 0xff : intAt(s, i)
if (x < 0) {
if (s.charAt(i) == "-") mi = true
continue
}
mi = false
if (sh == 0)
self[self.t++] = x
else if (sh + k > self.DB) {
self[self.t - 1] |= (x & ((1 << (self.DB - sh)) - 1)) << sh
self[self.t++] = (x >> (self.DB - sh))
} else
self[self.t - 1] |= x << sh
sh += k
if (sh >= self.DB) sh -= self.DB
}
if (k == 8 && (s[0] & 0x80) != 0) {
self.s = -1
if (sh > 0) self[self.t - 1] |= ((1 << (self.DB - sh)) - 1) << sh
}
self.clamp()
if (mi) BigInteger.ZERO.subTo(self, self)
}
// (protected) clamp off excess high words
function bnpClamp() {
var c = this.s & this.DM
while (this.t > 0 && this[this.t - 1] == c)--this.t
}
// (public) return string representation in given radix
function bnToString(b) {
var self = this
if (self.s < 0) return "-" + self.negate()
.toString(b)
var k
if (b == 16) k = 4
else if (b == 8) k = 3
else if (b == 2) k = 1
else if (b == 32) k = 5
else if (b == 4) k = 2
else return self.toRadix(b)
var km = (1 << k) - 1,
d, m = false,
r = "",
i = self.t
var p = self.DB - (i * self.DB) % k
if (i-- > 0) {
if (p < self.DB && (d = self[i] >> p) > 0) {
m = true
r = int2char(d)
}
while (i >= 0) {
if (p < k) {
d = (self[i] & ((1 << p) - 1)) << (k - p)
d |= self[--i] >> (p += self.DB - k)
} else {
d = (self[i] >> (p -= k)) & km
if (p <= 0) {
p += self.DB
--i
}
}
if (d > 0) m = true
if (m) r += int2char(d)
}
}
return m ? r : "0"
}
// (public) -this
function bnNegate() {
var r = new BigInteger()
BigInteger.ZERO.subTo(this, r)
return r
}
// (public) |this|
function bnAbs() {
return (this.s < 0) ? this.negate() : this
}
// (public) return + if this > a, - if this < a, 0 if equal
function bnCompareTo(a) {
var r = this.s - a.s
if (r != 0) return r
var i = this.t
r = i - a.t
if (r != 0) return (this.s < 0) ? -r : r
while (--i >= 0)
if ((r = this[i] - a[i]) != 0) return r
return 0
}
// returns bit length of the integer x
function nbits(x) {
var r = 1,
t
if ((t = x >>> 16) != 0) {
x = t
r += 16
}
if ((t = x >> 8) != 0) {
x = t
r += 8
}
if ((t = x >> 4) != 0) {
x = t
r += 4
}
if ((t = x >> 2) != 0) {
x = t
r += 2
}
if ((t = x >> 1) != 0) {
x = t
r += 1
}
return r
}
// (public) return the number of bits in "this"
function bnBitLength() {
if (this.t <= 0) return 0
return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ (this.s & this.DM))
}
// (public) return the number of bytes in "this"
function bnByteLength() {
return this.bitLength() >> 3
}
// (protected) r = this << n*DB
function bnpDLShiftTo(n, r) {
var i
for (i = this.t - 1; i >= 0; --i) r[i + n] = this[i]
for (i = n - 1; i >= 0; --i) r[i] = 0
r.t = this.t + n
r.s = this.s
}
// (protected) r = this >> n*DB
function bnpDRShiftTo(n, r) {
for (var i = n; i < this.t; ++i) r[i - n] = this[i]
r.t = Math.max(this.t - n, 0)
r.s = this.s
}
// (protected) r = this << n
function bnpLShiftTo(n, r) {
var self = this
var bs = n % self.DB
var cbs = self.DB - bs
var bm = (1 << cbs) - 1
var ds = Math.floor(n / self.DB),
c = (self.s << bs) & self.DM,
i
for (i = self.t - 1; i >= 0; --i) {
r[i + ds + 1] = (self[i] >> cbs) | c
c = (self[i] & bm) << bs
}
for (i = ds - 1; i >= 0; --i) r[i] = 0
r[ds] = c
r.t = self.t + ds + 1
r.s = self.s
r.clamp()
}
// (protected) r = this >> n
function bnpRShiftTo(n, r) {
var self = this
r.s = self.s
var ds = Math.floor(n / self.DB)
if (ds >= self.t) {
r.t = 0
return
}
var bs = n % self.DB
var cbs = self.DB - bs
var bm = (1 << bs) - 1
r[0] = self[ds] >> bs
for (var i = ds + 1; i < self.t; ++i) {
r[i - ds - 1] |= (self[i] & bm) << cbs
r[i - ds] = self[i] >> bs
}
if (bs > 0) r[self.t - ds - 1] |= (self.s & bm) << cbs
r.t = self.t - ds
r.clamp()
}
// (protected) r = this - a
function bnpSubTo(a, r) {
var self = this
var i = 0,
c = 0,
m = Math.min(a.t, self.t)
while (i < m) {
c += self[i] - a[i]
r[i++] = c & self.DM
c >>= self.DB
}
if (a.t < self.t) {
c -= a.s
while (i < self.t) {
c += self[i]
r[i++] = c & self.DM
c >>= self.DB
}
c += self.s
} else {
c += self.s
while (i < a.t) {
c -= a[i]
r[i++] = c & self.DM
c >>= self.DB
}
c -= a.s
}
r.s = (c < 0) ? -1 : 0
if (c < -1) r[i++] = self.DV + c
else if (c > 0) r[i++] = c
r.t = i
r.clamp()
}
// (protected) r = this * a, r != this,a (HAC 14.12)
// "this" should be the larger one if appropriate.
function bnpMultiplyTo(a, r) {
var x = this.abs(),
y = a.abs()
var i = x.t
r.t = i + y.t
while (--i >= 0) r[i] = 0
for (i = 0; i < y.t; ++i) r[i + x.t] = x.am(0, y[i], r, i, 0, x.t)
r.s = 0
r.clamp()
if (this.s != a.s) BigInteger.ZERO.subTo(r, r)
}
// (protected) r = this^2, r != this (HAC 14.16)
function bnpSquareTo(r) {
var x = this.abs()
var i = r.t = 2 * x.t
while (--i >= 0) r[i] = 0
for (i = 0; i < x.t - 1; ++i) {
var c = x.am(i, x[i], r, 2 * i, 0, 1)
if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {
r[i + x.t] -= x.DV
r[i + x.t + 1] = 1
}
}
if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1)
r.s = 0
r.clamp()
}
// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)
// r != q, this != m. q or r may be null.
function bnpDivRemTo(m, q, r) {
var self = this
var pm = m.abs()
if (pm.t <= 0) return
var pt = self.abs()
if (pt.t < pm.t) {
if (q != null) q.fromInt(0)
if (r != null) self.copyTo(r)
return
}
if (r == null) r = new BigInteger()
var y = new BigInteger(),
ts = self.s,
ms = m.s
var nsh = self.DB - nbits(pm[pm.t - 1]); // normalize modulus
if (nsh > 0) {
pm.lShiftTo(nsh, y)
pt.lShiftTo(nsh, r)
} else {
pm.copyTo(y)
pt.copyTo(r)
}
var ys = y.t
var y0 = y[ys - 1]
if (y0 == 0) return
var yt = y0 * (1 << self.F1) + ((ys > 1) ? y[ys - 2] >> self.F2 : 0)
var d1 = self.FV / yt,
d2 = (1 << self.F1) / yt,
e = 1 << self.F2
var i = r.t,
j = i - ys,
t = (q == null) ? new BigInteger() : q
y.dlShiftTo(j, t)
if (r.compareTo(t) >= 0) {
r[r.t++] = 1
r.subTo(t, r)
}
BigInteger.ONE.dlShiftTo(ys, t)
t.subTo(y, y); // "negative" y so we can replace sub with am later
while (y.t < ys) y[y.t++] = 0
while (--j >= 0) {
// Estimate quotient digit
var qd = (r[--i] == y0) ? self.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2)
if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) { // Try it out
y.dlShiftTo(j, t)
r.subTo(t, r)
while (r[i] < --qd) r.subTo(t, r)
}
}
if (q != null) {
r.drShiftTo(ys, q)
if (ts != ms) BigInteger.ZERO.subTo(q, q)
}
r.t = ys
r.clamp()
if (nsh > 0) r.rShiftTo(nsh, r); // Denormalize remainder
if (ts < 0) BigInteger.ZERO.subTo(r, r)
}
// (public) this mod a
function bnMod(a) {
var r = new BigInteger()
this.abs()
.divRemTo(a, null, r)
if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r)
return r
}
// Modular reduction using "classic" algorithm
function Classic(m) {
this.m = m
}
function cConvert(x) {
if (x.s < 0 || x.compareTo(this.m) >= 0) return x.mod(this.m)
else return x
}
function cRevert(x) {
return x
}
function cReduce(x) {
x.divRemTo(this.m, null, x)
}
function cMulTo(x, y, r) {
x.multiplyTo(y, r)
this.reduce(r)
}
function cSqrTo(x, r) {
x.squareTo(r)
this.reduce(r)
}
Classic.prototype.convert = cConvert
Classic.prototype.revert = cRevert
Classic.prototype.reduce = cReduce
Classic.prototype.mulTo = cMulTo
Classic.prototype.sqrTo = cSqrTo
// (protected) return "-1/this % 2^DB"; useful for Mont. reduction
// justification:
// xy == 1 (mod m)
// xy = 1+km
// xy(2-xy) = (1+km)(1-km)
// x[y(2-xy)] = 1-k^2m^2
// x[y(2-xy)] == 1 (mod m^2)
// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
// JS multiply "overflows" differently from C/C++, so care is needed here.
function bnpInvDigit() {
if (this.t < 1) return 0
var x = this[0]
if ((x & 1) == 0) return 0
var y = x & 3; // y == 1/x mod 2^2
y = (y * (2 - (x & 0xf) * y)) & 0xf; // y == 1/x mod 2^4
y = (y * (2 - (x & 0xff) * y)) & 0xff; // y == 1/x mod 2^8
y = (y * (2 - (((x & 0xffff) * y) & 0xffff))) & 0xffff; // y == 1/x mod 2^16
// last step - calculate inverse mod DV directly
// assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints
y = (y * (2 - x * y % this.DV)) % this.DV; // y == 1/x mod 2^dbits
// we really want the negative inverse, and -DV < y < DV
return (y > 0) ? this.DV - y : -y
}
// Montgomery reduction
function Montgomery(m) {
this.m = m
this.mp = m.invDigit()
this.mpl = this.mp & 0x7fff
this.mph = this.mp >> 15
this.um = (1 << (m.DB - 15)) - 1
this.mt2 = 2 * m.t
}
// xR mod m
function montConvert(x) {
var r = new BigInteger()
x.abs()
.dlShiftTo(this.m.t, r)
r.divRemTo(this.m, null, r)
if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r)
return r
}
// x/R mod m
function montRevert(x) {
var r = new BigInteger()
x.copyTo(r)
this.reduce(r)
return r
}
// x = x/R mod m (HAC 14.32)
function montReduce(x) {
while (x.t <= this.mt2) // pad x so am has enough room later
x[x.t++] = 0
for (var i = 0; i < this.m.t; ++i) {
// faster way of calculating u0 = x[i]*mp mod DV
var j = x[i] & 0x7fff
var u0 = (j * this.mpl + (((j * this.mph + (x[i] >> 15) * this.mpl) & this.um) << 15)) & x.DM
// use am to combine the multiply-shift-add into one call
j = i + this.m.t
x[j] += this.m.am(0, u0, x, i, 0, this.m.t)
// propagate carry
while (x[j] >= x.DV) {
x[j] -= x.DV
x[++j]++
}
}
x.clamp()
x.drShiftTo(this.m.t, x)
if (x.compareTo(this.m) >= 0) x.subTo(this.m, x)
}
// r = "x^2/R mod m"; x != r
function montSqrTo(x, r) {
x.squareTo(r)
this.reduce(r)
}
// r = "xy/R mod m"; x,y != r
function montMulTo(x, y, r) {
x.multiplyTo(y, r)
this.reduce(r)
}
Montgomery.prototype.convert = montConvert
Montgomery.prototype.revert = montRevert
Montgomery.prototype.reduce = montReduce
Montgomery.prototype.mulTo = montMulTo
Montgomery.prototype.sqrTo = montSqrTo
// (protected) true iff this is even
function bnpIsEven() {
return ((this.t > 0) ? (this[0] & 1) : this.s) == 0
}
// (protected) this^e, e < 2^32, doing sqr and mul with "r" (HAC 14.79)
function bnpExp(e, z) {
if (e > 0xffffffff || e < 1) return BigInteger.ONE
var r = new BigInteger(),
r2 = new BigInteger(),
g = z.convert(this),
i = nbits(e) - 1
g.copyTo(r)
while (--i >= 0) {
z.sqrTo(r, r2)
if ((e & (1 << i)) > 0) z.mulTo(r2, g, r)
else {
var t = r
r = r2
r2 = t
}
}
return z.revert(r)
}
// (public) this^e % m, 0 <= e < 2^32
function bnModPowInt(e, m) {
var z
if (e < 256 || m.isEven()) z = new Classic(m)
else z = new Montgomery(m)
return this.exp(e, z)
}
// protected
proto.copyTo = bnpCopyTo
proto.fromInt = bnpFromInt
proto.fromString = bnpFromString
proto.clamp = bnpClamp
proto.dlShiftTo = bnpDLShiftTo
proto.drShiftTo = bnpDRShiftTo
proto.lShiftTo = bnpLShiftTo
proto.rShiftTo = bnpRShiftTo
proto.subTo = bnpSubTo
proto.multiplyTo = bnpMultiplyTo
proto.squareTo = bnpSquareTo
proto.divRemTo = bnpDivRemTo
proto.invDigit = bnpInvDigit
proto.isEven = bnpIsEven
proto.exp = bnpExp
// public
proto.toString = bnToString
proto.negate = bnNegate
proto.abs = bnAbs
proto.compareTo = bnCompareTo
proto.bitLength = bnBitLength
proto.byteLength = bnByteLength
proto.mod = bnMod
proto.modPowInt = bnModPowInt
// (public)
function bnClone() {
var r = new BigInteger()
this.copyTo(r)
return r
}
// (public) return value as integer
function bnIntValue() {
if (this.s < 0) {
if (this.t == 1) return this[0] - this.DV
else if (this.t == 0) return -1
} else if (this.t == 1) return this[0]
else if (this.t == 0) return 0
// assumes 16 < DB < 32
return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0]
}
// (public) return value as byte
function bnByteValue() {
return (this.t == 0) ? this.s : (this[0] << 24) >> 24
}
// (public) return value as short (assumes DB>=16)
function bnShortValue() {
return (this.t == 0) ? this.s : (this[0] << 16) >> 16
}
// (protected) return x s.t. r^x < DV
function bnpChunkSize(r) {
return Math.floor(Math.LN2 * this.DB / Math.log(r))
}
// (public) 0 if this == 0, 1 if this > 0
function bnSigNum() {
if (this.s < 0) return -1
else if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) return 0
else return 1
}
// (protected) convert to radix string
function bnpToRadix(b) {
if (b == null) b = 10
if (this.signum() == 0 || b < 2 || b > 36) return "0"
var cs = this.chunkSize(b)
var a = Math.pow(b, cs)
var d = nbv(a),
y = new BigInteger(),
z = new BigInteger(),
r = ""
this.divRemTo(d, y, z)
while (y.signum() > 0) {
r = (a + z.intValue())
.toString(b)
.substr(1) + r
y.divRemTo(d, y, z)
}
return z.intValue()
.toString(b) + r
}
// (protected) convert from radix string
function bnpFromRadix(s, b) {
var self = this
self.fromInt(0)
if (b == null) b = 10
var cs = self.chunkSize(b)
var d = Math.pow(b, cs),
mi = false,
j = 0,
w = 0
for (var i = 0; i < s.length; ++i) {
var x = intAt(s, i)
if (x < 0) {
if (s.charAt(i) == "-" && self.signum() == 0) mi = true
continue
}
w = b * w + x
if (++j >= cs) {
self.dMultiply(d)
self.dAddOffset(w, 0)
j = 0
w = 0
}
}
if (j > 0) {
self.dMultiply(Math.pow(b, j))
self.dAddOffset(w, 0)
}
if (mi) BigInteger.ZERO.subTo(self, self)
}
// (protected) alternate constructor
function bnpFromNumber(a, b, c) {
var self = this
if ("number" == typeof b) {
// new BigInteger(int,int,RNG)
if (a < 2) self.fromInt(1)
else {
self.fromNumber(a, c)
if (!self.testBit(a - 1)) // force MSB set
self.bitwiseTo(BigInteger.ONE.shiftLeft(a - 1), op_or, self)
if (self.isEven()) self.dAddOffset(1, 0); // force odd
while (!self.isProbablePrime(b)) {
self.dAddOffset(2, 0)
if (self.bitLength() > a) self.subTo(BigInteger.ONE.shiftLeft(a - 1), self)
}
}
} else {
// new BigInteger(int,RNG)
var x = new Array(),
t = a & 7
x.length = (a >> 3) + 1
b.nextBytes(x)
if (t > 0) x[0] &= ((1 << t) - 1)
else x[0] = 0
self.fromString(x, 256)
}
}
// (public) convert to bigendian byte array
function bnToByteArray() {
var self = this
var i = self.t,
r = new Array()
r[0] = self.s
var p = self.DB - (i * self.DB) % 8,
d, k = 0
if (i-- > 0) {
if (p < self.DB && (d = self[i] >> p) != (self.s & self.DM) >> p)
r[k++] = d | (self.s << (self.DB - p))
while (i >= 0) {
if (p < 8) {
d = (self[i] & ((1 << p) - 1)) << (8 - p)
d |= self[--i] >> (p += self.DB - 8)
} else {
d = (self[i] >> (p -= 8)) & 0xff
if (p <= 0) {
p += self.DB
--i
}
}
if ((d & 0x80) != 0) d |= -256
if (k === 0 && (self.s & 0x80) != (d & 0x80))++k
if (k > 0 || d != self.s) r[k++] = d
}
}
return r
}
function bnEquals(a) {
return (this.compareTo(a) == 0)
}
function bnMin(a) {
return (this.compareTo(a) < 0) ? this : a
}
function bnMax(a) {
return (this.compareTo(a) > 0) ? this : a
}
// (protected) r = this op a (bitwise)
function bnpBitwiseTo(a, op, r) {
var self = this
var i, f, m = Math.min(a.t, self.t)
for (i = 0; i < m; ++i) r[i] = op(self[i], a[i])
if (a.t < self.t) {
f = a.s & self.DM
for (i = m; i < self.t; ++i) r[i] = op(self[i], f)
r.t = self.t
} else {
f = self.s & self.DM
for (i = m; i < a.t; ++i) r[i] = op(f, a[i])
r.t = a.t
}
r.s = op(self.s, a.s)
r.clamp()
}
// (public) this & a
function op_and(x, y) {
return x & y
}
function bnAnd(a) {
var r = new BigInteger()
this.bitwiseTo(a, op_and, r)
return r
}
// (public) this | a
function op_or(x, y) {
return x | y
}
function bnOr(a) {
var r = new BigInteger()
this.bitwiseTo(a, op_or, r)
return r
}
// (public) this ^ a
function op_xor(x, y) {
return x ^ y
}
function bnXor(a) {
var r = new BigInteger()
this.bitwiseTo(a, op_xor, r)
return r
}
// (public) this & ~a
function op_andnot(x, y) {
return x & ~y
}
function bnAndNot(a) {
var r = new BigInteger()
this.bitwiseTo(a, op_andnot, r)
return r
}
// (public) ~this
function bnNot() {
var r = new BigInteger()
for (var i = 0; i < this.t; ++i) r[i] = this.DM & ~this[i]
r.t = this.t
r.s = ~this.s
return r
}
// (public) this << n
function bnShiftLeft(n) {
var r = new BigInteger()
if (n < 0) this.rShiftTo(-n, r)
else this.lShiftTo(n, r)
return r
}
// (public) this >> n
function bnShiftRight(n) {
var r = new BigInteger()
if (n < 0) this.lShiftTo(-n, r)
else this.rShiftTo(n, r)
return r
}
// return index of lowest 1-bit in x, x < 2^31
function lbit(x) {
if (x == 0) return -1
var r = 0
if ((x & 0xffff) == 0) {
x >>= 16
r += 16
}
if ((x & 0xff) == 0) {
x >>= 8
r += 8
}
if ((x & 0xf) == 0) {
x >>= 4
r += 4
}
if ((x & 3) == 0) {
x >>= 2
r += 2
}
if ((x & 1) == 0)++r
return r
}
// (public) returns index of lowest 1-bit (or -1 if none)
function bnGetLowestSetBit() {
for (var i = 0; i < this.t; ++i)
if (this[i] != 0) return i * this.DB + lbit(this[i])
if (this.s < 0) return this.t * this.DB
return -1
}
// return number of 1 bits in x
function cbit(x) {
var r = 0
while (x != 0) {
x &= x - 1
++r
}
return r
}
// (public) return number of set bits
function bnBitCount() {
var r = 0,
x = this.s & this.DM
for (var i = 0; i < this.t; ++i) r += cbit(this[i] ^ x)
return r
}
// (public) true iff nth bit is set
function bnTestBit(n) {
var j = Math.floor(n / this.DB)
if (j >= this.t) return (this.s != 0)
return ((this[j] & (1 << (n % this.DB))) != 0)
}
// (protected) this op (1<<n)
function bnpChangeBit(n, op) {
var r = BigInteger.ONE.shiftLeft(n)
this.bitwiseTo(r, op, r)
return r
}
// (public) this | (1<<n)
function bnSetBit(n) {
return this.changeBit(n, op_or)
}
// (public) this & ~(1<<n)
function bnClearBit(n) {
return this.changeBit(n, op_andnot)
}
// (public) this ^ (1<<n)
function bnFlipBit(n) {
return this.changeBit(n, op_xor)
}
// (protected) r = this + a
function bnpAddTo(a, r) {
var self = this
var i = 0,
c = 0,
m = Math.min(a.t, self.t)
while (i < m) {
c += self[i] + a[i]
r[i++] = c & self.DM
c >>= self.DB
}
if (a.t < self.t) {
c += a.s
while (i < self.t) {
c += self[i]
r[i++] = c & self.DM
c >>= self.DB
}
c += self.s
} else {
c += self.s
while (i < a.t) {
c += a[i]
r[i++] = c & self.DM
c >>= self.DB
}
c += a.s
}
r.s = (c < 0) ? -1 : 0
if (c > 0) r[i++] = c
else if (c < -1) r[i++] = self.DV + c
r.t = i
r.clamp()
}
// (public) this + a
function bnAdd(a) {
var r = new BigInteger()
this.addTo(a, r)
return r
}
// (public) this - a
function bnSubtract(a) {
var r = new BigInteger()
this.subTo(a, r)
return r
}
// (public) this * a
function bnMultiply(a) {
var r = new BigInteger()
this.multiplyTo(a, r)
return r
}
// (public) this^2
function bnSquare() {
var r = new BigInteger()
this.squareTo(r)
return r
}
// (public) this / a
function bnDivide(a) {
var r = new BigInteger()
this.divRemTo(a, r, null)
return r
}
// (public) this % a
function bnRemainder(a) {
var r = new BigInteger()
this.divRemTo(a, null, r)
return r
}
// (public) [this/a,this%a]
function bnDivideAndRemainder(a) {
var q = new BigInteger(),
r = new BigInteger()
this.divRemTo(a, q, r)
return new Array(q, r)
}
// (protected) this *= n, this >= 0, 1 < n < DV
function bnpDMultiply(n) {
this[this.t] = this.am(0, n - 1, this, 0, 0, this.t)
++this.t
this.clamp()
}
// (protected) this += n << w words, this >= 0
function bnpDAddOffset(n, w) {
if (n == 0) return
while (this.t <= w) this[this.t++] = 0
this[w] += n
while (this[w] >= this.DV) {
this[w] -= this.DV
if (++w >= this.t) this[this.t++] = 0
++this[w]
}
}
// A "null" reducer
function NullExp() {}
function nNop(x) {
return x
}
function nMulTo(x, y, r) {
x.multiplyTo(y, r)
}
function nSqrTo(x, r) {
x.squareTo(r)
}
NullExp.prototype.convert = nNop
NullExp.prototype.revert = nNop
NullExp.prototype.mulTo = nMulTo
NullExp.prototype.sqrTo = nSqrTo
// (public) this^e
function bnPow(e) {
return this.exp(e, new NullExp())
}
// (protected) r = lower n words of "this * a", a.t <= n
// "this" should be the larger one if appropriate.
function bnpMultiplyLowerTo(a, n, r) {
var i = Math.min(this.t + a.t, n)
r.s = 0; // assumes a,this >= 0
r.t = i
while (i > 0) r[--i] = 0
var j
for (j = r.t - this.t; i < j; ++i) r[i + this.t] = this.am(0, a[i], r, i, 0, this.t)
for (j = Math.min(a.t, n); i < j; ++i) this.am(0, a[i], r, i, 0, n - i)
r.clamp()
}
// (protected) r = "this * a" without lower n words, n > 0
// "this" should be the larger one if appropriate.
function bnpMultiplyUpperTo(a, n, r) {
--n
var i = r.t = this.t + a.t - n
r.s = 0; // assumes a,this >= 0
while (--i >= 0) r[i] = 0
for (i = Math.max(n - this.t, 0); i < a.t; ++i)
r[this.t + i - n] = this.am(n - i, a[i], r, 0, 0, this.t + i - n)
r.clamp()
r.drShiftTo(1, r)
}
// Barrett modular reduction
function Barrett(m) {
// setup Barrett
this.r2 = new BigInteger()
this.q3 = new BigInteger()
BigInteger.ONE.dlShiftTo(2 * m.t, this.r2)
this.mu = this.r2.divide(m)
this.m = m
}
function barrettConvert(x) {
if (x.s < 0 || x.t > 2 * this.m.t) return x.mod(this.m)
else if (x.compareTo(this.m) < 0) return x
else {
var r = new BigInteger()
x.copyTo(r)
this.reduce(r)
return r
}
}
function barrettRevert(x) {
return x
}
// x = x mod m (HAC 14.42)
function barrettReduce(x) {
var self = this
x.drShiftTo(self.m.t - 1, self.r2)
if (x.t > self.m.t + 1) {
x.t = self.m.t + 1
x.clamp()
}
self.mu.multiplyUpperTo(self.r2, self.m.t + 1, self.q3)
self.m.multiplyLowerTo(self.q3, self.m.t + 1, self.r2)
while (x.compareTo(self.r2) < 0) x.dAddOffset(1, self.m.t + 1)
x.subTo(self.r2, x)
while (x.compareTo(self.m) >= 0) x.subTo(self.m, x)
}
// r = x^2 mod m; x != r
function barrettSqrTo(x, r) {
x.squareTo(r)
this.reduce(r)
}
// r = x*y mod m; x,y != r
function barrettMulTo(x, y, r) {
x.multiplyTo(y, r)
this.reduce(r)
}
Barrett.prototype.convert = barrettConvert
Barrett.prototype.revert = barrettRevert
Barrett.prototype.reduce = barrettReduce
Barrett.prototype.mulTo = barrettMulTo
Barrett.prototype.sqrTo = barrettSqrTo
// (public) this^e % m (HAC 14.85)
function bnModPow(e, m) {
var i = e.bitLength(),
k, r = nbv(1),
z
if (i <= 0) return r
else if (i < 18) k = 1
else if (i < 48) k = 3
else if (i < 144) k = 4
else if (i < 768) k = 5
else k = 6
if (i < 8)
z = new Classic(m)
else if (m.isEven())
z = new Barrett(m)
else
z = new Montgomery(m)
// precomputation
var g = new Array(),
n = 3,
k1 = k - 1,
km = (1 << k) - 1
g[1] = z.convert(this)
if (k > 1) {
var g2 = new BigInteger()
z.sqrTo(g[1], g2)
while (n <= km) {
g[n] = new BigInteger()
z.mulTo(g2, g[n - 2], g[n])
n += 2
}
}
var j = e.t - 1,
w, is1 = true,
r2 = new BigInteger(),
t
i = nbits(e[j]) - 1
while (j >= 0) {
if (i >= k1) w = (e[j] >> (i - k1)) & km
else {
w = (e[j] & ((1 << (i + 1)) - 1)) << (k1 - i)
if (j > 0) w |= e[j - 1] >> (this.DB + i - k1)
}
n = k
while ((w & 1) == 0) {
w >>= 1
--n
}
if ((i -= n) < 0) {
i += this.DB
--j
}
if (is1) { // ret == 1, don't bother squaring or multiplying it
g[w].copyTo(r)
is1 = false
} else {
while (n > 1) {
z.sqrTo(r, r2)
z.sqrTo(r2, r)
n -= 2
}
if (n > 0) z.sqrTo(r, r2)
else {
t = r
r = r2
r2 = t
}
z.mulTo(r2, g[w], r)
}
while (j >= 0 && (e[j] & (1 << i)) == 0) {
z.sqrTo(r, r2)
t = r
r = r2
r2 = t
if (--i < 0) {
i = this.DB - 1
--j
}
}
}
return z.revert(r)
}
// (public) gcd(this,a) (HAC 14.54)
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
x = y
y = t
}
var i = x.getLowestSetBit(),
g = y.getLowestSetBit()
if (g < 0) return x
if (i < g) g = i
if (g > 0) {
x.rShiftTo(g, x)
y.rShiftTo(g, y)
}
while (x.signum() > 0) {
if ((i = x.getLowestSetBit()) > 0) x.rShiftTo(i, x)
if ((i = y.getLowestSetBit()) > 0) y.rShiftTo(i, y)
if (x.compareTo(y) >= 0) {
x.subTo(y, x)
x.rShiftTo(1, x)
} else {
y.subTo(x, y)
y.rShiftTo(1, y)
}
}
if (g > 0) y.lShiftTo(g, y)
return y
}
// (protected) this % n, n < 2^26
function bnpModInt(n) {
if (n <= 0) return 0
var d = this.DV % n,
r = (this.s < 0) ? n - 1 : 0
if (this.t > 0)
if (d == 0) r = this[0] % n
else
for (var i = this.t - 1; i >= 0; --i) r = (d * r + this[i]) % n
return r
}
// (public) 1/this % m (HAC 14.61)
function bnModInverse(m) {
var ac = m.isEven()
if ((this.isEven() && ac) || m.signum() == 0) return BigInteger.ZERO
var u = m.clone(),
v = this.clone()
var a = nbv(1),
b = nbv(0),
c = nbv(0),
d = nbv(1)
while (u.signum() != 0) {
while (u.isEven()) {
u.rShiftTo(1, u)
if (ac) {
if (!a.isEven() || !b.isEven()) {
a.addTo(this, a)
b.subTo(m, b)
}
a.rShiftTo(1, a)
} else if (!b.isEven()) b.subTo(m, b)
b.rShiftTo(1, b)
}
while (v.isEven()) {
v.rShiftTo(1, v)
if (ac) {
if (!c.isEven() || !d.isEven()) {
c.addTo(this, c)
d.subTo(m, d)
}
c.rShiftTo(1, c)
} else if (!d.isEven()) d.subTo(m, d)
d.rShiftTo(1, d)
}
if (u.compareTo(v) >= 0) {
u.subTo(v, u)
if (ac) a.subTo(c, a)
b.subTo(d, b)
} else {
v.subTo(u, v)
if (ac) c.subTo(a, c)
d.subTo(b, d)
}
}
if (v.compareTo(BigInteger.ONE) != 0) return BigInteger.ZERO
if (d.compareTo(m) >= 0) return d.subtract(m)
if (d.signum() < 0) d.addTo(m, d)
else return d
if (d.signum() < 0) return d.add(m)
else return d
}
// protected
proto.chunkSize = bnpChunkSize
proto.toRadix = bnpToRadix
proto.fromRadix = bnpFromRadix
proto.fromNumber = bnpFromNumber
proto.bitwiseTo = bnpBitwiseTo
proto.changeBit = bnpChangeBit
proto.addTo = bnpAddTo
proto.dMultiply = bnpDMultiply
proto.dAddOffset = bnpDAddOffset
proto.multiplyLowerTo = bnpMultiplyLowerTo
proto.multiplyUpperTo = bnpMultiplyUpperTo
proto.modInt = bnpModInt
// public
proto.clone = bnClone
proto.intValue = bnIntValue
proto.byteValue = bnByteValue
proto.shortValue = bnShortValue
proto.signum = bnSigNum
proto.toByteArray = bnToByteArray
proto.equals = bnEquals
proto.min = bnMin
proto.max = bnMax
proto.and = bnAnd
proto.or = bnOr
proto.xor = bnXor
proto.andNot = bnAndNot
proto.not = bnNot
proto.shiftLeft = bnShiftLeft
proto.shiftRight = bnShiftRight
proto.getLowestSetBit = bnGetLowestSetBit
proto.bitCount = bnBitCount
proto.testBit = bnTestBit
proto.setBit = bnSetBit
proto.clearBit = bnClearBit
proto.flipBit = bnFlipBit
proto.add = bnAdd
proto.subtract = bnSubtract
proto.multiply = bnMultiply
proto.divide = bnDivide
proto.remainder = bnRemainder
proto.divideAndRemainder = bnDivideAndRemainder
proto.modPow = bnModPow
proto.modInverse = bnModInverse
proto.pow = bnPow
proto.gcd = bnGCD
// JSBN-specific extension
proto.square = bnSquare
// constants
BigInteger.ZERO = nbv(0)
BigInteger.ONE = nbv(1)
BigInteger.valueOf = nbv
module.exports = BigInteger
},{"../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')
/**
* Turns a byte array into a big integer.
*
* This function will interpret a byte array as a big integer in big
* endian notation.
*/
BigInteger.fromByteArrayUnsigned = function(byteArray) {
// BigInteger expects a DER integer conformant byte array
if (byteArray[0] & 0x80) {
return new BigInteger([0].concat(byteArray))
}
return new BigInteger(byteArray)
}
/**
* Returns a byte array representation of the big integer.
*
* This returns the absolute of the contained value in big endian
* form. A value of zero results in an empty array.
*/
BigInteger.prototype.toByteArrayUnsigned = function() {
var byteArray = this.toByteArray()
return byteArray[0] === 0 ? byteArray.slice(1) : byteArray
}
BigInteger.fromDERInteger = function(byteArray) {
return new BigInteger(byteArray)
}
/*
* Converts BigInteger to a DER integer representation.
*
* The format for this value uses the most significant bit as a sign
* bit. If the most significant bit is already set and the integer is
* positive, a 0x00 is prepended.
*
* Examples:
*
* 0 => 0x00
* 1 => 0x01
* -1 => 0xff
* 127 => 0x7f
* -127 => 0x81
* 128 => 0x0080
* -128 => 0x80
* 255 => 0x00ff
* -255 => 0xff01
* 16300 => 0x3fac
* -16300 => 0xc054
* 62300 => 0x00f35c
* -62300 => 0xff0ca4
*/
BigInteger.prototype.toDERInteger = BigInteger.prototype.toByteArray
BigInteger.fromBuffer = function(buffer) {
// BigInteger expects a DER integer conformant byte array
if (buffer[0] & 0x80) {
var byteArray = Array.prototype.slice.call(buffer)
return new BigInteger([0].concat(byteArray))
}
return new BigInteger(buffer)
}
BigInteger.fromHex = function(hex) {
if (hex === '') return BigInteger.ZERO
assert.equal(hex, hex.match(/^[A-Fa-f0-9]+/), 'Invalid hex string')
assert.equal(hex.length % 2, 0, 'Incomplete hex')
return new BigInteger(hex, 16)
}
BigInteger.prototype.toBuffer = function(size) {
var byteArray = this.toByteArrayUnsigned()
var zeros = []
var padding = size - byteArray.length
while (zeros.length < padding) zeros.push(0)
return new Buffer(zeros.concat(byteArray))
}
BigInteger.prototype.toHex = function(size) {
return this.toBuffer(size).toString('hex')
}
}).call(this,require("buffer").Buffer)
},{"./bigi":1,"assert":44,"buffer":46}],3:[function(require,module,exports){
var BigInteger = require('./bigi')
//addons
require('./convert')
module.exports = BigInteger
},{"./bigi":1,"./convert":2}],4:[function(require,module,exports){
module.exports={
"name": "bigi",
"version": "1.3.0",
"description": "Big integers.",
"keywords": [
"cryptography",
"math",
"bitcoin",
"arbitrary",
"precision",
"arithmetic",
"big",
"integer",
"int",
"number",
"biginteger",
"bigint",
"bignumber",
"decimal",
"float"
],
"devDependencies": {
"mocha": "^1.20.1",
"jshint": "^2.5.1",
"coveralls": "^2.10.0",
"istanbul": "^0.2.11"
},
"repository": {
"url": "https://github.com/cryptocoinjs/bigi",
"type": "git"
},
"main": "./lib/index.js",
"scripts": {
"test": "_mocha -- test/*.js",
"jshint": "jshint --config jshint.json lib/*.js ; true",
"unit": "mocha",
"coverage": "istanbul cover ./node_modules/.bin/_mocha -- --reporter list test/*.js",
"coveralls": "npm run-script coverage && node ./node_modules/.bin/coveralls < coverage/lcov.info"
},
"dependencies": {},
"testling": {
"files": "test/*.js",
"harness": "mocha",
"browsers": [
"ie/9..latest",
"firefox/latest",
"chrome/latest",
"safari/6.0..latest",
"iphone/6.0..latest",
"android-browser/4.2..latest"
]
},
"readme": "bigi\n======\n\n[![build status](https://secure.travis-ci.org/cryptocoinjs/bigi.png)](http://travis-ci.org/cryptocoinjs/bigi)\n[![Coverage Status](https://img.shields.io/coveralls/cryptocoinjs/bigi.svg)](https://coveralls.io/r/cryptocoinjs/bigi)\n[![Version](http://img.shields.io/npm/v/bigi.svg)](https://www.npmjs.org/package/bigi)\n\n[![browser support](https://ci.testling.com/cryptocoinjs/bigi.png)](https://ci.testling.com/cryptocoinjs/bigi)\n\nJavaScript library to manipulate big integers. Based on `jsbn` made by [Tom Wu](http://www-cs-students.stanford.edu/~tjw/jsbn/)\n\nOfficial documentation: \n\nhttp://cryptocoinjs.com/modules/misc/bigi/",
"readmeFilename": "README.md",
"bugs": {
"url": "https://github.com/cryptocoinjs/bigi/issues"
},
"homepage": "https://github.com/cryptocoinjs/bigi",
"_id": "bigi@1.3.0",
"_from": "bigi@^1.1.0"
}
},{}],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
// Merged Buffer refactorings from base58-native by Stephen Pair
// Copyright (c) 2013 BitPay Inc
var ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
var ALPHABET_MAP = {}
for(var i = 0; i < ALPHABET.length; i++) {
ALPHABET_MAP[ALPHABET.charAt(i)] = i
}
var BASE = 58
function encode(buffer) {
if (buffer.length === 0) return ''
var i, j, digits = [0]
for (i = 0; i < buffer.length; i++) {
for (j = 0; j < digits.length; j++) digits[j] <<= 8
digits[0] += buffer[i]
var carry = 0
for (j = 0; j < digits.length; ++j) {
digits[j] += carry
carry = (digits[j] / BASE) | 0
digits[j] %= BASE
}
while (carry) {
digits.push(carry % BASE)
carry = (carry / BASE) | 0
}
}
// deal with leading zeros
for (i = 0; buffer[i] === 0 && i < buffer.length - 1; i++) digits.push(0)
return digits.reverse().map(function(digit) { return ALPHABET[digit] }).join('')
}
function decode(string) {
if (string.length === 0) return []
var i, j, bytes = [0]
for (i = 0; i < string.length; i++) {
var c = string[i]
if (!(c in ALPHABET_MAP)) throw new Error('Non-base58 character')
for (j = 0; j < bytes.length; j++) bytes[j] *= BASE
bytes[0] += ALPHABET_MAP[c]
var carry = 0
for (j = 0; j < bytes.length; ++j) {
bytes[j] += carry
carry = bytes[j] >> 8
bytes[j] &= 0xff
}
while (carry) {
bytes.push(carry & 0xff)
carry >>= 8
}
}
// deal with leading zeros
for (i = 0; string[i] === '1' && i < string.length - 1; i++) bytes.push(0)
return bytes.reverse()
}
module.exports = {
encode: encode,
decode: decode
}
},{}],6:[function(require,module,exports){
(function (Buffer){
'use strict';
var assert = require('assert')
var base58 = require('bs58')
var crypto = require('crypto')
// SHA256(SHA256(buffer))
function sha256x2(buffer) {
buffer = crypto.createHash('sha256').update(buffer).digest()
return crypto.createHash('sha256').update(buffer).digest()
}
// Encode a buffer as a base58-check encoded string
function encode(payload) {
var checksum = sha256x2(payload).slice(0, 4)
return base58.encode(Buffer.concat([
payload,
checksum
]))
}
// Decode a base58-check encoded string to a buffer
function decode(string) {
var buffer = new Buffer(base58.decode(string))
var payload = buffer.slice(0, -4)
var checksum = buffer.slice(-4)
var newChecksum = sha256x2(payload).slice(0, 4)
assert.deepEqual(newChecksum, checksum, 'Invalid checksum')
return payload
}
module.exports = {
encode: encode,
decode: decode
}
}).call(this,require("buffer").Buffer)
},{"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'))
var rmd160 = toConstructor(require('ripemd160'))
function toConstructor (fn) {
return function () {
var buffers = []
var m= {
update: function (data, enc) {
if(!Buffer.isBuffer(data)) data = new Buffer(data, enc)
buffers.push(data)
return this
},
digest: function (enc) {
var buf = Buffer.concat(buffers)
var r = fn(buf)
buffers = null
return enc ? r.toString(enc) : r
}
}
return m
}
}
module.exports = function (alg) {
if('md5' === alg) return new md5()
if('rmd160' === alg) return new rmd160()
return createHash(alg)
}
}).call(this,require("buffer").Buffer)
},{"./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)
zeroBuffer.fill(0)
module.exports = Hmac
function Hmac (alg, key) {
if(!(this instanceof Hmac)) return new Hmac(alg, key)
this._opad = opad
this._alg = alg
var blocksize = (alg === 'sha512') ? 128 : 64
key = this._key = !Buffer.isBuffer(key) ? new Buffer(key) : key
if(key.length > blocksize) {
key = createHash(alg).update(key).digest()
} else if(key.length < blocksize) {
key = Buffer.concat([key, zeroBuffer], blocksize)
}
var ipad = this._ipad = new Buffer(blocksize)
var opad = this._opad = new Buffer(blocksize)
for(var i = 0; i < blocksize; i++) {
ipad[i] = key[i] ^ 0x36
opad[i] = key[i] ^ 0x5C
}
this._hash = createHash(alg).update(ipad)
}
Hmac.prototype.update = function (data, enc) {
this._hash.update(data, enc)
return this
}
Hmac.prototype.digest = function (enc) {
var h = this._hash.digest()
return createHash(this._alg).update(this._opad).update(h).digest(enc)
}
}).call(this,require("buffer").Buffer)
},{"./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;
function toArray(buf, bigEndian) {
if ((buf.length % intSize) !== 0) {
var len = buf.length + (intSize - (buf.length % intSize));
buf = Buffer.concat([buf, zeroBuffer], len);
}
var arr = [];
var fn = bigEndian ? buf.readInt32BE : buf.readInt32LE;
for (var i = 0; i < buf.length; i += intSize) {
arr.push(fn.call(buf, i));
}
return arr;
}
function toBuffer(arr, size, bigEndian) {
var buf = new Buffer(size);
var fn = bigEndian ? buf.writeInt32BE : buf.writeInt32LE;
for (var i = 0; i < arr.length; i++) {
fn.call(buf, arr[i], i * 4, true);
}
return buf;
}
function hash(buf, fn, hashSize, bigEndian) {
if (!Buffer.isBuffer(buf)) buf = new Buffer(buf);
var arr = fn(toArray(buf, bigEndian), buf.length * chrsz);
return toBuffer(arr, hashSize, bigEndian);
}
module.exports = { hash: hash };
}).call(this,require("buffer").Buffer)
},{"buffer":46}],10:[function(require,module,exports){
(function (Buffer){
var rng = require('./rng')
function error () {
var m = [].slice.call(arguments).join(' ')
throw new Error([
m,
'we accept pull requests',
'http://github.com/dominictarr/crypto-browserify'
].join('\n'))
}
exports.createHash = require('./create-hash')
exports.createHmac = require('./create-hmac')
exports.randomBytes = function(size, callback) {
if (callback && callback.call) {
try {
callback.call(this, undefined, new Buffer(rng(size)))
} catch (err) { callback(err) }
} else {
return new Buffer(rng(size))
}
}
function each(a, f) {
for(var i in a)
f(a[i], i)
}
exports.getHashes = function () {
return ['sha1', 'sha256', 'sha512', 'md5', 'rmd160']
}
var p = require('./pbkdf2')(exports)
exports.pbkdf2 = p.pbkdf2
exports.pbkdf2Sync = p.pbkdf2Sync
// the least I can do is make error messages for the rest of the node.js/crypto api.
each(['createCredentials'
, 'createCipher'
, 'createCipheriv'
, 'createDecipher'
, 'createDecipheriv'
, 'createSign'
, 'createVerify'
, 'createDiffieHellman'
], function (name) {
exports[name] = function () {
error('sorry,', name, 'is not implemented yet')
}
})
}).call(this,require("buffer").Buffer)
},{"./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.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for more info.
*/
var helpers = require('./helpers');
/*
* Calculate the MD5 of an array of little-endian words, and a bit length
*/
function core_md5(x, len)
{
/* append padding */
x[len >> 5] |= 0x80 << ((len) % 32);
x[(((len + 64) >>> 9) << 4) + 14] = len;
var a = 1732584193;
var b = -271733879;
var c = -1732584194;
var d = 271733878;
for(var i = 0; i < x.length; i += 16)
{
var olda = a;
var oldb = b;
var oldc = c;
var oldd = d;
a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);
a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
a = safe_add(a, olda);
b = safe_add(b, oldb);
c = safe_add(c, oldc);
d = safe_add(d, oldd);
}
return Array(a, b, c, d);
}
/*
* These functions implement the four basic operations the algorithm uses.
*/
function md5_cmn(q, a, b, x, s, t)
{
return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
}
function md5_ff(a, b, c, d, x, s, t)
{
return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
}
function md5_gg(a, b, c, d, x, s, t)
{
return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
}
function md5_hh(a, b, c, d, x, s, t)
{
return md5_cmn(b ^ c ^ d, a, b, x, s, t);
}
function md5_ii(a, b, c, d, x, s, t)
{
return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
}
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
*/
function safe_add(x, y)
{
var lsw = (x & 0xFFFF) + (y & 0xFFFF);
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
return (msw << 16) | (lsw & 0xFFFF);
}
/*
* Bitwise rotate a 32-bit number to the left.
*/
function bit_rol(num, cnt)
{
return (num << cnt) | (num >>> (32 - cnt));
}
module.exports = function md5(buf) {
return helpers.hash(buf, core_md5, 16);
};
},{"./helpers":9}],12:[function(require,module,exports){
var crypto = require('crypto')
var exportFn = require('./pbkdf2')
var exported = exportFn(crypto)
module.exports = {
pbkdf2: exported.pbkdf2,
pbkdf2Sync: exported.pbkdf2Sync,
// for crypto-browserify
__pbkdf2Export: exportFn
}
},{"./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) {
callback = digest
digest = undefined
}
if ('function' !== typeof callback)
throw new Error('No callback provided to pbkdf2')
setTimeout(function() {
var result
try {
result = pbkdf2Sync(password, salt, iterations, keylen, digest)
} catch (e) {
return callback(e)
}
callback(undefined, result)
})
}
function pbkdf2Sync(password, salt, iterations, keylen, digest) {
if ('number' !== typeof iterations)
throw new TypeError('Iterations not a number')
if (iterations < 0)
throw new TypeError('Bad iterations')
if ('number' !== typeof keylen)
throw new TypeError('Key length not a number')
if (keylen < 0)
throw new TypeError('Bad key length')
digest = digest || 'sha1'
if (!Buffer.isBuffer(password)) password = new Buffer(password)
if (!Buffer.isBuffer(salt)) salt = new Buffer(salt)
var hLen, l = 1, r, T
var DK = new Buffer(keylen)
var block1 = new Buffer(salt.length + 4)
salt.copy(block1, 0, 0, salt.length)
for (var i = 1; i <= l; i++) {
block1.writeUInt32BE(i, salt.length)
var U = crypto.createHmac(digest, password).update(block1).digest()
if (!hLen) {
hLen = U.length
T = new Buffer(hLen)
l = Math.ceil(keylen / hLen)
r = keylen - (l - 1) * hLen
if (keylen > (Math.pow(2, 32) - 1) * hLen)
throw new TypeError('keylen exceeds maximum length')
}
U.copy(T, 0, 0, hLen)
for (var j = 1; j < iterations; j++) {
U = crypto.createHmac(digest, password).update(U).digest()
for (var k = 0; k < hLen; k++) {
T[k] ^= U[k]
}
}
var destPos = (i - 1) * hLen
var len = (i == l ? r : hLen)
T.copy(DK, destPos, 0, len)
}
return DK
}
return {
pbkdf2: pbkdf2,
pbkdf2Sync: pbkdf2Sync
}
}
}).call(this,require("buffer").Buffer)
},{"buffer":46}],14:[function(require,module,exports){
(function (Buffer){
module.exports = ripemd160
/*
CryptoJS v3.1.2
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
/** @preserve
(c) 2012 by Cédric Mesnil. All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// Constants table
var zl = [
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13];
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,
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11];
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,
9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 ];
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,
8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 ];
var hl = [ 0x00000000, 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xA953FD4E];
var hr = [ 0x50A28BE6, 0x5C4DD124, 0x6D703EF3, 0x7A6D76E9, 0x00000000];
var bytesToWords = function (bytes) {
var words = [];
for (var i = 0, b = 0; i < bytes.length; i++, b += 8) {
words[b >>> 5] |= bytes[i] << (24 - b % 32);
}
return words;
};
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);
}
return bytes;
};
var processBlock = function (H, M, offset) {
// Swap endian
for (var i = 0; i < 16; i++) {
var offset_i = offset + i;
var M_offset_i = M[offset_i];
// Swap
M[offset_i] = (
(((M_offset_i << 8) | (M_offset_i >>> 24)) & 0x00ff00ff) |
(((M_offset_i << 24) | (M_offset_i >>> 8)) & 0xff00ff00)
);
}
// Working variables
var al, bl, cl, dl, el;
var ar, br, cr, dr, er;
ar = al = H[0];
br = bl = H[1];
cr = cl = H[2];
dr = dl = H[3];
er = el = H[4];
// Computation
var t;
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) {
t += f2(bl,cl,dl) + hl[1];
} else if (i<48) {
t += f3(bl,cl,dl) + hl[2];
} else if (i<64) {
t += f4(bl,cl,dl) + hl[3];
} else {// if (i<80) {
t += f5(bl,cl,dl) + hl[4];
}
t = t|0;
t = rotl(t,sl[i]);
t = (t+el)|0;
al = el;
el = dl;
dl = rotl(cl, 10);
cl = bl;
bl = t;
t = (ar + M[offset+zr[i]])|0;
if (i<16){
t += f5(br,cr,dr) + hr[0];
} else if (i<32) {
t += f4(br,cr,dr) + hr[1];
} else if (i<48) {
t += f3(br,cr,dr) + hr[2];
} else if (i<64) {
t += f2(br,cr,dr) + hr[3];
} else {// if (i<80) {
t += f1(br,cr,dr) + hr[4];
}
t = t|0;
t = rotl(t,sr[i]) ;
t = (t+er)|0;
ar = er;
er = dr;
dr = rotl(cr, 10);
cr = br;
br = t;
}
// Intermediate hash value
t = (H[1] + cl + dr)|0;
H[1] = (H[2] + dl + er)|0;
H[2] = (H[3] + el + ar)|0;
H[3] = (H[4] + al + br)|0;
H[4] = (H[0] + bl + cr)|0;
H[0] = t;
};
function f1(x, y, z) {
return ((x) ^ (y) ^ (z));
}
function f2(x, y, z) {
return (((x)&(y)) | ((~x)&(z)));
}
function f3(x, y, z) {
return (((x) | (~(y))) ^ (z));
}
function f4(x, y, z) {
return (((x) & (z)) | ((y)&(~(z))));
}
function f5(x, y, z) {
return ((x) ^ ((y) |(~(z))));
}
function rotl(x,n) {
return (x<<n) | (x>>>(32-n));
}
function ripemd160(message) {
var H = [0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0];
if (typeof message == 'string')
message = new Buffer(message, 'utf8');
var m = bytesToWords(message);
var nBitsLeft = message.length * 8;
var nBitsTotal = message.length * 8;
// Add padding
m[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
m[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
(((nBitsTotal << 8) | (nBitsTotal >>> 24)) & 0x00ff00ff) |
(((nBitsTotal << 24) | (nBitsTotal >>> 8)) & 0xff00ff00)
);
for (var i=0 ; i<m.length; i += 16) {
processBlock(H, m, i);
}
// Swap endian
for (var i = 0; i < 5; i++) {
// Shortcut
var H_i = H[i];
// Swap
H[i] = (((H_i << 8) | (H_i >>> 24)) & 0x00ff00ff) |
(((H_i << 24) | (H_i >>> 8)) & 0xff00ff00);
}
var digestbytes = wordsToBytes(H);
return new Buffer(digestbytes);
}
}).call(this,require("buffer").Buffer)
},{"buffer":46}],15:[function(require,module,exports){
module.exports = function (Buffer) {
//prototype class for hash functions
function Hash (blockSize, finalSize) {
this._block = new Buffer(blockSize) //new Uint32Array(blockSize/4)
this._finalSize = finalSize
this._blockSize = blockSize
this._len = 0
this._s = 0
}
Hash.prototype.init = function () {
this._s = 0
this._len = 0
}
Hash.prototype.update = function (data, enc) {
if ("string" === typeof data) {
enc = enc || "utf8"
data = new Buffer(data, enc)
}
var l = this._len += data.length
var s = this._s = (this._s || 0)
var f = 0
var buffer = this._block
while (s < l) {
var t = Math.min(data.length, f + this._blockSize - (s % this._blockSize))
var ch = (t - f)
for (var i = 0; i < ch; i++) {
buffer[(s % this._blockSize) + i] = data[i + f]
}
s += ch
f += ch
if ((s % this._blockSize) === 0) {
this._update(buffer)
}
}
this._s = s
return this
}
Hash.prototype.digest = function (enc) {
// Suppose the length of the message M, in bits, is l
var l = this._len * 8
// Append the bit 1 to the end of the message
this._block[this._len % this._blockSize] = 0x80
// and then k zero bits, where k is the smallest non-negative solution to the equation (l + 1 + k) === finalSize mod blockSize
this._block.fill(0, this._len % this._blockSize + 1)
if (l % (this._blockSize * 8) >= this._finalSize * 8) {
this._update(this._block)
this._block.fill(0)
}
// to this append the block which is equal to the number l written in binary
// TODO: handle case where l is > Math.pow(2, 29)
this._block.writeInt32BE(l, this._blockSize - 4)
var hash = this._update(this._block) || this._hash()
return enc ? hash.toString(enc) : hash
}
Hash.prototype._update = function () {
throw new Error('_update must be implemented by subclass')
}
return Hash
}
},{}],16:[function(require,module,exports){
var exports = module.exports = function (alg) {
var Alg = exports[alg]
if(!Alg) throw new Error(alg + ' is not supported (we accept pull requests)')
return new Alg()
}
var Buffer = require('buffer').Buffer
var Hash = require('./hash')(Buffer)
exports.sha1 = require('./sha1')(Buffer, Hash)
exports.sha256 = require('./sha256')(Buffer, Hash)
exports.sha512 = require('./sha512')(Buffer, Hash)
},{"./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.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
* Distributed under the BSD License
* See http://pajhome.org.uk/crypt/md5 for details.
*/
var inherits = require('util').inherits
module.exports = function (Buffer, Hash) {
var A = 0|0
var B = 4|0
var C = 8|0
var D = 12|0
var E = 16|0
var W = new (typeof Int32Array === 'undefined' ? Array : Int32Array)(80)
var POOL = []
function Sha1 () {
if(POOL.length)
return POOL.pop().init()
if(!(this instanceof Sha1)) return new Sha1()
this._w = W
Hash.call(this, 16*4, 14*4)
this._h = null
this.init()
}
inherits(Sha1, Hash)
Sha1.prototype.init = function () {
this._a = 0x67452301
this._b = 0xefcdab89
this._c = 0x98badcfe
this._d = 0x10325476
this._e = 0xc3d2e1f0
Hash.prototype.init.call(this)
return this
}
Sha1.prototype._POOL = POOL
Sha1.prototype._update = function (X) {
var a, b, c, d, e, _a, _b, _c, _d, _e
a = _a = this._a
b = _b = this._b
c = _c = this._c
d = _d = this._d
e = _e = this._e
var w = this._w
for(var j = 0; j < 80; j++) {
var W = w[j] = j < 16 ? X.readInt32BE(j*4)
: rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1)
var t = add(
add(rol(a, 5), sha1_ft(j, b, c, d)),
add(add(e, W), sha1_kt(j))
)
e = d
d = c
c = rol(b, 30)
b = a
a = t
}
this._a = add(a, _a)
this._b = add(b, _b)
this._c = add(c, _c)
this._d = add(d, _d)
this._e = add(e, _e)
}
Sha1.prototype._hash = function () {
if(POOL.length < 100) POOL.push(this)
var H = new Buffer(20)
//console.log(this._a|0, this._b|0, this._c|0, this._d|0, this._e|0)
H.writeInt32BE(this._a|0, A)
H.writeInt32BE(this._b|0, B)
H.writeInt32BE(this._c|0, C)
H.writeInt32BE(this._d|0, D)
H.writeInt32BE(this._e|0, E)
return H
}
/*
* Perform the appropriate triplet combination function for the current
* iteration
*/
function sha1_ft(t, b, c, d) {
if(t < 20) return (b & c) | ((~b) & d);
if(t < 40) return b ^ c ^ d;
if(t < 60) return (b & c) | (b & d) | (c & d);
return b ^ c ^ d;
}
/*
* Determine the appropriate additive constant for the current iteration
*/
function sha1_kt(t) {
return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 :
(t < 60) ? -1894007588 : -899497514;
}
/*
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
* to work around bugs in some JS interpreters.
* //dominictarr: this is 10 years old, so maybe this can be dropped?)
*
*/
function add(x, y) {
return (x + y ) | 0
//lets see how this goes on testling.
// var lsw = (x & 0xFFFF) + (y & 0xFFFF);
// var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
// return (msw << 16) | (lsw & 0xFFFF);
}
/*
* Bitwise rotate a 32-bit number to the left.
*/
function rol(num, cnt) {
return (num << cnt) | (num >>> (32 - cnt));
}
return Sha1
}
},{"util":68}],18:[function(require,module,exports){
/**
* A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined
* in FIPS 180-2
* Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.
* Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
*
*/
var inherits = require('util').inherits
module.exports = function (Buffer, Hash) {
var K = [
0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
]
var W = new Array(64)
function Sha256() {
this.init()
this._w = W //new Array(64)
Hash.call(this, 16*4, 14*4)
}
inherits(Sha256, Hash)
Sha256.prototype.init = function () {
this._a = 0x6a09e667|0
this._b = 0xbb67ae85|0
this._c = 0x3c6ef372|0
this._d = 0xa54ff53a|0
this._e = 0x510e527f|0
this._f = 0x9b05688c|0
this._g = 0x1f83d9ab|0
this._h = 0x5be0cd19|0
this._len = this._s = 0
return this
}
function S (X, n) {
return (X >>> n) | (X << (32 - n));
}
function R (X, n) {
return (X >>> n);
}
function Ch (x, y, z) {
return ((x & y) ^ ((~x) & z));
}
function Maj (x, y, z) {
return ((x & y) ^ (x & z) ^ (y & z));
}
function Sigma0256 (x) {
return (S(x, 2) ^ S(x, 13) ^ S(x, 22));
}
function Sigma1256 (x) {
return (S(x, 6) ^ S(x, 11) ^ S(x, 25));
}
function Gamma0256 (x) {
return (S(x, 7) ^ S(x, 18) ^ R(x, 3));
}
function Gamma1256 (x) {
return (S(x, 17) ^ S(x, 19) ^ R(x, 10));
}
Sha256.prototype._update = function(M) {
var W = this._w
var a, b, c, d, e, f, g, h
var T1, T2
a = this._a | 0
b = this._b | 0
c = this._c | 0
d = this._d | 0
e = this._e | 0
f = this._f | 0
g = this._g | 0
h = this._h | 0
for (var j = 0; j < 64; j++) {
var w = W[j] = j < 16
? M.readInt32BE(j * 4)
: Gamma1256(W[j - 2]) + W[j - 7] + Gamma0256(W[j - 15]) + W[j - 16]
T1 = h + Sigma1256(e) + Ch(e, f, g) + K[j] + w
T2 = Sigma0256(a) + Maj(a, b, c);
h = g; g = f; f = e; e = d + T1; d = c; c = b; b = a; a = T1 + T2;
}
this._a = (a + this._a) | 0
this._b = (b + this._b) | 0
this._c = (c + this._c) | 0
this._d = (d + this._d) | 0
this._e = (e + this._e) | 0
this._f = (f + this._f) | 0
this._g = (g + this._g) | 0
this._h = (h + this._h) | 0
};
Sha256.prototype._hash = function () {
var H = new Buffer(32)
H.writeInt32BE(this._a, 0)
H.writeInt32BE(this._b, 4)
H.writeInt32BE(this._c, 8)
H.writeInt32BE(this._d, 12)
H.writeInt32BE(this._e, 16)
H.writeInt32BE(this._f, 20)
H.writeInt32BE(this._g, 24)
H.writeInt32BE(this._h, 28)
return H
}
return Sha256
}
},{"util":68}],19:[function(require,module,exports){
var inherits = require('util').inherits
module.exports = function (Buffer, Hash) {
var K = [
0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,
0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,
0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,
0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,
0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,
0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,
0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,
0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,
0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,
0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,
0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,
0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,
0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,
0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,
0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,
0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,
0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,
0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,
0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817
]
var W = new Array(160)
function Sha512() {
this.init()
this._w = W
Hash.call(this, 128, 112)
}
inherits(Sha512, Hash)
Sha512.prototype.init = function () {
this._a = 0x6a09e667|0
this._b = 0xbb67ae85|0
this._c = 0x3c6ef372|0
this._d = 0xa54ff53a|0
this._e = 0x510e527f|0
this._f = 0x9b05688c|0
this._g = 0x1f83d9ab|0
this._h = 0x5be0cd19|0
this._al = 0xf3bcc908|0
this._bl = 0x84caa73b|0
this._cl = 0xfe94f82b|0
this._dl = 0x5f1d36f1|0
this._el = 0xade682d1|0
this._fl = 0x2b3e6c1f|0
this._gl = 0xfb41bd6b|0
this._hl = 0x137e2179|0
this._len = this._s = 0
return this
}
function S (X, Xl, n) {
return (X >>> n) | (Xl << (32 - n))
}
function Ch (x, y, z) {
return ((x & y) ^ ((~x) & z));
}
function Maj (x, y, z) {
return ((x & y) ^ (x & z) ^ (y & z));
}
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
a = this._a | 0
b = this._b | 0
c = this._c | 0
d = this._d | 0
e = this._e | 0
f = this._f | 0
g = this._g | 0
h = this._h | 0
al = this._al | 0
bl = this._bl | 0
cl = this._cl | 0
dl = this._dl | 0
el = this._el | 0
fl = this._fl | 0
gl = this._gl | 0
hl = this._hl | 0
for (var i = 0; i < 80; i++) {
var j = i * 2
var Wi, Wil
if (i < 16) {
Wi = W[j] = M.readInt32BE(j * 4)
Wil = W[j + 1] = M.readInt32BE(j * 4 + 4)
} else {
var x = W[j - 15*2]
var xl = W[j - 15*2 + 1]
var gamma0 = S(x, xl, 1) ^ S(x, xl, 8) ^ (x >>> 7)
var gamma0l = S(xl, x, 1) ^ S(xl, x, 8) ^ S(xl, x, 7)
x = W[j - 2*2]
xl = W[j - 2*2 + 1]
var gamma1 = S(x, xl, 19) ^ S(xl, x, 29) ^ (x >>> 6)
var gamma1l = S(xl, x, 19) ^ S(x, xl, 29) ^ S(xl, x, 6)
// W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]
var Wi7 = W[j - 7*2]
var Wi7l = W[j - 7*2 + 1]
var Wi16 = W[j - 16*2]
var Wi16l = W[j - 16*2 + 1]
Wil = gamma0l + Wi7l
Wi = gamma0 + Wi7 + ((Wil >>> 0) < (gamma0l >>> 0) ? 1 : 0)
Wil = Wil + gamma1l
Wi = Wi + gamma1 + ((Wil >>> 0) < (gamma1l >>> 0) ? 1 : 0)
Wil = Wil + Wi16l
Wi = Wi + Wi16 + ((Wil >>> 0) < (Wi16l >>> 0) ? 1 : 0)
W[j] = Wi
W[j + 1] = Wil
}
var maj = Maj(a, b, c)
var majl = Maj(al, bl, cl)
var sigma0h = S(a, al, 28) ^ S(al, a, 2) ^ S(al, a, 7)
var sigma0l = S(al, a, 28) ^ S(a, al, 2) ^ S(a, al, 7)
var sigma1h = S(e, el, 14) ^ S(e, el, 18) ^ S(el, e, 9)
var sigma1l = S(el, e, 14) ^ S(el, e, 18) ^ S(e, el, 9)
// t1 = h + sigma1 + ch + K[i] + W[i]
var Ki = K[j]
var Kil = K[j + 1]
var ch = Ch(e, f, g)
var chl = Ch(el, fl, gl)
var t1l = hl + sigma1l
var t1 = h + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0)
t1l = t1l + chl
t1 = t1 + ch + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0)
t1l = t1l + Kil
t1 = t1 + Ki + ((t1l >>> 0) < (Kil >>> 0) ? 1 : 0)
t1l = t1l + Wil
t1 = t1 + Wi + ((t1l >>> 0) < (Wil >>> 0) ? 1 : 0)
// t2 = sigma0 + maj
var t2l = sigma0l + majl
var t2 = sigma0h + maj + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0)
h = g
hl = gl
g = f
gl = fl
f = e
fl = el
el = (dl + t1l) | 0
e = (d + t1 + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0
d = c
dl = cl
c = b
cl = bl
b = a
bl = al
al = (t1l + t2l) | 0
a = (t1 + t2 + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0
}
this._al = (this._al + al) | 0
this._bl = (this._bl + bl) | 0
this._cl = (this._cl + cl) | 0
this._dl = (this._dl + dl) | 0
this._el = (this._el + el) | 0
this._fl = (this._fl + fl) | 0
this._gl = (this._gl + gl) | 0
this._hl = (this._hl + hl) | 0
this._a = (this._a + a + ((this._al >>> 0) < (al >>> 0) ? 1 : 0)) | 0
this._b = (this._b + b + ((this._bl >>> 0) < (bl >>> 0) ? 1 : 0)) | 0
this._c = (this._c + c + ((this._cl >>> 0) < (cl >>> 0) ? 1 : 0)) | 0
this._d = (this._d + d + ((this._dl >>> 0) < (dl >>> 0) ? 1 : 0)) | 0
this._e = (this._e + e + ((this._el >>> 0) < (el >>> 0) ? 1 : 0)) | 0
this._f = (this._f + f + ((this._fl >>> 0) < (fl >>> 0) ? 1 : 0)) | 0
this._g = (this._g + g + ((this._gl >>> 0) < (gl >>> 0) ? 1 : 0)) | 0
this._h = (this._h + h + ((this._hl >>> 0) < (hl >>> 0) ? 1 : 0)) | 0
}
Sha512.prototype._hash = function () {
var H = new Buffer(64)
function writeInt64BE(h, l, offset) {
H.writeInt32BE(h, offset)
H.writeInt32BE(l, offset + 4)
}
writeInt64BE(this._a, this._al, 0)
writeInt64BE(this._b, this._bl, 8)
writeInt64BE(this._c, this._cl, 16)
writeInt64BE(this._d, this._dl, 24)
writeInt64BE(this._e, this._el, 32)
writeInt64BE(this._f, this._fl, 40)
writeInt64BE(this._g, this._gl, 48)
writeInt64BE(this._h, this._hl, 56)
return H
}
return Sha512
}
},{"util":68}],20:[function(require,module,exports){
var pbkdf2Export = require('pbkdf2-compat').__pbkdf2Export
module.exports = function (crypto, exports) {
exports = exports || {}
var exported = pbkdf2Export(crypto)
exports.pbkdf2 = exported.pbkdf2
exports.pbkdf2Sync = exported.pbkdf2Sync
return exports
}
},{"pbkdf2-compat":12}],21:[function(require,module,exports){
(function (global,Buffer){
(function() {
var g = ('undefined' === typeof window ? global : window) || {}
_crypto = (
g.crypto || g.msCrypto || require('crypto')
)
module.exports = function(size) {
// Modern Browsers
if(_crypto.getRandomValues) {
var bytes = new Buffer(size); //in browserify, this is an extended Uint8Array
/* This will not work in older browsers.
* See https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
*/
_crypto.getRandomValues(bytes);
return bytes;
}
else if (_crypto.randomBytes) {
return _crypto.randomBytes(size)
}
else
throw new Error(
'secure random number generation not supported by this browser\n'+
'use chrome, FireFox or Internet Explorer 11'
)
}
}())
}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
},{"buffer":46,"crypto":45}],22:[function(require,module,exports){
var assert = require('assert')
var BigInteger = require('bigi')
var Point = require('./point')
function Curve(p, a, b, Gx, Gy, n, h) {
this.p = p
this.a = a
this.b = b
this.G = Point.fromAffine(this, Gx, Gy)
this.n = n
this.h = h
this.infinity = new Point(this, null, null, BigInteger.ZERO)
// result caching
this.pOverFour = p.add(BigInteger.ONE).shiftRight(2)
}
Curve.prototype.pointFromX = function(isOdd, x) {
var alpha = x.pow(3).add(this.a.multiply(x)).add(this.b).mod(this.p)
var beta = alpha.modPow(this.pOverFour, this.p)
var y = beta
if (beta.isEven() ^ !isOdd) {
y = this.p.subtract(y) // -y % p
}
return Point.fromAffine(this, x, y)
}
Curve.prototype.isInfinity = function(Q) {
if (Q === this.infinity) return true
return Q.z.signum() === 0 && Q.y.signum() !== 0
}
Curve.prototype.isOnCurve = function(Q) {
if (this.isInfinity(Q)) return true
var x = Q.affineX
var y = Q.affineY
var a = this.a
var b = this.b
var p = this.p
// Check that xQ and yQ are integers in the interval [0, p - 1]
if (x.signum() < 0 || x.compareTo(p) >= 0) return false
if (y.signum() < 0 || y.compareTo(p) >= 0) return false
// and check that y^2 = x^3 + ax + b (mod p)
var lhs = y.square().mod(p)
var rhs = x.pow(3).add(a.multiply(x)).add(b).mod(p)
return lhs.equals(rhs)
}
/**
* Validate an elliptic curve point.
*
* See SEC 1, section 3.2.2.1: Elliptic Curve Public Key Validation Primitive
*/
Curve.prototype.validate = function(Q) {
// Check Q != O
assert(!this.isInfinity(Q), 'Point is at infinity')
assert(this.isOnCurve(Q), 'Point is not on the curve')
// Check nQ = O (where Q is a scalar multiple of G)
var nQ = Q.multiply(this.n)
assert(this.isInfinity(nQ), 'Point is not a scalar multiple of G')
return true
}
module.exports = Curve
},{"./point":26,"assert":44,"bigi":3}],23:[function(require,module,exports){
module.exports={
"secp128r1": {
"p": "fffffffdffffffffffffffffffffffff",
"a": "fffffffdfffffffffffffffffffffffc",
"b": "e87579c11079f43dd824993c2cee5ed3",
"n": "fffffffe0000000075a30d1b9038a115",
"h": "01",
"Gx": "161ff7528b899b2d0c28607ca52c5b86",
"Gy": "cf5ac8395bafeb13c02da292dded7a83"
},
"secp160k1": {
"p": "fffffffffffffffffffffffffffffffeffffac73",
"a": "00",
"b": "07",
"n": "0100000000000000000001b8fa16dfab9aca16b6b3",
"h": "01",
"Gx": "3b4c382ce37aa192a4019e763036f4f5dd4d7ebb",
"Gy": "938cf935318fdced6bc28286531733c3f03c4fee"
},
"secp160r1": {
"p": "ffffffffffffffffffffffffffffffff7fffffff",
"a": "ffffffffffffffffffffffffffffffff7ffffffc",
"b": "1c97befc54bd7a8b65acf89f81d4d4adc565fa45",
"n": "0100000000000000000001f4c8f927aed3ca752257",
"h": "01",
"Gx": "4a96b5688ef573284664698968c38bb913cbfc82",
"Gy": "23a628553168947d59dcc912042351377ac5fb32"
},
"secp192k1": {
"p": "fffffffffffffffffffffffffffffffffffffffeffffee37",
"a": "00",
"b": "03",
"n": "fffffffffffffffffffffffe26f2fc170f69466a74defd8d",
"h": "01",
"Gx": "db4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d",
"Gy": "9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d"
},
"secp192r1": {
"p": "fffffffffffffffffffffffffffffffeffffffffffffffff",
"a": "fffffffffffffffffffffffffffffffefffffffffffffffc",
"b": "64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1",
"n": "ffffffffffffffffffffffff99def836146bc9b1b4d22831",
"h": "01",
"Gx": "188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012",
"Gy": "07192b95ffc8da78631011ed6b24cdd573f977a11e794811"
},
"secp256k1": {
"p": "fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f",
"a": "00",
"b": "07",
"n": "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141",
"h": "01",
"Gx": "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
"Gy": "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"
},
"secp256r1": {
"p": "ffffffff00000001000000000000000000000000ffffffffffffffffffffffff",
"a": "ffffffff00000001000000000000000000000000fffffffffffffffffffffffc",
"b": "5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
"n": "ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
"h": "01",
"Gx": "6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
"Gy": "4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5"
}
}
},{}],24:[function(require,module,exports){
var Point = require('./point')
var Curve = require('./curve')
var getCurveByName = require('./names')
module.exports = {
Curve: Curve,
Point: Point,
getCurveByName: getCurveByName
}
},{"./curve":22,"./names":25,"./point":26}],25:[function(require,module,exports){
var BigInteger = require('bigi')
var curves = require('./curves')
var Curve = require('./curve')
function getCurveByName(name) {
var curve = curves[name]
if (!curve) return null
var p = new BigInteger(curve.p, 16)
var a = new BigInteger(curve.a, 16)
var b = new BigInteger(curve.b, 16)
var n = new BigInteger(curve.n, 16)
var h = new BigInteger(curve.h, 16)
var Gx = new BigInteger(curve.Gx, 16)
var Gy = new BigInteger(curve.Gy, 16)
return new Curve(p, a, b, Gx, Gy, n, h)
}
module.exports = getCurveByName
},{"./curve":22,"./curves":23,"bigi":3}],26:[function(require,module,exports){
(function (Buffer){
var assert = require('assert')
var BigInteger = require('bigi')
var THREE = BigInteger.valueOf(3)
function Point(curve, x, y, z) {
assert.notStrictEqual(z, undefined, 'Missing Z coordinate')
this.curve = curve
this.x = x
this.y = y
this.z = z
this._zInv = null
this.compressed = true
}
Object.defineProperty(Point.prototype, 'zInv', {
get: function() {
if (this._zInv === null) {
this._zInv = this.z.modInverse(this.curve.p)
}
return this._zInv
}
})
Object.defineProperty(Point.prototype, 'affineX', {
get: function() {
return this.x.multiply(this.zInv).mod(this.curve.p)
}
})
Object.defineProperty(Point.prototype, 'affineY', {
get: function() {
return this.y.multiply(this.zInv).mod(this.curve.p)
}
})
Point.fromAffine = function(curve, x, y) {
return new Point(curve, x, y, BigInteger.ONE)
}
Point.prototype.equals = function(other) {
if (other === this) return true
if (this.curve.isInfinity(this)) return this.curve.isInfinity(other)
if (this.curve.isInfinity(other)) return this.curve.isInfinity(this)
// u = Y2 * Z1 - Y1 * Z2
var u = other.y.multiply(this.z).subtract(this.y.multiply(other.z)).mod(this.curve.p)
if (u.signum() !== 0) return false
// v = X2 * Z1 - X1 * Z2
var v = other.x.multiply(this.z).subtract(this.x.multiply(other.z)).mod(this.curve.p)
return v.signum() === 0
}
Point.prototype.negate = function() {
var y = this.curve.p.subtract(this.y)
return new Point(this.curve, this.x, y, this.z)
}
Point.prototype.add = function(b) {
if (this.curve.isInfinity(this)) return b
if (this.curve.isInfinity(b)) return this
var x1 = this.x
var y1 = this.y
var x2 = b.x
var y2 = b.y
// u = Y2 * Z1 - Y1 * Z2
var u = y2.multiply(this.z).subtract(y1.multiply(b.z)).mod(this.curve.p)
// v = X2 * Z1 - X1 * Z2
var v = x2.multiply(this.z).subtract(x1.multiply(b.z)).mod(this.curve.p)
if (v.signum() === 0) {
if (u.signum() === 0) {
return this.twice() // this == b, so double
}
return this.curve.infinity // this = -b, so infinity
}
var v2 = v.square()
var v3 = v2.multiply(v)
var x1v2 = x1.multiply(v2)
var zu2 = u.square().multiply(this.z)
// x3 = v * (z2 * (z1 * u^2 - 2 * x1 * v^2) - v^3)
var x3 = zu2.subtract(x1v2.shiftLeft(1)).multiply(b.z).subtract(v3).multiply(v).mod(this.curve.p)
// y3 = z2 * (3 * x1 * u * v^2 - y1 * v^3 - z1 * u^3) + u * v^3
var y3 = x1v2.multiply(THREE).multiply(u).subtract(y1.multiply(v3)).subtract(zu2.multiply(u)).multiply(b.z).add(u.multiply(v3)).mod(this.curve.p)
// z3 = v^3 * z1 * z2
var z3 = v3.multiply(this.z).multiply(b.z).mod(this.curve.p)
return new Point(this.curve, x3, y3, z3)
}
Point.prototype.twice = function() {
if (this.curve.isInfinity(this)) return this
if (this.y.signum() === 0) return this.curve.infinity
var x1 = this.x
var y1 = this.y
var y1z1 = y1.multiply(this.z)
var y1sqz1 = y1z1.multiply(y1).mod(this.curve.p)
var a = this.curve.a
// w = 3 * x1^2 + a * z1^2
var w = x1.square().multiply(THREE)
if (a.signum() !== 0) {
w = w.add(this.z.square().multiply(a))
}
w = w.mod(this.curve.p)
// x3 = 2 * y1 * z1 * (w^2 - 8 * x1 * y1^2 * z1)
var x3 = w.square().subtract(x1.shiftLeft(3).multiply(y1sqz1)).shiftLeft(1).multiply(y1z1).mod(this.curve.p)
// y3 = 4 * y1^2 * z1 * (3 * w * x1 - 2 * y1^2 * z1) - w^3
var y3 = w.multiply(THREE).multiply(x1).subtract(y1sqz1.shiftLeft(1)).shiftLeft(2).multiply(y1sqz1).subtract(w.pow(3)).mod(this.curve.p)
// z3 = 8 * (y1 * z1)^3
var z3 = y1z1.pow(3).shiftLeft(3).mod(this.curve.p)
return new Point(this.curve, x3, y3, z3)
}
// Simple NAF (Non-Adjacent Form) multiplication algorithm
// TODO: modularize the multiplication algorithm
Point.prototype.multiply = function(k) {
if (this.curve.isInfinity(this)) return this
if (k.signum() === 0) return this.curve.infinity
var e = k
var h = e.multiply(THREE)
var neg = this.negate()
var R = this
for (var i = h.bitLength() - 2; i > 0; --i) {
R = R.twice()
var hBit = h.testBit(i)
var eBit = e.testBit(i)
if (hBit != eBit) {
R = R.add(hBit ? this : neg)
}
}
return R
}
// Compute this*j + x*k (simultaneous multiplication)
Point.prototype.multiplyTwo = function(j, x, k) {
var i
if (j.bitLength() > k.bitLength())
i = j.bitLength() - 1
else
i = k.bitLength() - 1
var R = this.curve.infinity
var both = this.add(x)
while (i >= 0) {
R = R.twice()
var jBit = j.testBit(i)
var kBit = k.testBit(i)
if (jBit) {
if (kBit) {
R = R.add(both)
} else {
R = R.add(this)
}
} else {
if (kBit) {
R = R.add(x)
}
}
--i
}
return R
}
Point.prototype.getEncoded = function(compressed) {
if (compressed == undefined) compressed = this.compressed
if (this.curve.isInfinity(this)) return new Buffer('00', 'hex') // Infinity point encoded is simply '00'
var x = this.affineX
var y = this.affineY
var buffer
// Determine size of q in bytes
var byteLength = Math.floor((this.curve.p.bitLength() + 7) / 8)
// 0x02/0x03 | X
if (compressed) {
buffer = new Buffer(1 + byteLength)
buffer.writeUInt8(y.isEven() ? 0x02 : 0x03, 0)
// 0x04 | X | Y
} else {
buffer = new Buffer(1 + byteLength + byteLength)
buffer.writeUInt8(0x04, 0)
y.toBuffer(byteLength).copy(buffer, 1 + byteLength)
}
x.toBuffer(byteLength).copy(buffer, 1)
return buffer
}
Point.decodeFrom = function(curve, buffer) {
var type = buffer.readUInt8(0)
var compressed = (type !== 4)
var x = BigInteger.fromBuffer(buffer.slice(1, 33))
var byteLength = Math.floor((curve.p.bitLength() + 7) / 8)
var Q
if (compressed) {
assert.equal(buffer.length, byteLength + 1, 'Invalid sequence length')
assert(type === 0x02 || type === 0x03, 'Invalid sequence tag')
var isOdd = (type === 0x03)
Q = curve.pointFromX(isOdd, x)
} else {
assert.equal(buffer.length, 1 + byteLength + byteLength, 'Invalid sequence length')
var y = BigInteger.fromBuffer(buffer.slice(1 + byteLength))
Q = Point.fromAffine(curve, x, y)
}
Q.compressed = compressed
return Q
}
Point.prototype.toString = function () {
if (this.curve.isInfinity(this)) return '(INFINITY)'
return '(' + this.affineX.toString() + ',' + this.affineY.toString() + ')'
}
module.exports = Point
}).call(this,require("buffer").Buffer)
},{"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')
var networks = require('./networks')
var scripts = require('./scripts')
function findScriptTypeByVersion(version) {
for (var networkName in networks) {
var network = networks[networkName]
if (version === network.pubKeyHash) return 'pubkeyhash'
if (version === network.scriptHash) return 'scripthash'
}
}
function Address(hash, version) {
enforceType('Buffer', hash)
assert.strictEqual(hash.length, 20, 'Invalid hash length')
assert.strictEqual(version & 0xff, version, 'Invalid version byte')
this.hash = hash
this.version = version
}
// Import functions
Address.fromBase58Check = function(string) {
var payload = base58check.decode(string)
var version = payload.readUInt8(0)
var hash = payload.slice(1)
return new Address(hash, version)
}
Address.fromOutputScript = function(script, network) {
network = network || networks.bitcoin
var type = scripts.classifyOutput(script)
if (type === 'pubkeyhash') return new Address(script.chunks[2], network.pubKeyHash)
if (type === 'scripthash') return new Address(script.chunks[1], network.scriptHash)
assert(false, type + ' has no matching Address')
}
// Export functions
Address.prototype.toBase58Check = function () {
var payload = new Buffer(21)
payload.writeUInt8(this.version, 0)
this.hash.copy(payload, 1)
return base58check.encode(payload)
}
Address.prototype.toOutputScript = function() {
var scriptType = findScriptTypeByVersion(this.version)
if (scriptType === 'pubkeyhash') return scripts.pubKeyHashOutput(this.hash)
if (scriptType === 'scripthash') return scripts.scriptHashOutput(this.hash)
assert(false, this.toString() + ' has no matching Script')
}
Address.prototype.toString = Address.prototype.toBase58Check
module.exports = Address
}).call(this,require("buffer").Buffer)
},{"./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')
// https://github.com/feross/buffer/blob/master/index.js#L1127
function verifuint(value, max) {
assert(typeof value === 'number', 'cannot write a non-number as a number')
assert(value >= 0, 'specified a negative value for writing an unsigned value')
assert(value <= max, 'value is larger than maximum value for type')
assert(Math.floor(value) === value, 'value has a fractional component')
}
function pushDataSize(i) {
return i < opcodes.OP_PUSHDATA1 ? 1
: i < 0xff ? 2
: i < 0xffff ? 3
: 5
}
function readPushDataInt(buffer, offset) {
var opcode = buffer.readUInt8(offset)
var number, size
// ~6 bit
if (opcode < opcodes.OP_PUSHDATA1) {
number = opcode
size = 1
// 8 bit
} else if (opcode === opcodes.OP_PUSHDATA1) {
number = buffer.readUInt8(offset + 1)
size = 2
// 16 bit
} else if (opcode === opcodes.OP_PUSHDATA2) {
number = buffer.readUInt16LE(offset + 1)
size = 3
// 32 bit
} else {
assert.equal(opcode, opcodes.OP_PUSHDATA4, 'Unexpected opcode')
number = buffer.readUInt32LE(offset + 1)
size = 5
}
return {
opcode: opcode,
number: number,
size: size
}
}
function readUInt64LE(buffer, offset) {
var a = buffer.readUInt32LE(offset)
var b = buffer.readUInt32LE(offset + 4)
b *= 0x100000000
verifuint(b + a, 0x001fffffffffffff)
return b + a
}
function readVarInt(buffer, offset) {
var t = buffer.readUInt8(offset)
var number, size
// 8 bit
if (t < 253) {
number = t
size = 1
// 16 bit
} else if (t < 254) {
number = buffer.readUInt16LE(offset + 1)
size = 3
// 32 bit
} else if (t < 255) {
number = buffer.readUInt32LE(offset + 1)
size = 5
// 64 bit
} else {
number = readUInt64LE(buffer, offset + 1)
size = 9
}
return {
number: number,
size: size
}
}
function writePushDataInt(buffer, number, offset) {
var size = pushDataSize(number)
// ~6 bit
if (size === 1) {
buffer.writeUInt8(number, offset)
// 8 bit
} else if (size === 2) {
buffer.writeUInt8(opcodes.OP_PUSHDATA1, offset)
buffer.writeUInt8(number, offset + 1)
// 16 bit
} else if (size === 3) {
buffer.writeUInt8(opcodes.OP_PUSHDATA2, offset)
buffer.writeUInt16LE(number, offset + 1)
// 32 bit
} else {
buffer.writeUInt8(opcodes.OP_PUSHDATA4, offset)
buffer.writeUInt32LE(number, offset + 1)
}
return size
}
function writeUInt64LE(buffer, value, offset) {
verifuint(value, 0x001fffffffffffff)
buffer.writeInt32LE(value & -1, offset)
buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4)
}
function varIntSize(i) {
return i < 253 ? 1
: i < 0x10000 ? 3
: i < 0x100000000 ? 5
: 9
}
function writeVarInt(buffer, number, offset) {
var size = varIntSize(number)
// 8 bit
if (size === 1) {
buffer.writeUInt8(number, offset)
// 16 bit
} else if (size === 3) {
buffer.writeUInt8(253, offset)
buffer.writeUInt16LE(number, offset + 1)
// 32 bit
} else if (size === 5) {
buffer.writeUInt8(254, offset)
buffer.writeUInt32LE(number, offset + 1)
// 64 bit
} else {
buffer.writeUInt8(255, offset)
writeUInt64LE(buffer, number, offset + 1)
}
return size
}
function reverse(buffer) {
var buffer2 = new Buffer(buffer)
Array.prototype.reverse.call(buffer2)
return buffer2
}
module.exports = {
pushDataSize: pushDataSize,
readPushDataInt: readPushDataInt,
readUInt64LE: readUInt64LE,
readVarInt: readVarInt,
reverse: reverse,
varIntSize: varIntSize,
writePushDataInt: writePushDataInt,
writeUInt64LE: writeUInt64LE,
writeVarInt: writeVarInt
}
}).call(this,require("buffer").Buffer)
},{"./opcodes":37,"assert":44,"buffer":46}],29:[function(require,module,exports){
var crypto = require('crypto')
function hash160(buffer) {
return ripemd160(sha256(buffer))
}
function hash256(buffer) {
return sha256(sha256(buffer))
}
function ripemd160(buffer) {
return crypto.createHash('rmd160').update(buffer).digest()
}
function sha1(buffer) {
return crypto.createHash('sha1').update(buffer).digest()
}
function sha256(buffer) {
return crypto.createHash('sha256').update(buffer).digest()
}
// FIXME: Name not consistent with others
function HmacSHA256(buffer, secret) {
return crypto.createHmac('sha256', secret).update(buffer).digest()
}
function HmacSHA512(buffer, secret) {
return crypto.createHmac('sha512', secret).update(buffer).digest()
}
module.exports = {
ripemd160: ripemd160,
sha1: sha1,
sha256: sha256,
hash160: hash160,
hash256: hash256,
HmacSHA256: HmacSHA256,
HmacSHA512: HmacSHA512
}
},{"crypto":10}],30:[function(require,module,exports){
(function (Buffer){
var assert = require('assert')
var crypto = require('./crypto')
var enforceType = require('./types')
var BigInteger = require('bigi')
var ECSignature = require('./ecsignature')
// https://tools.ietf.org/html/rfc6979#section-3.2
function deterministicGenerateK(curve, hash, d) {
enforceType('Buffer', hash)
enforceType(BigInteger, d)
// sanity check
assert.equal(hash.length, 32, 'Hash must be 256 bit')
var x = d.toBuffer(32)
var k = new Buffer(32)
var v = new Buffer(32)
// Step B
v.fill(1)
// Step C
k.fill(0)
// Step D
k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0]), x, hash]), k)
// Step E
v = crypto.HmacSHA256(v, k)
// Step F
k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([1]), x, hash]), k)
// Step G
v = crypto.HmacSHA256(v, k)
// Step H1/H2a, ignored as tlen === qlen (256 bit)
// Step H2b
v = crypto.HmacSHA256(v, k)
var T = BigInteger.fromBuffer(v)
// Step H3, repeat until T is within the interval [1, n - 1]
while ((T.signum() <= 0) || (T.compareTo(curve.n) >= 0)) {
k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0])]), k)
v = crypto.HmacSHA256(v, k)
T = BigInteger.fromBuffer(v)
}
return T
}
function sign(curve, hash, d) {
var k = deterministicGenerateK(curve, hash, d)
var n = curve.n
var G = curve.G
var Q = G.multiply(k)
var e = BigInteger.fromBuffer(hash)
var r = Q.affineX.mod(n)
assert.notEqual(r.signum(), 0, 'Invalid R value')
var s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n)
assert.notEqual(s.signum(), 0, 'Invalid S value')
var N_OVER_TWO = n.shiftRight(1)
// enforce low S values, see bip62: 'low s values in signatures'
if (s.compareTo(N_OVER_TWO) > 0) {
s = n.subtract(s)
}
return new ECSignature(r, s)
}
function verifyRaw(curve, e, signature, Q) {
var n = curve.n
var G = curve.G
var r = signature.r
var s = signature.s
// 1.4.1 Enforce r and s are both integers in the interval [1, n − 1]
if (r.signum() <= 0 || r.compareTo(n) >= 0) return false
if (s.signum() <= 0 || s.compareTo(n) >= 0) return false
// c = s^-1 mod n
var c = s.modInverse(n)
// 1.4.4 Compute u1 = es^−1 mod n
// u2 = rs^−1 mod n
var u1 = e.multiply(c).mod(n)
var u2 = r.multiply(c).mod(n)
// 1.4.5 Compute R = (xR, yR) = u1G + u2Q
var R = G.multiplyTwo(u1, Q, u2)
var v = R.affineX.mod(n)
// 1.4.5 (cont.) Enforce R is not at infinity
if (curve.isInfinity(R)) return false
// 1.4.8 If v = r, output "valid", and if v != r, output "invalid"
return v.equals(r)
}
function verify(curve, hash, signature, Q) {
// 1.4.2 H = Hash(M), already done by the user
// 1.4.3 e = H
var e = BigInteger.fromBuffer(hash)
return verifyRaw(curve, e, signature, Q)
}
/**
* Recover a public key from a signature.
*
* See SEC 1: Elliptic Curve Cryptography, section 4.1.6, "Public
* Key Recovery Operation".
*
* http://www.secg.org/download/aid-780/sec1-v2.pdf
*/
function recoverPubKey(curve, e, signature, i) {
assert.strictEqual(i & 3, i, 'Recovery param is more than two bits')
var n = curve.n
var G = curve.G
var r = signature.r
var s = signature.s
assert(r.signum() > 0 && r.compareTo(n) < 0, 'Invalid r value')
assert(s.signum() > 0 && s.compareTo(n) < 0, 'Invalid s value')
// A set LSB signifies that the y-coordinate is odd
var isYOdd = i & 1
// The more significant bit specifies whether we should use the
// first or second candidate key.
var isSecondKey = i >> 1
// 1.1 Let x = r + jn
var x = isSecondKey ? r.add(n) : r
var R = curve.pointFromX(isYOdd, x)
// 1.4 Check that nR is at infinity
var nR = R.multiply(n)
assert(curve.isInfinity(nR), 'nR is not a valid curve point')
// Compute -e from e
var eNeg = e.negate().mod(n)
// 1.6.1 Compute Q = r^-1 (sR - eG)
// Q = r^-1 (sR + -eG)
var rInv = r.modInverse(n)
var Q = R.multiplyTwo(s, G, eNeg).multiply(rInv)
curve.validate(Q)
return Q
}
/**
* Calculate pubkey extraction parameter.
*
* When extracting a pubkey from a signature, we have to
* distinguish four different cases. Rather than putting this
* burden on the verifier, Bitcoin includes a 2-bit value with the
* signature.
*
* This function simply tries all four cases and returns the value
* that resulted in a successful pubkey recovery.
*/
function calcPubKeyRecoveryParam(curve, e, signature, Q) {
for (var i = 0; i < 4; i++) {
var Qprime = recoverPubKey(curve, e, signature, i)
// 1.6.2 Verify Q
if (Qprime.equals(Q)) {
return i
}
}
throw new Error('Unable to find valid recovery factor')
}
module.exports = {
calcPubKeyRecoveryParam: calcPubKeyRecoveryParam,
deterministicGenerateK: deterministicGenerateK,
recoverPubKey: recoverPubKey,
sign: sign,
verify: verify,
verifyRaw: verifyRaw
}
}).call(this,require("buffer").Buffer)
},{"./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')
var ecdsa = require('./ecdsa')
var enforceType = require('./types')
var networks = require('./networks')
var BigInteger = require('bigi')
var ECPubKey = require('./ecpubkey')
var ecurve = require('ecurve')
var secp256k1 = ecurve.getCurveByName('secp256k1')
function ECKey(d, compressed) {
assert(d.signum() > 0, 'Private key must be greater than 0')
assert(d.compareTo(ECKey.curve.n) < 0, 'Private key must be less than the curve order')
var Q = ECKey.curve.G.multiply(d)
this.d = d
this.pub = new ECPubKey(Q, compressed)
}
// Constants
ECKey.curve = secp256k1
// Static constructors
ECKey.fromWIF = function(string) {
var payload = base58check.decode(string)
var compressed = false
// Ignore the version byte
payload = payload.slice(1)
if (payload.length === 33) {
assert.strictEqual(payload[32], 0x01, 'Invalid compression flag')
// Truncate the compression flag
payload = payload.slice(0, -1)
compressed = true
}
assert.equal(payload.length, 32, 'Invalid WIF payload length')
var d = BigInteger.fromBuffer(payload)
return new ECKey(d, compressed)
}
ECKey.makeRandom = function(compressed, rng) {
rng = rng || crypto.randomBytes
var buffer = rng(32)
enforceType('Buffer', buffer)
assert.equal(buffer.length, 32, 'Expected 256-bit Buffer from RNG')
var d = BigInteger.fromBuffer(buffer)
d = d.mod(ECKey.curve.n)
return new ECKey(d, compressed)
}
// Export functions
ECKey.prototype.toWIF = function(network) {
network = network || networks.bitcoin
var bufferLen = this.pub.compressed ? 34 : 33
var buffer = new Buffer(bufferLen)
buffer.writeUInt8(network.wif, 0)
this.d.toBuffer(32).copy(buffer, 1)
if (this.pub.compressed) {
buffer.writeUInt8(0x01, 33)
}
return base58check.encode(buffer)
}
// Operations
ECKey.prototype.sign = function(hash) {
return ecdsa.sign(ECKey.curve, hash, this.d)
}
module.exports = ECKey
}).call(this,require("buffer").Buffer)
},{"./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')
var networks = require('./networks')
var Address = require('./address')
var ecurve = require('ecurve')
var secp256k1 = ecurve.getCurveByName('secp256k1')
function ECPubKey(Q, compressed) {
if (compressed === undefined) compressed = true
enforceType(ecurve.Point, Q)
enforceType('Boolean', compressed)
this.compressed = compressed
this.Q = Q
}
// Constants
ECPubKey.curve = secp256k1
// Static constructors
ECPubKey.fromBuffer = function(buffer) {
var Q = ecurve.Point.decodeFrom(ECPubKey.curve, buffer)
return new ECPubKey(Q, Q.compressed)
}
ECPubKey.fromHex = function(hex) {
return ECPubKey.fromBuffer(new Buffer(hex, 'hex'))
}
// Operations
ECPubKey.prototype.getAddress = function(network) {
network = network || networks.bitcoin
return new Address(crypto.hash160(this.toBuffer()), network.pubKeyHash)
}
ECPubKey.prototype.verify = function(hash, signature) {
return ecdsa.verify(ECPubKey.curve, hash, signature, this.Q)
}
// Export functions
ECPubKey.prototype.toBuffer = function() {
return this.Q.getEncoded(this.compressed)
}
ECPubKey.prototype.toHex = function() {
return this.toBuffer().toString('hex')
}
module.exports = ECPubKey
}).call(this,require("buffer").Buffer)
},{"./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')
var BigInteger = require('bigi')
function ECSignature(r, s) {
enforceType(BigInteger, r)
enforceType(BigInteger, s)
this.r = r
this.s = s
}
// Import operations
ECSignature.parseCompact = function(buffer) {
assert.equal(buffer.length, 65, 'Invalid signature length')
var i = buffer.readUInt8(0) - 27
// At most 3 bits
assert.equal(i, i & 7, 'Invalid signature parameter')
var compressed = !!(i & 4)
// Recovery param only
i = i & 3
var r = BigInteger.fromBuffer(buffer.slice(1, 33))
var s = BigInteger.fromBuffer(buffer.slice(33))
return {
compressed: compressed,
i: i,
signature: new ECSignature(r, s)
}
}
ECSignature.fromDER = function(buffer) {
assert.equal(buffer.readUInt8(0), 0x30, 'Not a DER sequence')
assert.equal(buffer.readUInt8(1), buffer.length - 2, 'Invalid sequence length')
assert.equal(buffer.readUInt8(2), 0x02, 'Expected a DER integer')
var rLen = buffer.readUInt8(3)
assert(rLen > 0, 'R length is zero')
var offset = 4 + rLen
assert.equal(buffer.readUInt8(offset), 0x02, 'Expected a DER integer (2)')
var sLen = buffer.readUInt8(offset + 1)
assert(sLen > 0, 'S length is zero')
var rB = buffer.slice(4, offset)
var sB = buffer.slice(offset + 2)
offset += 2 + sLen
if (rLen > 1 && rB.readUInt8(0) === 0x00) {
assert(rB.readUInt8(1) & 0x80, 'R value excessively padded')
}
if (sLen > 1 && sB.readUInt8(0) === 0x00) {
assert(sB.readUInt8(1) & 0x80, 'S value excessively padded')
}
assert.equal(offset, buffer.length, 'Invalid DER encoding')
var r = BigInteger.fromDERInteger(rB)
var s = BigInteger.fromDERInteger(sB)
assert(r.signum() >= 0, 'R value is negative')
assert(s.signum() >= 0, 'S value is negative')
return new ECSignature(r, s)
}
// FIXME: 0x00, 0x04, 0x80 are SIGHASH_* boundary constants, importing Transaction causes a circular dependency
ECSignature.parseScriptSignature = function(buffer) {
var hashType = buffer.readUInt8(buffer.length - 1)
var hashTypeMod = hashType & ~0x80
assert(hashTypeMod > 0x00 && hashTypeMod < 0x04, 'Invalid hashType')
return {
signature: ECSignature.fromDER(buffer.slice(0, -1)),
hashType: hashType
}
}
// Export operations
ECSignature.prototype.toCompact = function(i, compressed) {
if (compressed) i += 4
i += 27
var buffer = new Buffer(65)
buffer.writeUInt8(i, 0)
this.r.toBuffer(32).copy(buffer, 1)
this.s.toBuffer(32).copy(buffer, 33)
return buffer
}
ECSignature.prototype.toDER = function() {
var rBa = this.r.toDERInteger()
var sBa = this.s.toDERInteger()
var sequence = []
// INTEGER
sequence.push(0x02, rBa.length)
sequence = sequence.concat(rBa)
// INTEGER
sequence.push(0x02, sBa.length)
sequence = sequence.concat(sBa)
// SEQUENCE
sequence.unshift(0x30, sequence.length)
return new Buffer(sequence)
}
ECSignature.prototype.toScriptSignature = function(hashType) {
var hashTypeBuffer = new Buffer(1)
hashTypeBuffer.writeUInt8(hashType, 0)
return Buffer.concat([this.toDER(), hashTypeBuffer])
}
module.exports = ECSignature
}).call(this,require("buffer").Buffer)
},{"./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')
var enforceType = require('./types')
var networks = require('./networks')
var BigInteger = require('bigi')
var ECKey = require('./eckey')
var ECPubKey = require('./ecpubkey')
var ecurve = require('ecurve')
var curve = ecurve.getCurveByName('secp256k1')
function findBIP32ParamsByVersion(version) {
for (var name in networks) {
var network = networks[name]
for (var type in network.bip32) {
if (version != network.bip32[type]) continue
return {
isPrivate: (type === 'private'),
network: network
}
}
}
assert(false, 'Could not find version ' + version.toString(16))
}
function HDNode(K, chainCode, network) {
network = network || networks.bitcoin
enforceType('Buffer', chainCode)
assert.equal(chainCode.length, 32, 'Expected chainCode length of 32, got ' + chainCode.length)
assert(network.bip32, 'Unknown BIP32 constants for network')
this.chainCode = chainCode
this.depth = 0
this.index = 0
this.network = network
if (K instanceof BigInteger) {
this.privKey = new ECKey(K, true)
this.pubKey = this.privKey.pub
} else {
this.pubKey = new ECPubKey(K, true)
}
}
HDNode.MASTER_SECRET = new Buffer('Bitcoin seed')
HDNode.HIGHEST_BIT = 0x80000000
HDNode.LENGTH = 78
HDNode.fromSeedBuffer = function(seed, network) {
enforceType('Buffer', seed)
assert(seed.length >= 16, 'Seed should be at least 128 bits')
assert(seed.length <= 64, 'Seed should be at most 512 bits')
var I = crypto.HmacSHA512(seed, HDNode.MASTER_SECRET)
var IL = I.slice(0, 32)
var IR = I.slice(32)
// In case IL is 0 or >= n, the master key is invalid
// This is handled by `new ECKey` in the HDNode constructor
var pIL = BigInteger.fromBuffer(IL)
return new HDNode(pIL, IR, network)
}
HDNode.fromSeedHex = function(hex, network) {
return HDNode.fromSeedBuffer(new Buffer(hex, 'hex'), network)
}
HDNode.fromBase58 = function(string) {
return HDNode.fromBuffer(base58check.decode(string), true)
}
// FIXME: remove in 2.x.y
HDNode.fromBuffer = function(buffer, __ignoreDeprecation) {
if (!__ignoreDeprecation) {
console.warn('HDNode.fromBuffer() is deprecated for removal in 2.x.y, use fromBase58 instead')
}
assert.strictEqual(buffer.length, HDNode.LENGTH, 'Invalid buffer length')
// 4 byte: version bytes
var version = buffer.readUInt32BE(0)
var params = findBIP32ParamsByVersion(version)
// 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ...
var depth = buffer.readUInt8(4)
// 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
var parentFingerprint = buffer.readUInt32BE(5)
if (depth === 0) {
assert.strictEqual(parentFingerprint, 0x00000000, 'Invalid parent fingerprint')
}
// 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
// This is encoded in MSB order. (0x00000000 if master key)
var index = buffer.readUInt32BE(9)
assert(depth > 0 || index === 0, 'Invalid index')
// 32 bytes: the chain code
var chainCode = buffer.slice(13, 45)
var data, hd
// 33 bytes: private key data (0x00 + k)
if (params.isPrivate) {
assert.strictEqual(buffer.readUInt8(45), 0x00, 'Invalid private key')
data = buffer.slice(46, 78)
var d = BigInteger.fromBuffer(data)
hd = new HDNode(d, chainCode, params.network)
// 33 bytes: public key data (0x02 + X or 0x03 + X)
} else {
data = buffer.slice(45, 78)
var Q = ecurve.Point.decodeFrom(curve, data)
assert.equal(Q.compressed, true, 'Invalid public key')
// Verify that the X coordinate in the public point corresponds to a point on the curve.
// If not, the extended public key is invalid.
curve.validate(Q)
hd = new HDNode(Q, chainCode, params.network)
}
hd.depth = depth
hd.index = index
hd.parentFingerprint = parentFingerprint
return hd
}
// FIXME: remove in 2.x.y
HDNode.fromHex = function(hex) {
return HDNode.fromBuffer(new Buffer(hex, 'hex'))
}
HDNode.prototype.getIdentifier = function() {
return crypto.hash160(this.pubKey.toBuffer())
}
HDNode.prototype.getFingerprint = function() {
return this.getIdentifier().slice(0, 4)
}
HDNode.prototype.getAddress = function() {
return this.pubKey.getAddress(this.network)
}
HDNode.prototype.neutered = function() {
var neutered = new HDNode(this.pubKey.Q, this.chainCode, this.network)
neutered.depth = this.depth
neutered.index = this.index
neutered.parentFingerprint = this.parentFingerprint
return neutered
}
HDNode.prototype.toBase58 = function(isPrivate) {
return base58check.encode(this.toBuffer(isPrivate, true))
}
// FIXME: remove in 2.x.y
HDNode.prototype.toBuffer = function(isPrivate, __ignoreDeprecation) {
if (isPrivate === undefined) {
isPrivate = !!this.privKey
// FIXME: remove in 2.x.y
} else {
console.warn('isPrivate flag is deprecated, please use the .neutered() method instead')
}
if (!__ignoreDeprecation) {
console.warn('HDNode.toBuffer() is deprecated for removal in 2.x.y, use toBase58 instead')
}
// Version
var version = isPrivate ? this.network.bip32.private : this.network.bip32.public
var buffer = new Buffer(HDNode.LENGTH)
// 4 bytes: version bytes
buffer.writeUInt32BE(version, 0)
// Depth
// 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ....
buffer.writeUInt8(this.depth, 4)
// 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
var fingerprint = (this.depth === 0) ? 0x00000000 : this.parentFingerprint
buffer.writeUInt32BE(fingerprint, 5)
// 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
// This is encoded in Big endian. (0x00000000 if master key)
buffer.writeUInt32BE(this.index, 9)
// 32 bytes: the chain code
this.chainCode.copy(buffer, 13)
// 33 bytes: the public key or private key data
if (isPrivate) {
// FIXME: remove in 2.x.y
assert(this.privKey, 'Missing private key')
// 0x00 + k for private keys
buffer.writeUInt8(0, 45)
this.privKey.d.toBuffer(32).copy(buffer, 46)
} else {
// X9.62 encoding for public keys
this.pubKey.toBuffer().copy(buffer, 45)
}
return buffer
}
// FIXME: remove in 2.x.y
HDNode.prototype.toHex = function(isPrivate) {
return this.toBuffer(isPrivate).toString('hex')
}
// https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions
HDNode.prototype.derive = function(index) {
var isHardened = index >= HDNode.HIGHEST_BIT
var indexBuffer = new Buffer(4)
indexBuffer.writeUInt32BE(index, 0)
var data
// Hardened child
if (isHardened) {
assert(this.privKey, 'Could not derive hardened child key')
// data = 0x00 || ser256(kpar) || ser32(index)
data = Buffer.concat([
this.privKey.d.toBuffer(33),
indexBuffer
])
// Normal child
} else {
// data = serP(point(kpar)) || ser32(index)
// = serP(Kpar) || ser32(index)
data = Buffer.concat([
this.pubKey.toBuffer(),
indexBuffer
])
}
var I = crypto.HmacSHA512(data, this.chainCode)
var IL = I.slice(0, 32)
var IR = I.slice(32)
var pIL = BigInteger.fromBuffer(IL)
// In case parse256(IL) >= n, proceed with the next value for i
if (pIL.compareTo(curve.n) >= 0) {
return this.derive(index + 1)
}
// Private parent key -> private child key
var hd
if (this.privKey) {
// ki = parse256(IL) + kpar (mod n)
var ki = pIL.add(this.privKey.d).mod(curve.n)
// In case ki == 0, proceed with the next value for i
if (ki.signum() === 0) {
return this.derive(index + 1)
}
hd = new HDNode(ki, IR, this.network)
// Public parent key -> public child key
} else {
// Ki = point(parse256(IL)) + Kpar
// = G*IL + Kpar
var Ki = curve.G.multiply(pIL).add(this.pubKey.Q)
// In case Ki is the point at infinity, proceed with the next value for i
if (curve.isInfinity(Ki)) {
return this.derive(index + 1)
}
hd = new HDNode(Ki, IR, this.network)
}
hd.depth = this.depth + 1
hd.index = index
hd.parentFingerprint = this.getFingerprint().readUInt32BE(0)
return hd
}
HDNode.prototype.deriveHardened = function(index) {
// Only derives hardened private keys by default
return this.derive(index + HDNode.HIGHEST_BIT)
}
HDNode.prototype.toString = HDNode.prototype.toBase58
module.exports = HDNode
}).call(this,require("buffer").Buffer)
},{"./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')
var networks = require('./networks')
var BigInteger = require('bigi')
var ECPubKey = require('./ecpubkey')
var ECSignature = require('./ecsignature')
var ecurve = require('ecurve')
var ecparams = ecurve.getCurveByName('secp256k1')
function magicHash(message, network) {
var magicPrefix = new Buffer(network.magicPrefix)
var messageBuffer = new Buffer(message)
var lengthBuffer = new Buffer(bufferutils.varIntSize(messageBuffer.length))
bufferutils.writeVarInt(lengthBuffer, messageBuffer.length, 0)
var buffer = Buffer.concat([magicPrefix, lengthBuffer, messageBuffer])
return crypto.hash256(buffer)
}
function sign(privKey, message, network) {
network = network || networks.bitcoin
var hash = magicHash(message, network)
var signature = privKey.sign(hash)
var e = BigInteger.fromBuffer(hash)
var i = ecdsa.calcPubKeyRecoveryParam(ecparams, e, signature, privKey.pub.Q)
return signature.toCompact(i, privKey.pub.compressed)
}
// TODO: network could be implied from address
function verify(address, signature, message, network) {
if (!Buffer.isBuffer(signature)) {
signature = new Buffer(signature, 'base64')
}
network = network || networks.bitcoin
var hash = magicHash(message, network)
var parsed = ECSignature.parseCompact(signature)
var e = BigInteger.fromBuffer(hash)
var Q = ecdsa.recoverPubKey(ecparams, e, parsed.signature, parsed.i)
var pubKey = new ECPubKey(Q, parsed.compressed)
return pubKey.getAddress(network).toString() === address.toString()
}
module.exports = {
magicHash: magicHash,
sign: sign,
verify: verify
}
}).call(this,require("buffer").Buffer)
},{"./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 = {
bitcoin: {
magicPrefix: '\x18Bitcoin Signed Message:\n',
bip32: {
public: 0x0488b21e,
private: 0x0488ade4
},
pubKeyHash: 0x00,
scriptHash: 0x05,
wif: 0x80,
dustThreshold: 546, // https://github.com/bitcoin/bitcoin/blob/v0.9.2/src/core.h#L151-L162
feePerKb: 10000, // https://github.com/bitcoin/bitcoin/blob/v0.9.2/src/main.cpp#L53
estimateFee: estimateFee('bitcoin')
},
dogecoin: {
magicPrefix: '\x19Dogecoin Signed Message:\n',
bip32: {
public: 0x02facafd,
private: 0x02fac398
},
pubKeyHash: 0x1e,
scriptHash: 0x16,
wif: 0x9e,
dustThreshold: 0, // https://github.com/dogecoin/dogecoin/blob/v1.7.1/src/core.h#L155-L160
dustSoftThreshold: 100000000, // https://github.com/dogecoin/dogecoin/blob/v1.7.1/src/main.h#L62
feePerKb: 100000000, // https://github.com/dogecoin/dogecoin/blob/v1.7.1/src/main.cpp#L58
estimateFee: estimateFee('dogecoin')
},
litecoin: {
magicPrefix: '\x19Litecoin Signed Message:\n',
bip32: {
public: 0x019da462,
private: 0x019d9cfe
},
pubKeyHash: 0x30,
scriptHash: 0x05,
wif: 0xb0,
dustThreshold: 0, // https://github.com/litecoin-project/litecoin/blob/v0.8.7.2/src/main.cpp#L360-L365
dustSoftThreshold: 100000, // https://github.com/litecoin-project/litecoin/blob/v0.8.7.2/src/main.h#L53
feePerKb: 100000, // https://github.com/litecoin-project/litecoin/blob/v0.8.7.2/src/main.cpp#L56
estimateFee: estimateFee('litecoin')
},
testnet: {
magicPrefix: '\x18Bitcoin Signed Message:\n',
bip32: {
public: 0x043587cf,
private: 0x04358394
},
pubKeyHash: 0x6f,
scriptHash: 0xc4,
wif: 0xef,
dustThreshold: 546,
feePerKb: 10000,
estimateFee: estimateFee('testnet')
},
viacoin: {
magicPrefix: '\x18Viacoin Signed Message:\n',
bip32: {
public: 0x0488b21e,
private: 0x0488ade4
},
pubKeyHash: 0x47,
scriptHash: 0x21,
wif: 0xc7,
dustThreshold: 560,
dustSoftThreshold: 100000,
feePerKb: 100000, //
estimateFee: estimateFee('viacoin')
},
viacointestnet: {
magicPrefix: '\x18Viacoin Signed Message:\n',
bip32: {
public: 0x043587cf,
private: 0x04358394
},
pubKeyHash: 0x7f,
scriptHash: 0xc4,
wif: 0xff,
dustThreshold: 560,
dustSoftThreshold: 100000,
feePerKb: 100000,
estimateFee: estimateFee('viacointestnet')
},
zetacoin: {
magicPrefix: '\x18Zetacoin Signed Message:\n',
bip32: {
public: 0x0488b21e,
private: 0x0488ade4
},
pubKeyHash: 0x50,
scriptHash: 0x09,
wif: 0xe0,
dustThreshold: 546, // https://github.com/zetacoin/zetacoin/blob/master/src/core.h#L159
feePerKb: 10000, // https://github.com/zetacoin/zetacoin/blob/master/src/main.cpp#L54
estimateFee: estimateFee('zetacoin')
}
}
function estimateFee(type) {
return function(tx) {
var network = networks[type]
var baseFee = network.feePerKb
var byteSize = tx.toBuffer().length
var fee = baseFee * Math.ceil(byteSize / 1000)
if (network.dustSoftThreshold == undefined) return fee
tx.outs.forEach(function(e){
if (e.value < network.dustSoftThreshold) {
fee += baseFee
}
})
return fee
}
}
module.exports = networks
},{}],37:[function(require,module,exports){
module.exports = {
// push value
OP_FALSE : 0,
OP_0 : 0,
OP_PUSHDATA1 : 76,
OP_PUSHDATA2 : 77,
OP_PUSHDATA4 : 78,
OP_1NEGATE : 79,
OP_RESERVED : 80,
OP_1 : 81,
OP_TRUE : 81,
OP_2 : 82,
OP_3 : 83,
OP_4 : 84,
OP_5 : 85,
OP_6 : 86,
OP_7 : 87,
OP_8 : 88,
OP_9 : 89,
OP_10 : 90,
OP_11 : 91,
OP_12 : 92,
OP_13 : 93,
OP_14 : 94,
OP_15 : 95,
OP_16 : 96,
// control
OP_NOP : 97,
OP_VER : 98,
OP_IF : 99,
OP_NOTIF : 100,
OP_VERIF : 101,
OP_VERNOTIF : 102,
OP_ELSE : 103,
OP_ENDIF : 104,
OP_VERIFY : 105,
OP_RETURN : 106,
// stack ops
OP_TOALTSTACK : 107,
OP_FROMALTSTACK : 108,
OP_2DROP : 109,
OP_2DUP : 110,
OP_3DUP : 111,
OP_2OVER : 112,
OP_2ROT : 113,
OP_2SWAP : 114,
OP_IFDUP : 115,
OP_DEPTH : 116,
OP_DROP : 117,
OP_DUP : 118,
OP_NIP : 119,
OP_OVER : 120,
OP_PICK : 121,
OP_ROLL : 122,
OP_ROT : 123,
OP_SWAP : 124,
OP_TUCK : 125,
// splice ops
OP_CAT : 126,
OP_SUBSTR : 127,
OP_LEFT : 128,
OP_RIGHT : 129,
OP_SIZE : 130,
// bit logic
OP_INVERT : 131,
OP_AND : 132,
OP_OR : 133,
OP_XOR : 134,
OP_EQUAL : 135,
OP_EQUALVERIFY : 136,
OP_RESERVED1 : 137,
OP_RESERVED2 : 138,
// numeric
OP_1ADD : 139,
OP_1SUB : 140,
OP_2MUL : 141,
OP_2DIV : 142,
OP_NEGATE : 143,
OP_ABS : 144,
OP_NOT : 145,
OP_0NOTEQUAL : 146,
OP_ADD : 147,
OP_SUB : 148,
OP_MUL : 149,
OP_DIV : 150,
OP_MOD : 151,
OP_LSHIFT : 152,
OP_RSHIFT : 153,
OP_BOOLAND : 154,
OP_BOOLOR : 155,
OP_NUMEQUAL : 156,
OP_NUMEQUALVERIFY : 157,
OP_NUMNOTEQUAL : 158,
OP_LESSTHAN : 159,
OP_GREATERTHAN : 160,
OP_LESSTHANOREQUAL : 161,
OP_GREATERTHANOREQUAL : 162,
OP_MIN : 163,
OP_MAX : 164,
OP_WITHIN : 165,
// crypto
OP_RIPEMD160 : 166,
OP_SHA1 : 167,
OP_SHA256 : 168,
OP_HASH160 : 169,
OP_HASH256 : 170,
OP_CODESEPARATOR : 171,
OP_CHECKSIG : 172,
OP_CHECKSIGVERIFY : 173,
OP_CHECKMULTISIG : 174,
OP_CHECKMULTISIGVERIFY : 175,
// expansion
OP_NOP1 : 176,
OP_NOP2 : 177,
OP_NOP3 : 178,
OP_NOP4 : 179,
OP_NOP5 : 180,
OP_NOP6 : 181,
OP_NOP7 : 182,
OP_NOP8 : 183,
OP_NOP9 : 184,
OP_NOP10 : 185,
// template matching params
OP_PUBKEYHASH : 253,
OP_PUBKEY : 254,
OP_INVALIDOPCODE : 255
}
},{}],38:[function(require,module,exports){
(function (Buffer){
var assert = require('assert')
var bufferutils = require('./bufferutils')
var crypto = require('./crypto')
var enforceType = require('./types')
var opcodes = require('./opcodes')
function Script(buffer, chunks) {
enforceType('Buffer', buffer)
enforceType('Array', chunks)
this.buffer = buffer
this.chunks = chunks
}
// Import operations
Script.fromASM = function(asm) {
var strChunks = asm.split(' ')
var chunks = strChunks.map(function(strChunk) {
if (strChunk in opcodes) {
return opcodes[strChunk]
} else {
return new Buffer(strChunk, 'hex')
}
})
return Script.fromChunks(chunks)
}
Script.fromBuffer = function(buffer) {
var chunks = []
var i = 0
while (i < buffer.length) {
var opcode = buffer.readUInt8(i)
if ((opcode > opcodes.OP_0) && (opcode <= opcodes.OP_PUSHDATA4)) {
var d = bufferutils.readPushDataInt(buffer, i)
i += d.size
var data = buffer.slice(i, i + d.number)
i += d.number
chunks.push(data)
} else {
chunks.push(opcode)
i += 1
}
}
return new Script(buffer, chunks)
}
Script.fromChunks = function(chunks) {
enforceType('Array', chunks)
var bufferSize = chunks.reduce(function(accum, chunk) {
if (Buffer.isBuffer(chunk)) {
return accum + bufferutils.pushDataSize(chunk.length) + chunk.length
}
return accum + 1
}, 0.0)
var buffer = new Buffer(bufferSize)
var offset = 0
chunks.forEach(function(chunk) {
if (Buffer.isBuffer(chunk)) {
offset += bufferutils.writePushDataInt(buffer, chunk.length, offset)
chunk.copy(buffer, offset)
offset += chunk.length
} else {
buffer.writeUInt8(chunk, offset)
offset += 1
}
})
assert.equal(offset, buffer.length, 'Could not decode chunks')
return new Script(buffer, chunks)
}
Script.fromHex = function(hex) {
return Script.fromBuffer(new Buffer(hex, 'hex'))
}
// Constants
Script.EMPTY = Script.fromChunks([])
// Operations
Script.prototype.getHash = function() {
return crypto.hash160(this.buffer)
}
// FIXME: doesn't work for data chunks, maybe time to use buffertools.compare...
Script.prototype.without = function(needle) {
return Script.fromChunks(this.chunks.filter(function(op) {
return op !== needle
}))
}
// Export operations
var reverseOps = []
for (var op in opcodes) {
var code = opcodes[op]
reverseOps[code] = op
}
Script.prototype.toASM = function() {
return this.chunks.map(function(chunk) {
if (Buffer.isBuffer(chunk)) {
return chunk.toString('hex')
} else {
return reverseOps[chunk]
}
}).join(' ')
}
Script.prototype.toBuffer = function() {
return this.buffer
}
Script.prototype.toHex = function() {
return this.toBuffer().toString('hex')
}
module.exports = Script
}).call(this,require("buffer").Buffer)
},{"./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')
var ecurve = require('ecurve')
var curve = ecurve.getCurveByName('secp256k1')
var ECSignature = require('./ecsignature')
var Script = require('./script')
function isCanonicalPubKey(buffer) {
if (!Buffer.isBuffer(buffer)) return false
try {
ecurve.Point.decodeFrom(curve, buffer)
} catch (e) {
if (!(e.message.match(/Invalid sequence (length|tag)/))) throw e
return false
}
return true
}
function isCanonicalSignature(buffer) {
if (!Buffer.isBuffer(buffer)) return false
try {
ECSignature.parseScriptSignature(buffer)
} catch(e) {
if (!(e.message.match(/Not a DER sequence|Invalid sequence length|Expected a DER integer|R length is zero|S length is zero|R value excessively padded|S value excessively padded|R value is negative|S value is negative|Invalid hashType/))) throw e
return false
}
return true
}
function isPubKeyHashInput(script) {
return script.chunks.length === 2 &&
isCanonicalSignature(script.chunks[0]) &&
isCanonicalPubKey(script.chunks[1])
}
function isPubKeyHashOutput(script) {
return script.chunks.length === 5 &&
script.chunks[0] === ops.OP_DUP &&
script.chunks[1] === ops.OP_HASH160 &&
Buffer.isBuffer(script.chunks[2]) &&
script.chunks[2].length === 20 &&
script.chunks[3] === ops.OP_EQUALVERIFY &&
script.chunks[4] === ops.OP_CHECKSIG
}
function isPubKeyInput(script) {
return script.chunks.length === 1 &&
isCanonicalSignature(script.chunks[0])
}
function isPubKeyOutput(script) {
return script.chunks.length === 2 &&
isCanonicalPubKey(script.chunks[0]) &&
script.chunks[1] === ops.OP_CHECKSIG
}
function isScriptHashInput(script) {
if (script.chunks.length < 2) return false
var lastChunk = script.chunks[script.chunks.length - 1]
if (!Buffer.isBuffer(lastChunk)) return false
var scriptSig = Script.fromChunks(script.chunks.slice(0, -1))
var scriptPubKey = Script.fromBuffer(lastChunk)
return classifyInput(scriptSig) === classifyOutput(scriptPubKey)
}
function isScriptHashOutput(script) {
return script.chunks.length === 3 &&
script.chunks[0] === ops.OP_HASH160 &&
Buffer.isBuffer(script.chunks[1]) &&
script.chunks[1].length === 20 &&
script.chunks[2] === ops.OP_EQUAL
}
function isMultisigInput(script) {
return script.chunks[0] === ops.OP_0 &&
script.chunks.slice(1).every(isCanonicalSignature)
}
function isMultisigOutput(script) {
if (script.chunks.length < 4) return false
if (script.chunks[script.chunks.length - 1] !== ops.OP_CHECKMULTISIG) return false
var mOp = script.chunks[0]
if (mOp === ops.OP_0) return false
if (mOp < ops.OP_1) return false
if (mOp > ops.OP_16) return false
var nOp = script.chunks[script.chunks.length - 2]
if (nOp === ops.OP_0) return false
if (nOp < ops.OP_1) return false
if (nOp > ops.OP_16) return false
var m = mOp - (ops.OP_1 - 1)
var n = nOp - (ops.OP_1 - 1)
if (n < m) return false
var pubKeys = script.chunks.slice(1, -2)
if (n < pubKeys.length) return false
return pubKeys.every(isCanonicalPubKey)
}
function isNulldataOutput(script) {
return script.chunks[0] === ops.OP_RETURN
}
function classifyOutput(script) {
enforceType(Script, script)
if (isPubKeyHashOutput(script)) {
return 'pubkeyhash'
} else if (isScriptHashOutput(script)) {
return 'scripthash'
} else if (isMultisigOutput(script)) {
return 'multisig'
} else if (isPubKeyOutput(script)) {
return 'pubkey'
} else if (isNulldataOutput(script)) {
return 'nulldata'
}
return 'nonstandard'
}
function classifyInput(script) {
enforceType(Script, script)
if (isPubKeyHashInput(script)) {
return 'pubkeyhash'
} else if (isScriptHashInput(script)) {
return 'scripthash'
} else if (isMultisigInput(script)) {
return 'multisig'
} else if (isPubKeyInput(script)) {
return 'pubkey'
}
return 'nonstandard'
}
// Standard Script Templates
// {pubKey} OP_CHECKSIG
function pubKeyOutput(pubKey) {
return Script.fromChunks([
pubKey.toBuffer(),
ops.OP_CHECKSIG
])
}
// OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG
function pubKeyHashOutput(hash) {
enforceType('Buffer', hash)
return Script.fromChunks([
ops.OP_DUP,
ops.OP_HASH160,
hash,
ops.OP_EQUALVERIFY,
ops.OP_CHECKSIG
])
}
// OP_HASH160 {scriptHash} OP_EQUAL
function scriptHashOutput(hash) {
enforceType('Buffer', hash)
return Script.fromChunks([
ops.OP_HASH160,
hash,
ops.OP_EQUAL
])
}
// m [pubKeys ...] n OP_CHECKMULTISIG
function multisigOutput(m, pubKeys) {
enforceType('Array', pubKeys)
assert(pubKeys.length >= m, 'Not enough pubKeys provided')
var pubKeyBuffers = pubKeys.map(function(pubKey) {
return pubKey.toBuffer()
})
var n = pubKeys.length
return Script.fromChunks([].concat(
(ops.OP_1 - 1) + m,
pubKeyBuffers,
(ops.OP_1 - 1) + n,
ops.OP_CHECKMULTISIG
))
}
// {signature}
function pubKeyInput(signature) {
enforceType('Buffer', signature)
return Script.fromChunks([signature])
}
// {signature} {pubKey}
function pubKeyHashInput(signature, pubKey) {
enforceType('Buffer', signature)
return Script.fromChunks([signature, pubKey.toBuffer()])
}
// <scriptSig> {serialized scriptPubKey script}
function scriptHashInput(scriptSig, scriptPubKey) {
return Script.fromChunks([].concat(
scriptSig.chunks,
scriptPubKey.toBuffer()
))
}
// OP_0 [signatures ...]
function multisigInput(signatures, scriptPubKey) {
if (scriptPubKey) {
assert(isMultisigOutput(scriptPubKey))
var mOp = scriptPubKey.chunks[0]
var nOp = scriptPubKey.chunks[scriptPubKey.chunks.length - 2]
var m = mOp - (ops.OP_1 - 1)
var n = nOp - (ops.OP_1 - 1)
assert(signatures.length >= m, 'Not enough signatures provided')
assert(signatures.length <= n, 'Too many signatures provided')
}
return Script.fromChunks([].concat(ops.OP_0, signatures))
}
module.exports = {
classifyInput: classifyInput,
classifyOutput: classifyOutput,
multisigInput: multisigInput,
multisigOutput: multisigOutput,
pubKeyHashInput: pubKeyHashInput,
pubKeyHashOutput: pubKeyHashOutput,
pubKeyInput: pubKeyInput,
pubKeyOutput: pubKeyOutput,
scriptHashInput: scriptHashInput,
scriptHashOutput: scriptHashOutput
}
}).call(this,require("buffer").Buffer)
},{"./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')
var enforceType = require('./types')
var opcodes = require('./opcodes')
var scripts = require('./scripts')
var Address = require('./address')
var ECSignature = require('./ecsignature')
var Script = require('./script')
function Transaction() {
this.version = 1
this.locktime = 0
this.ins = []
this.outs = []
}
Transaction.DEFAULT_SEQUENCE = 0xffffffff
Transaction.SIGHASH_ALL = 0x01
Transaction.SIGHASH_NONE = 0x02
Transaction.SIGHASH_SINGLE = 0x03
Transaction.SIGHASH_ANYONECANPAY = 0x80
/**
* Create a new txin.
*
* Can be called with any of:
*
* - A transaction and an index
* - A transaction hash and an index
*
* Note that this method does not sign the created input.
*/
Transaction.prototype.addInput = function(hash, index, sequence) {
if (sequence === undefined) sequence = Transaction.DEFAULT_SEQUENCE
if (typeof hash === 'string') {
// TxId hex is big-endian, we need little-endian
hash = bufferutils.reverse(new Buffer(hash, 'hex'))
} else if (hash instanceof Transaction) {
hash = hash.getHash()
}
enforceType('Buffer', hash)
enforceType('Number', index)
enforceType('Number', sequence)
assert.equal(hash.length, 32, 'Expected hash length of 32, got ' + hash.length)
// Add the input and return the input's index
return (this.ins.push({
hash: hash,
index: index,
script: Script.EMPTY,
sequence: sequence
}) - 1)
}
/**
* Create a new txout.
*
* Can be called with:
*
* - A base58 address string and a value
* - An Address object and a value
* - A scriptPubKey Script and a value
*/
Transaction.prototype.addOutput = function(scriptPubKey, value) {
// Attempt to get a valid address if it's a base58 address string
if (typeof scriptPubKey === 'string') {
scriptPubKey = Address.fromBase58Check(scriptPubKey)
}
// Attempt to get a valid script if it's an Address object
if (scriptPubKey instanceof Address) {
scriptPubKey = scriptPubKey.toOutputScript()
}
enforceType(Script, scriptPubKey)
enforceType('Number', value)
// Add the output and return the output's index
return (this.outs.push({
script: scriptPubKey,
value: value
}) - 1)
}
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)
var txOutSize = this.outs.reduce(function(a, x) {
return a + (8 + bufferutils.varIntSize(x.script.buffer.length) + x.script.buffer.length)
}, 0)
var buffer = new Buffer(
8 +
bufferutils.varIntSize(this.ins.length) +
bufferutils.varIntSize(this.outs.length) +
txInSize +
txOutSize
)
var offset = 0
function writeSlice(slice) {
slice.copy(buffer, offset)
offset += slice.length
}
function writeUInt32(i) {
buffer.writeUInt32LE(i, offset)
offset += 4
}
function writeUInt64(i) {
bufferutils.writeUInt64LE(buffer, i, offset)
offset += 8
}
function writeVarInt(i) {
var n = bufferutils.writeVarInt(buffer, i, offset)
offset += n
}
writeUInt32(this.version)
writeVarInt(this.ins.length)
this.ins.forEach(function(txin) {
writeSlice(txin.hash)
writeUInt32(txin.index)
writeVarInt(txin.script.buffer.length)
writeSlice(txin.script.buffer)
writeUInt32(txin.sequence)
})
writeVarInt(this.outs.length)
this.outs.forEach(function(txout) {
writeUInt64(txout.value)
writeVarInt(txout.script.buffer.length)
writeSlice(txout.script.buffer)
})
writeUInt32(this.locktime)
return buffer
}
Transaction.prototype.toHex = function() {
return this.toBuffer().toString('hex')
}
/**
* Hash transaction for signing a specific input.
*
* Bitcoin uses a different hash for each signed transaction input. This
* method copies the transaction, makes the necessary changes based on the
* hashType, serializes and finally hashes the result. This hash can then be
* used to sign the transaction input in question.
*/
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, ...)')
// swap the arguments (must be stored in tmp, arguments is special)
var tmp = arguments[0]
inIndex = arguments[1]
prevOutScript = tmp
}
enforceType('Number', inIndex)
enforceType(Script, prevOutScript)
enforceType('Number', hashType)
assert(inIndex >= 0, 'Invalid vin index')
assert(inIndex < this.ins.length, 'Invalid vin index')
var txTmp = this.clone()
var hashScript = prevOutScript.without(opcodes.OP_CODESEPARATOR)
// Blank out other inputs' signatures
txTmp.ins.forEach(function(txin) {
txin.script = Script.EMPTY
})
txTmp.ins[inIndex].script = hashScript
var hashTypeModifier = hashType & 0x1f
if (hashTypeModifier === Transaction.SIGHASH_NONE) {
assert(false, 'SIGHASH_NONE not yet supported')
} else if (hashTypeModifier === Transaction.SIGHASH_SINGLE) {
assert(false, 'SIGHASH_SINGLE not yet supported')
}
if (hashType & Transaction.SIGHASH_ANYONECANPAY) {
assert(false, 'SIGHASH_ANYONECANPAY not yet supported')
}
var hashTypeBuffer = new Buffer(4)
hashTypeBuffer.writeInt32LE(hashType, 0)
var buffer = Buffer.concat([txTmp.toBuffer(), hashTypeBuffer])
return crypto.hash256(buffer)
}
Transaction.prototype.getHash = function () {
return crypto.hash256(this.toBuffer())
}
Transaction.prototype.getId = function () {
// TxHash is little-endian, we need big-endian
return bufferutils.reverse(this.getHash()).toString('hex')
}
Transaction.prototype.clone = function () {
var newTx = new Transaction()
newTx.version = this.version
newTx.locktime = this.locktime
newTx.ins = this.ins.map(function(txin) {
return {
hash: txin.hash,
index: txin.index,
script: txin.script,
sequence: txin.sequence
}
})
newTx.outs = this.outs.map(function(txout) {
return {
script: txout.script,
value: txout.value
}
})
return newTx
}
Transaction.fromBuffer = function(buffer) {
var offset = 0
function readSlice(n) {
offset += n
return buffer.slice(offset - n, offset)
}
function readUInt32() {
var i = buffer.readUInt32LE(offset)
offset += 4
return i
}
function readUInt64() {
var i = bufferutils.readUInt64LE(buffer, offset)
offset += 8
return i
}
function readVarInt() {
var vi = bufferutils.readVarInt(buffer, offset)
offset += vi.size
return vi.number
}
var tx = new Transaction()
tx.version = readUInt32()
var vinLen = readVarInt()
for (var i = 0; i < vinLen; ++i) {
var hash = readSlice(32)
var vout = readUInt32()
var scriptLen = readVarInt()
var script = readSlice(scriptLen)
var sequence = readUInt32()
tx.ins.push({
hash: hash,
index: vout,
script: Script.fromBuffer(script),
sequence: sequence
})
}
var voutLen = readVarInt()
for (i = 0; i < voutLen; ++i) {
var value = readUInt64()
var scriptLen = readVarInt()
var script = readSlice(scriptLen)
tx.outs.push({
value: value,
script: Script.fromBuffer(script)
})
}
tx.locktime = readUInt32()
assert.equal(offset, buffer.length, 'Transaction has unexpected data')
return tx
}
Transaction.fromHex = function(hex) {
return Transaction.fromBuffer(new Buffer(hex, 'hex'))
}
Transaction.prototype.setInputScript = function(index, script) {
this.ins[index].script = script
}
// FIXME: remove in 2.x.y
Transaction.prototype.sign = function(index, privKey, hashType) {
console.warn("Transaction.prototype.sign is deprecated. Use TransactionBuilder instead.")
var prevOutScript = privKey.pub.getAddress().toOutputScript()
var signature = this.signInput(index, prevOutScript, privKey, hashType)
var scriptSig = scripts.pubKeyHashInput(signature, privKey.pub)
this.setInputScript(index, scriptSig)
}
// FIXME: remove in 2.x.y
Transaction.prototype.signInput = function(index, prevOutScript, privKey, hashType) {
console.warn("Transaction.prototype.signInput is deprecated. Use TransactionBuilder instead.")
hashType = hashType || Transaction.SIGHASH_ALL
var hash = this.hashForSignature(index, prevOutScript, hashType)
var signature = privKey.sign(hash)
return signature.toScriptSignature(hashType)
}
// FIXME: remove in 2.x.y
Transaction.prototype.validateInput = function(index, prevOutScript, pubKey, buffer) {
console.warn("Transaction.prototype.validateInput is deprecated. Use TransactionBuilder instead.")
var parsed = ECSignature.parseScriptSignature(buffer)
var hash = this.hashForSignature(index, prevOutScript, parsed.hashType)
return pubKey.verify(hash, parsed.signature)
}
module.exports = Transaction
}).call(this,require("buffer").Buffer)
},{"./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')
var ECPubKey = require('./ecpubkey')
var ECSignature = require('./ecsignature')
var Script = require('./script')
var Transaction = require('./transaction')
function TransactionBuilder() {
this.prevOutMap = {}
this.prevOutScripts = {}
this.prevOutTypes = {}
this.signatures = []
this.tx = new Transaction()
}
// Static constructors
TransactionBuilder.fromTransaction = function(transaction) {
var txb = new TransactionBuilder()
// Extract/add inputs
transaction.ins.forEach(function(txin) {
txb.addInput(txin.hash, txin.index, txin.sequence)
})
// Extract/add outputs
transaction.outs.forEach(function(txout) {
txb.addOutput(txout.script, txout.value)
})
// Extract/add signatures
transaction.ins.forEach(function(txin, i) {
// Ignore empty scripts
if (txin.script.buffer.length === 0) return
assert(!Array.prototype.every.call(txin.hash, function(x) {
return x === 0
}), 'coinbase inputs not supported')
var redeemScript
var scriptSig = txin.script
var scriptType = scripts.classifyInput(scriptSig)
// Re-classify if P2SH
if (scriptType === 'scripthash') {
redeemScript = Script.fromBuffer(scriptSig.chunks.slice(-1)[0])
scriptSig = Script.fromChunks(scriptSig.chunks.slice(0, -1))
scriptType = scripts.classifyInput(scriptSig)
assert.equal(scripts.classifyOutput(redeemScript), scriptType, 'Non-matching scriptSig and scriptPubKey in input')
}
// Extract hashType, pubKeys and signatures
var hashType, pubKeys, signatures
switch (scriptType) {
case 'pubkeyhash':
var parsed = ECSignature.parseScriptSignature(scriptSig.chunks[0])
var pubKey = ECPubKey.fromBuffer(scriptSig.chunks[1])
hashType = parsed.hashType
pubKeys = [pubKey]
signatures = [parsed.signature]
break
case 'multisig':
var scriptSigs = scriptSig.chunks.slice(1) // ignore OP_0
var parsed = scriptSigs.map(function(scriptSig) {
return ECSignature.parseScriptSignature(scriptSig)
})
hashType = parsed[0].hashType
pubKeys = []
signatures = parsed.map(function(p) { return p.signature })
break
case 'pubkey':
var parsed = ECSignature.parseScriptSignature(scriptSig.chunks[0])
hashType = parsed.hashType
pubKeys = []
signatures = [parsed.signature]
break
default:
assert(false, scriptType + ' inputs not supported')
}
txb.signatures[i] = {
hashType: hashType,
pubKeys: pubKeys,
redeemScript: redeemScript,
scriptType: scriptType,
signatures: signatures
}
})
return txb
}
// Operations
TransactionBuilder.prototype.addInput = function(prevTx, index, sequence, prevOutScript) {
var prevOutHash
if (typeof prevTx === 'string') {
prevOutHash = new Buffer(prevTx, 'hex')
// TxId hex is big-endian, we want little-endian hash
Array.prototype.reverse.call(prevOutHash)
} else if (prevTx instanceof Transaction) {
prevOutHash = prevTx.getHash()
prevOutScript = prevTx.outs[index].script
} else {
prevOutHash = prevTx
}
var prevOutType
if (prevOutScript !== undefined) {
prevOutType = scripts.classifyOutput(prevOutScript)
assert.notEqual(prevOutType, 'nonstandard', 'PrevOutScript not supported (nonstandard)')
}
assert(this.signatures.every(function(input) {
return input.hashType & Transaction.SIGHASH_ANYONECANPAY
}), 'No, this would invalidate signatures')
var prevOut = prevOutHash.toString('hex') + ':' + index
assert(!(prevOut in this.prevOutMap), 'Transaction is already an input')
var vout = this.tx.addInput(prevOutHash, index, sequence)
this.prevOutMap[prevOut] = true
this.prevOutScripts[vout] = prevOutScript
this.prevOutTypes[vout] = prevOutType
return vout
}
TransactionBuilder.prototype.addOutput = function(scriptPubKey, value) {
assert(this.signatures.every(function(signature) {
return (signature.hashType & 0x1f) === Transaction.SIGHASH_SINGLE
}), 'No, this would invalidate signatures')
return this.tx.addOutput(scriptPubKey, value)
}
TransactionBuilder.prototype.build = function() {
return this.__build(false)
}
TransactionBuilder.prototype.buildIncomplete = function() {
return this.__build(true)
}
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')
assert.equal(this.signatures.length, this.tx.ins.length, 'Transaction is missing signatures')
}
var tx = this.tx.clone()
// Create script signatures from signature meta-data
this.signatures.forEach(function(input, index) {
var scriptSig
var scriptType = input.scriptType
var signatures = input.signatures.map(function(signature) {
return signature.toScriptSignature(input.hashType)
})
switch (scriptType) {
case 'pubkeyhash':
var signature = signatures[0]
var pubKey = input.pubKeys[0]
scriptSig = scripts.pubKeyHashInput(signature, pubKey)
break
case 'multisig':
var redeemScript = allowIncomplete ? undefined : input.redeemScript
scriptSig = scripts.multisigInput(signatures, redeemScript)
break
case 'pubkey':
var signature = signatures[0]
scriptSig = scripts.pubKeyInput(signature)
break
default:
assert(false, scriptType + ' not supported')
}
if (input.redeemScript) {
scriptSig = scripts.scriptHashInput(scriptSig, input.redeemScript)
}
tx.setInputScript(index, scriptSig)
})
return tx
}
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]
var prevOutType = this.prevOutTypes[index]
var scriptType, hash
if (redeemScript) {
prevOutScript = prevOutScript || scripts.scriptHashOutput(redeemScript.getHash())
prevOutType = prevOutType || 'scripthash'
assert.equal(prevOutType, 'scripthash', 'PrevOutScript must be P2SH')
scriptType = scripts.classifyOutput(redeemScript)
assert.notEqual(scriptType, 'scripthash', 'RedeemScript can\'t be P2SH')
assert.notEqual(scriptType, 'nonstandard', 'RedeemScript not supported (nonstandard)')
hash = this.tx.hashForSignature(index, redeemScript, hashType)
} else {
prevOutScript = prevOutScript || privKey.pub.getAddress().toOutputScript()
prevOutType = prevOutType || 'pubkeyhash'
assert.notEqual(prevOutType, 'scripthash', 'PrevOutScript is P2SH, missing redeemScript')
scriptType = prevOutType
hash = this.tx.hashForSignature(index, prevOutScript, hashType)
}
this.prevOutScripts[index] = prevOutScript
this.prevOutTypes[index] = prevOutType
if (!(index in this.signatures)) {
this.signatures[index] = {
hashType: hashType,
pubKeys: [],
redeemScript: redeemScript,
scriptType: scriptType,
signatures: []
}
} else {
assert.equal(scriptType, 'multisig', scriptType + ' doesn\'t support multiple signatures')
}
var input = this.signatures[index]
assert.equal(input.hashType, hashType, 'Inconsistent hashType')
assert.deepEqual(input.redeemScript, redeemScript, 'Inconsistent redeemScript')
var signature = privKey.sign(hash)
input.pubKeys.push(privKey.pub)
input.signatures.push(signature)
}
module.exports = TransactionBuilder
}).call(this,require("buffer").Buffer)
},{"./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': {
if (Array.isArray(value)) return
break
}
case 'Boolean': {
if (typeof value === 'boolean') return
break
}
case 'Buffer': {
if (Buffer.isBuffer(value)) return
break
}
case 'Number': {
if (typeof value === 'number') return
break
}
case 'String': {
if (typeof value === 'string') return
break
}
default: {
if (getName(value.constructor) === getName(type)) return
}
}
throw new TypeError('Expected ' + (getName(type) || type) + ', got ' + value)
}
function getName(fn) {
// Why not fn.name: https://kangax.github.io/compat-table/es6/#function_name_property
var match = fn.toString().match(/function (.*?)\(/)
return match ? match[1] : null
}
}).call(this,require("buffer").Buffer)
},{"buffer":46}],43:[function(require,module,exports){
(function (Buffer){
var assert = require('assert')
var bufferutils = require('./bufferutils')
var crypto = require('crypto')
var enforceType = require('./types')
var networks = require('./networks')
var Address = require('./address')
var HDNode = require('./hdnode')
var TransactionBuilder = require('./transaction_builder')
var Script = require('./script')
function Wallet(seed, network) {
seed = seed || crypto.randomBytes(32)
network = network || networks.bitcoin
// Stored in a closure to make accidental serialization less likely
var masterKey = HDNode.fromSeedBuffer(seed, network)
// HD first-level child derivation method should be hardened
// See https://bitcointalk.org/index.php?topic=405179.msg4415254#msg4415254
var accountZero = masterKey.deriveHardened(0)
var externalAccount = accountZero.derive(0)
var internalAccount = accountZero.derive(1)
this.addresses = []
this.changeAddresses = []
this.network = network
this.unspents = []
// FIXME: remove in 2.0.0
this.unspentMap = {}
// FIXME: remove in 2.0.0
var me = this
this.newMasterKey = function(seed) {
console.warn('newMasterKey is deprecated, please make a new Wallet instance instead')
seed = seed || crypto.randomBytes(32)
masterKey = HDNode.fromSeedBuffer(seed, network)
accountZero = masterKey.deriveHardened(0)
externalAccount = accountZero.derive(0)
internalAccount = accountZero.derive(1)
me.addresses = []
me.changeAddresses = []
me.unspents = []
me.unspentMap = {}
}
this.getMasterKey = function() { return masterKey }
this.getAccountZero = function() { return accountZero }
this.getExternalAccount = function() { return externalAccount }
this.getInternalAccount = function() { return internalAccount }
}
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')
options = {
fixedFee: arguments[2],
changeAddress: arguments[3]
}
}
}
options = options || {}
assert(value > this.network.dustThreshold, value + ' must be above dust threshold (' + this.network.dustThreshold + ' Satoshis)')
var changeAddress = options.changeAddress
var fixedFee = options.fixedFee
var minConf = options.minConf === undefined ? 0 : options.minConf // FIXME: change minConf:1 by default in 2.0.0
// filter by minConf, then pending and sort by descending value
var unspents = this.unspents.filter(function(unspent) {
return unspent.confirmations >= minConf
}).filter(function(unspent) {
return !unspent.pending
}).sort(function(o1, o2) {
return o2.value - o1.value
})
var accum = 0
var addresses = []
var subTotal = value
var txb = new TransactionBuilder()
txb.addOutput(to, value)
for (var i = 0; i < unspents.length; ++i) {
var unspent = unspents[i]
addresses.push(unspent.address)
txb.addInput(unspent.txHash, unspent.index)
var fee = fixedFee === undefined ? estimatePaddedFee(txb.buildIncomplete(), this.network) : fixedFee
accum += unspent.value
subTotal = value + fee
if (accum >= subTotal) {
var change = accum - subTotal
if (change > this.network.dustThreshold) {
txb.addOutput(changeAddress || this.getChangeAddress(), change)
}
break
}
}
assert(accum >= subTotal, 'Not enough funds (incl. fee): ' + accum + ' < ' + subTotal)
return this.signWith(txb, addresses).build()
}
// FIXME: remove in 2.0.0
Wallet.prototype.processPendingTx = function(tx){
this.__processTx(tx, true)
}
// FIXME: remove in 2.0.0
Wallet.prototype.processConfirmedTx = function(tx){
this.__processTx(tx, false)
}
// FIXME: remove in 2.0.0
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()
tx.outs.forEach(function(txOut, i) {
var address
try {
address = Address.fromOutputScript(txOut.script, this.network).toString()
} catch(e) {
if (!(e.message.match(/has no matching Address/))) throw e
}
var myAddresses = this.addresses.concat(this.changeAddresses)
if (myAddresses.indexOf(address) > -1) {
var lookup = txId + ':' + i
if (lookup in this.unspentMap) return
// its unique, add it
var unspent = {
address: address,
confirmations: 0, // no way to determine this without more information
index: i,
txHash: txHash,
txId: txId,
value: txOut.value,
pending: isPending
}
this.unspentMap[lookup] = unspent
this.unspents.push(unspent)
}
}, this)
tx.ins.forEach(function(txIn, i) {
// copy and convert to big-endian hex
var txInId = bufferutils.reverse(txIn.hash).toString('hex')
var lookup = txInId + ':' + txIn.index
if (!(lookup in this.unspentMap)) return
var unspent = this.unspentMap[lookup]
if (isPending) {
unspent.pending = true
unspent.spent = true
} else {
delete this.unspentMap[lookup]
this.unspents = this.unspents.filter(function(unspent2) {
return unspent !== unspent2
})
}
}, this)
}
Wallet.prototype.generateAddress = function() {
var k = this.addresses.length
var address = this.getExternalAccount().derive(k).getAddress()
this.addresses.push(address.toString())
return this.getReceiveAddress()
}
Wallet.prototype.generateChangeAddress = function() {
var k = this.changeAddresses.length
var address = this.getInternalAccount().derive(k).getAddress()
this.changeAddresses.push(address.toString())
return this.getChangeAddress()
}
Wallet.prototype.getAddress = function() {
if (this.addresses.length === 0) {
this.generateAddress()
}
return this.addresses[this.addresses.length - 1]
}
Wallet.prototype.getBalance = function(minConf) {
minConf = minConf || 0
return this.unspents.filter(function(unspent) {
return unspent.confirmations >= minConf
// FIXME: remove spent filter in 2.0.0
}).filter(function(unspent) {
return !unspent.spent
}).reduce(function(accum, unspent) {
return accum + unspent.value
}, 0)
}
Wallet.prototype.getChangeAddress = function() {
if (this.changeAddresses.length === 0) {
this.generateChangeAddress()
}
return this.changeAddresses[this.changeAddresses.length - 1]
}
Wallet.prototype.getInternalPrivateKey = function(index) {
return this.getInternalAccount().derive(index).privKey
}
Wallet.prototype.getPrivateKey = function(index) {
return this.getExternalAccount().derive(index).privKey
}
Wallet.prototype.getPrivateKeyForAddress = function(address) {
var index
if ((index = this.addresses.indexOf(address)) > -1) {
return this.getPrivateKey(index)
}
if ((index = this.changeAddresses.indexOf(address)) > -1) {
return this.getInternalPrivateKey(index)
}
assert(false, 'Unknown address. Make sure the address is from the keychain and has been generated')
}
Wallet.prototype.getUnspentOutputs = function(minConf) {
minConf = minConf || 0
return this.unspents.filter(function(unspent) {
return unspent.confirmations >= minConf
// FIXME: remove spent filter in 2.0.0
}).filter(function(unspent) {
return !unspent.spent
}).map(function(unspent) {
return {
address: unspent.address,
confirmations: unspent.confirmations,
index: unspent.index,
txId: unspent.txId,
value: unspent.value,
// FIXME: remove in 2.0.0
hash: unspent.txId,
pending: unspent.pending
}
})
}
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
var index = unspent.index
// FIXME: remove in 2.0.0
if (unspent.hash !== undefined) {
console.warn('unspent.hash is deprecated, use unspent.txId instead')
}
// FIXME: remove in 2.0.0
if (index === undefined) {
console.warn('unspent.outputIndex is deprecated, use unspent.index instead')
index = unspent.outputIndex
}
enforceType('String', txId)
enforceType('Number', index)
enforceType('Number', unspent.value)
assert.equal(txId.length, 64, 'Expected valid txId, got ' + txId)
assert.doesNotThrow(function() { Address.fromBase58Check(unspent.address) }, 'Expected Base58 Address, got ' + unspent.address)
assert(isFinite(index), 'Expected finite index, got ' + index)
// FIXME: remove branch in 2.0.0
if (unspent.confirmations !== undefined) {
enforceType('Number', unspent.confirmations)
}
var txHash = bufferutils.reverse(new Buffer(txId, 'hex'))
unspent = {
address: unspent.address,
confirmations: unspent.confirmations || 0,
index: index,
txHash: txHash,
txId: txId,
value: unspent.value,
// FIXME: remove in 2.0.0
pending: unspent.pending || false
}
// FIXME: remove in 2.0.0
this.unspentMap[txId + ':' + index] = unspent
return unspent
}, this)
}
Wallet.prototype.signWith = function(tx, addresses) {
addresses.forEach(function(address, i) {
var privKey = this.getPrivateKeyForAddress(address)
tx.sign(i, privKey)
}, this)
return tx
}
function estimatePaddedFee(tx, network) {
var tmpTx = tx.clone()
tmpTx.addOutput(Script.EMPTY, network.dustSoftThreshold || 0)
return network.estimateFee(tmpTx)
}
// FIXME: 1.0.0 shims, remove in 2.0.0
Wallet.prototype.getReceiveAddress = Wallet.prototype.getAddress
Wallet.prototype.createTx = Wallet.prototype.createTransaction
module.exports = Wallet
}).call(this,require("buffer").Buffer)
},{"./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!
//
// Originally from narwhal.js (http://narwhaljs.org)
// Copyright (c) 2009 Thomas Robinson <280north.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the 'Software'), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// when used in node, this will actually load the util module we depend on
// versus loading the builtin util module as happens otherwise
// this is a bug in node module loading as far as I am concerned
var util = require('util/');
var pSlice = Array.prototype.slice;
var hasOwn = Object.prototype.hasOwnProperty;
// 1. The assert module provides functions that throw
// AssertionError's when particular conditions are not met. The
// assert module must conform to the following interface.
var assert = module.exports = ok;
// 2. The AssertionError is defined in assert.
// new assert.AssertionError({ message: message,
// actual: actual,
// expected: expected })
assert.AssertionError = function AssertionError(options) {
this.name = 'AssertionError';
this.actual = options.actual;
this.expected = options.expected;
this.operator = options.operator;
if (options.message) {
this.message = options.message;
this.generatedMessage = false;
} else {
this.message = getMessage(this);
this.generatedMessage = true;
}
var stackStartFunction = options.stackStartFunction || fail;
if (Error.captureStackTrace) {
Error.captureStackTrace(this, stackStartFunction);
}
else {
// non v8 browsers so we can have a stacktrace
var err = new Error();
if (err.stack) {
var out = err.stack;
// try to strip useless frames
var fn_name = stackStartFunction.name;
var idx = out.indexOf('\n' + fn_name);
if (idx >= 0) {
// once we have located the function frame
// we need to strip out everything before it (and its line)
var next_line = out.indexOf('\n', idx + 1);
out = out.substring(next_line + 1);
}
this.stack = out;
}
}
};
// assert.AssertionError instanceof Error
util.inherits(assert.AssertionError, Error);
function replacer(key, value) {
if (util.isUndefined(value)) {
return '' + value;
}
if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
return value.toString();
}
if (util.isFunction(value) || util.isRegExp(value)) {
return value.toString();
}
return value;
}
function truncate(s, n) {
if (util.isString(s)) {
return s.length < n ? s : s.slice(0, n);
} else {
return s;
}
}
function getMessage(self) {
return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
self.operator + ' ' +
truncate(JSON.stringify(self.expected, replacer), 128);
}
// At present only the three keys mentioned above are used and
// understood by the spec. Implementations or sub modules can pass
// other keys to the AssertionError's constructor - they will be
// ignored.
// 3. All of the following functions must throw an AssertionError
// when a corresponding condition is not met, with a message that
// may be undefined if not provided. All assertion methods provide
// both the actual and expected values to the assertion error for
// display purposes.
function fail(actual, expected, message, operator, stackStartFunction) {
throw new assert.AssertionError({
message: message,
actual: actual,
expected: expected,
operator: operator,
stackStartFunction: stackStartFunction
});
}
// EXTENSION! allows for well behaved errors defined elsewhere.
assert.fail = fail;
// 4. Pure assertion tests whether a value is truthy, as determined
// by !!guard.
// assert.ok(guard, message_opt);
// This statement is equivalent to assert.equal(true, !!guard,
// message_opt);. To test strictly for the value true, use
// assert.strictEqual(true, guard, message_opt);.
function ok(value, message) {
if (!value) fail(value, true, message, '==', assert.ok);
}
assert.ok = ok;
// 5. The equality assertion tests shallow, coercive equality with
// ==.
// assert.equal(actual, expected, message_opt);
assert.equal = function equal(actual, expected, message) {
if (actual != expected) fail(actual, expected, message, '==', assert.equal);
};
// 6. The non-equality assertion tests for whether two objects are not equal
// with != assert.notEqual(actual, expected, message_opt);
assert.notEqual = function notEqual(actual, expected, message) {
if (actual == expected) {
fail(actual, expected, message, '!=', assert.notEqual);
}
};
// 7. The equivalence assertion tests a deep equality relation.
// assert.deepEqual(actual, expected, message_opt);
assert.deepEqual = function deepEqual(actual, expected, message) {
if (!_deepEqual(actual, expected)) {
fail(actual, expected, message, 'deepEqual', assert.deepEqual);
}
};
function _deepEqual(actual, expected) {
// 7.1. All identical values are equivalent, as determined by ===.
if (actual === expected) {
return true;
} else if (util.isBuffer(actual) && util.isBuffer(expected)) {
if (actual.length != expected.length) return false;
for (var i = 0; i < actual.length; i++) {
if (actual[i] !== expected[i]) return false;
}
return true;
// 7.2. If the expected value is a Date object, the actual value is
// equivalent if it is also a Date object that refers to the same time.
} else if (util.isDate(actual) && util.isDate(expected)) {
return actual.getTime() === expected.getTime();
// 7.3 If the expected value is a RegExp object, the actual value is
// equivalent if it is also a RegExp object with the same source and
// properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
} 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 &&
actual.ignoreCase === expected.ignoreCase;
// 7.4. Other pairs that do not both pass typeof value == 'object',
// equivalence is determined by ==.
} else if (!util.isObject(actual) && !util.isObject(expected)) {
return actual == expected;
// 7.5 For all other Object pairs, including Array objects, equivalence is
// determined by having the same number of owned properties (as verified
// with Object.prototype.hasOwnProperty.call), the same set of keys
// (although not necessarily the same order), equivalent values for every
// corresponding key, and an identical 'prototype' property. Note: this
// accounts for both named and indexed properties on Arrays.
} else {
return objEquiv(actual, expected);
}
}
function isArguments(object) {
return Object.prototype.toString.call(object) == '[object Arguments]';
}
function objEquiv(a, b) {
if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
return false;
// an identical 'prototype' property.
if (a.prototype !== b.prototype) return false;
//~~~I've managed to break Object.keys through screwy arguments passing.
// Converting to array solves the problem.
if (isArguments(a)) {
if (!isArguments(b)) {
return false;
}
a = pSlice.call(a);
b = pSlice.call(b);
return _deepEqual(a, b);
}
try {
var ka = objectKeys(a),
kb = objectKeys(b),
key, i;
} catch (e) {//happens when one is a string literal and the other isn't
return false;
}
// having the same number of owned properties (keys incorporates
// hasOwnProperty)
if (ka.length != kb.length)
return false;
//the same set of keys (although not necessarily the same order),
ka.sort();
kb.sort();
//~~~cheap key test
for (i = ka.length - 1; i >= 0; i--) {
if (ka[i] != kb[i])
return false;
}
//equivalent values for every corresponding key, and
//~~~possibly expensive deep test
for (i = ka.length - 1; i >= 0; i--) {
key = ka[i];
if (!_deepEqual(a[key], b[key])) return false;
}
return true;
}
// 8. The non-equivalence assertion tests for any deep inequality.
// assert.notDeepEqual(actual, expected, message_opt);
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
if (_deepEqual(actual, expected)) {
fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
}
};
// 9. The strict equality assertion tests strict equality, as determined by ===.
// assert.strictEqual(actual, expected, message_opt);
assert.strictEqual = function strictEqual(actual, expected, message) {
if (actual !== expected) {
fail(actual, expected, message, '===', assert.strictEqual);
}
};
// 10. The strict non-equality assertion tests for strict inequality, as
// determined by !==. assert.notStrictEqual(actual, expected, message_opt);
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
if (actual === expected) {
fail(actual, expected, message, '!==', assert.notStrictEqual);
}
};
function expectedException(actual, expected) {
if (!actual || !expected) {
return false;
}
if (Object.prototype.toString.call(expected) == '[object RegExp]') {
return expected.test(actual);
} else if (actual instanceof expected) {
return true;
} else if (expected.call({}, actual) === true) {
return true;
}
return false;
}
function _throws(shouldThrow, block, expected, message) {
var actual;
if (util.isString(expected)) {
message = expected;
expected = null;
}
try {
block();
} catch (e) {
actual = e;
}
message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
(message ? ' ' + message : '.');
if (shouldThrow && !actual) {
fail(actual, expected, 'Missing expected exception' + message);
}
if (!shouldThrow && expectedException(actual, expected)) {
fail(actual, expected, 'Got unwanted exception' + message);
}
if ((shouldThrow && actual && expected &&
!expectedException(actual, expected)) || (!shouldThrow && actual)) {
throw actual;
}
}
// 11. Expected to throw an error:
// assert.throws(block, Error_opt, message_opt);
assert.throws = function(block, /*optional*/error, /*optional*/message) {
_throws.apply(this, [true].concat(pSlice.call(arguments)));
};
// EXTENSION! This is annoying to write outside this module.
assert.doesNotThrow = function(block, /*optional*/message) {
_throws.apply(this, [false].concat(pSlice.call(arguments)));
};
assert.ifError = function(err) { if (err) {throw err;}};
var objectKeys = Object.keys || function (obj) {
var keys = [];
for (var key in obj) {
if (hasOwn.call(obj, key)) keys.push(key);
}
return keys;
};
},{"util/":68}],45:[function(require,module,exports){
},{}],46:[function(require,module,exports){
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
* @license MIT
*/
var base64 = require('base64-js')
var ieee754 = require('ieee754')
var isArray = require('is-array')
exports.Buffer = Buffer
exports.SlowBuffer = Buffer
exports.INSPECT_MAX_BYTES = 50
Buffer.poolSize = 8192 // not used by this implementation
var kMaxLength = 0x3fffffff
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Use Object implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
* Opera 11.6+, iOS 4.2+.
*
* Note:
*
* - Implementation must support adding new properties to `Uint8Array` instances.
* Firefox 4-29 lacked support, fixed in Firefox 30+.
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
*
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
*
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
* incorrect length in some situations.
*
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they will
* get the Object implementation, which is slower but will work correctly.
*/
Buffer.TYPED_ARRAY_SUPPORT = (function () {
try {
var buf = new ArrayBuffer(0)
var arr = new Uint8Array(buf)
arr.foo = function () { return 42 }
return 42 === arr.foo() && // typed array instances can be augmented
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
new Uint8Array(1).subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
} catch (e) {
return false
}
})()
/**
* Class: Buffer
* =============
*
* The Buffer constructor returns instances of `Uint8Array` that are augmented
* with function properties for all the node `Buffer` API functions. We use
* `Uint8Array` so that square bracket notation works as expected -- it returns
* a single octet.
*
* By augmenting the instances, we can avoid modifying the `Uint8Array`
* prototype.
*/
function Buffer (subject, encoding, noZero) {
if (!(this instanceof Buffer))
return new Buffer(subject, encoding, noZero)
var type = typeof subject
// Find the length
var length
if (type === 'number')
length = subject > 0 ? subject >>> 0 : 0
else if (type === 'string') {
if (encoding === 'base64')
subject = base64clean(subject)
length = Buffer.byteLength(subject, encoding)
} else if (type === 'object' && subject !== null) { // assume object is array-like
if (subject.type === 'Buffer' && isArray(subject.data))
subject = subject.data
length = +subject.length > 0 ? Math.floor(+subject.length) : 0
} else
throw new TypeError('must start with number, buffer, array or string')
if (this.length > kMaxLength)
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + kMaxLength.toString(16) + ' bytes')
var buf
if (Buffer.TYPED_ARRAY_SUPPORT) {
// Preferred: Return an augmented `Uint8Array` instance for best performance
buf = Buffer._augment(new Uint8Array(length))
} else {
// Fallback: Return THIS instance of Buffer (created by `new`)
buf = this
buf.length = length
buf._isBuffer = true
}
var i
if (Buffer.TYPED_ARRAY_SUPPORT && typeof subject.byteLength === 'number') {
// Speed optimization -- use set if we're copying from a typed array
buf._set(subject)
} else if (isArrayish(subject)) {
// Treat array-ish objects as a byte array
if (Buffer.isBuffer(subject)) {
for (i = 0; i < length; i++)
buf[i] = subject.readUInt8(i)
} else {
for (i = 0; i < length; i++)
buf[i] = ((subject[i] % 256) + 256) % 256
}
} else if (type === 'string') {
buf.write(subject, 0, encoding)
} else if (type === 'number' && !Buffer.TYPED_ARRAY_SUPPORT && !noZero) {
for (i = 0; i < length; i++) {
buf[i] = 0
}
}
return buf
}
Buffer.isBuffer = function (b) {
return !!(b != null && b._isBuffer)
}
Buffer.compare = function (a, b) {
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b))
throw new TypeError('Arguments must be Buffers')
var x = a.length
var y = b.length
for (var i = 0, len = Math.min(x, y); i < len && a[i] === b[i]; i++) {}
if (i !== len) {
x = a[i]
y = b[i]
}
if (x < y) return -1
if (y < x) return 1
return 0
}
Buffer.isEncoding = function (encoding) {
switch (String(encoding).toLowerCase()) {
case 'hex':
case 'utf8':
case 'utf-8':
case 'ascii':
case 'binary':
case 'base64':
case 'raw':
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return true
default:
return false
}
}
Buffer.concat = function (list, totalLength) {
if (!isArray(list)) throw new TypeError('Usage: Buffer.concat(list[, length])')
if (list.length === 0) {
return new Buffer(0)
} else if (list.length === 1) {
return list[0]
}
var i
if (totalLength === undefined) {
totalLength = 0
for (i = 0; i < list.length; i++) {
totalLength += list[i].length
}
}
var buf = new Buffer(totalLength)
var pos = 0
for (i = 0; i < list.length; i++) {
var item = list[i]
item.copy(buf, pos)
pos += item.length
}
return buf
}
Buffer.byteLength = function (str, encoding) {
var ret
str = str + ''
switch (encoding || 'utf8') {
case 'ascii':
case 'binary':
case 'raw':
ret = str.length
break
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
ret = str.length * 2
break
case 'hex':
ret = str.length >>> 1
break
case 'utf8':
case 'utf-8':
ret = utf8ToBytes(str).length
break
case 'base64':
ret = base64ToBytes(str).length
break
default:
ret = str.length
}
return ret
}
// pre-set for values that may exist in the future
Buffer.prototype.length = undefined
Buffer.prototype.parent = undefined
// toString(encoding, start=0, end=buffer.length)
Buffer.prototype.toString = function (encoding, start, end) {
var loweredCase = false
start = start >>> 0
end = end === undefined || end === Infinity ? this.length : end >>> 0
if (!encoding) encoding = 'utf8'
if (start < 0) start = 0
if (end > this.length) end = this.length
if (end <= start) return ''
while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)
case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)
case 'ascii':
return asciiSlice(this, start, end)
case 'binary':
return binarySlice(this, start, end)
case 'base64':
return base64Slice(this, start, end)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)
default:
if (loweredCase)
throw new TypeError('Unknown encoding: ' + encoding)
encoding = (encoding + '').toLowerCase()
loweredCase = true
}
}
}
Buffer.prototype.equals = function (b) {
if(!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
return Buffer.compare(this, b) === 0
}
Buffer.prototype.inspect = function () {
var str = ''
var max = exports.INSPECT_MAX_BYTES
if (this.length > 0) {
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
if (this.length > max)
str += ' ... '
}
return '<Buffer ' + str + '>'
}
Buffer.prototype.compare = function (b) {
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
return Buffer.compare(this, b)
}
// `get` will be removed in Node 0.13+
Buffer.prototype.get = function (offset) {
console.log('.get() is deprecated. Access using array indexes instead.')
return this.readUInt8(offset)
}
// `set` will be removed in Node 0.13+
Buffer.prototype.set = function (v, offset) {
console.log('.set() is deprecated. Access using array indexes instead.')
return this.writeUInt8(v, offset)
}
function hexWrite (buf, string, offset, length) {
offset = Number(offset) || 0
var remaining = buf.length - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}
// must be an even number of digits
var strLen = string.length
if (strLen % 2 !== 0) throw new Error('Invalid hex string')
if (length > strLen / 2) {
length = strLen / 2
}
for (var i = 0; i < length; i++) {
var byte = parseInt(string.substr(i * 2, 2), 16)
if (isNaN(byte)) throw new Error('Invalid hex string')
buf[offset + i] = byte
}
return i
}
function utf8Write (buf, string, offset, length) {
var charsWritten = blitBuffer(utf8ToBytes(string), buf, offset, length)
return charsWritten
}
function asciiWrite (buf, string, offset, length) {
var charsWritten = blitBuffer(asciiToBytes(string), buf, offset, length)
return charsWritten
}
function binaryWrite (buf, string, offset, length) {
return asciiWrite(buf, string, offset, length)
}
function base64Write (buf, string, offset, length) {
var charsWritten = blitBuffer(base64ToBytes(string), buf, offset, length)
return charsWritten
}
function utf16leWrite (buf, string, offset, length) {
var charsWritten = blitBuffer(utf16leToBytes(string), buf, offset, length)
return charsWritten
}
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)) {
encoding = length
length = undefined
}
} else { // legacy
var swap = encoding
encoding = offset
offset = length
length = swap
}
offset = Number(offset) || 0
var remaining = this.length - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}
encoding = String(encoding || 'utf8').toLowerCase()
var ret
switch (encoding) {
case 'hex':
ret = hexWrite(this, string, offset, length)
break
case 'utf8':
case 'utf-8':
ret = utf8Write(this, string, offset, length)
break
case 'ascii':
ret = asciiWrite(this, string, offset, length)
break
case 'binary':
ret = binaryWrite(this, string, offset, length)
break
case 'base64':
ret = base64Write(this, string, offset, length)
break
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
ret = utf16leWrite(this, string, offset, length)
break
default:
throw new TypeError('Unknown encoding: ' + encoding)
}
return ret
}
Buffer.prototype.toJSON = function () {
return {
type: 'Buffer',
data: Array.prototype.slice.call(this._arr || this, 0)
}
}
function base64Slice (buf, start, end) {
if (start === 0 && end === buf.length) {
return base64.fromByteArray(buf)
} else {
return base64.fromByteArray(buf.slice(start, end))
}
}
function utf8Slice (buf, start, end) {
var res = ''
var tmp = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; i++) {
if (buf[i] <= 0x7F) {
res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
tmp = ''
} else {
tmp += '%' + buf[i].toString(16)
}
}
return res + decodeUtf8Char(tmp)
}
function asciiSlice (buf, start, end) {
var ret = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; i++) {
ret += String.fromCharCode(buf[i])
}
return ret
}
function binarySlice (buf, start, end) {
return asciiSlice(buf, start, end)
}
function hexSlice (buf, start, end) {
var len = buf.length
if (!start || start < 0) start = 0
if (!end || end < 0 || end > len) end = len
var out = ''
for (var i = start; i < end; i++) {
out += toHex(buf[i])
}
return out
}
function utf16leSlice (buf, start, end) {
var bytes = buf.slice(start, end)
var res = ''
for (var i = 0; i < bytes.length; i += 2) {
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
}
return res
}
Buffer.prototype.slice = function (start, end) {
var len = this.length
start = ~~start
end = end === undefined ? len : ~~end
if (start < 0) {
start += len;
if (start < 0)
start = 0
} else if (start > len) {
start = len
}
if (end < 0) {
end += len
if (end < 0)
end = 0
} else if (end > len) {
end = len
}
if (end < start)
end = start
if (Buffer.TYPED_ARRAY_SUPPORT) {
return Buffer._augment(this.subarray(start, end))
} else {
var sliceLen = end - start
var newBuf = new Buffer(sliceLen, undefined, true)
for (var i = 0; i < sliceLen; i++) {
newBuf[i] = this[i + start]
}
return newBuf
}
}
/*
* Need to make sure that buffer isn't trying to write out of bounds.
*/
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0)
throw new RangeError('offset is not uint')
if (offset + ext > length)
throw new RangeError('Trying to access beyond buffer length')
}
Buffer.prototype.readUInt8 = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 1, this.length)
return this[offset]
}
Buffer.prototype.readUInt16LE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 2, this.length)
return this[offset] | (this[offset + 1] << 8)
}
Buffer.prototype.readUInt16BE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 2, this.length)
return (this[offset] << 8) | this[offset + 1]
}
Buffer.prototype.readUInt32LE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
}
Buffer.prototype.readUInt32BE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return (this[offset] * 0x1000000) +
((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
}
Buffer.prototype.readInt8 = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 1, this.length)
if (!(this[offset] & 0x80))
return (this[offset])
return ((0xff - this[offset] + 1) * -1)
}
Buffer.prototype.readInt16LE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 2, this.length)
var val = this[offset] | (this[offset + 1] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt16BE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 2, this.length)
var val = this[offset + 1] | (this[offset] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt32LE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
}
Buffer.prototype.readInt32BE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return (this[offset] << 24) |
(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
}
Buffer.prototype.readFloatLE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, true, 23, 4)
}
Buffer.prototype.readFloatBE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, false, 23, 4)
}
Buffer.prototype.readDoubleLE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, true, 52, 8)
}
Buffer.prototype.readDoubleBE = function (offset, noAssert) {
if (!noAssert)
checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, false, 52, 8)
}
function checkInt (buf, value, offset, ext, max, min) {
if (!Buffer.isBuffer(buf)) throw new TypeError('buffer must be a Buffer instance')
if (value > max || value < min) throw new TypeError('value is out of bounds')
if (offset + ext > buf.length) throw new TypeError('index out of range')
}
Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 1, 0xff, 0)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
this[offset] = value
return offset + 1
}
function objectWriteUInt16 (buf, value, offset, littleEndian) {
if (value < 0) value = 0xffff + value + 1
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
(littleEndian ? i : 1 - i) * 8
}
}
Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
} else objectWriteUInt16(this, value, offset, true)
return offset + 2
}
Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0xffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = value
} else objectWriteUInt16(this, value, offset, false)
return offset + 2
}
function objectWriteUInt32 (buf, value, offset, littleEndian) {
if (value < 0) value = 0xffffffff + value + 1
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
}
}
Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset + 3] = (value >>> 24)
this[offset + 2] = (value >>> 16)
this[offset + 1] = (value >>> 8)
this[offset] = value
} else objectWriteUInt32(this, value, offset, true)
return offset + 4
}
Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0xffffffff, 0)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = value
} else objectWriteUInt32(this, value, offset, false)
return offset + 4
}
Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 1, 0x7f, -0x80)
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
if (value < 0) value = 0xff + value + 1
this[offset] = value
return offset + 1
}
Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
} else objectWriteUInt16(this, value, offset, true)
return offset + 2
}
Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 2, 0x7fff, -0x8000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 8)
this[offset + 1] = value
} else objectWriteUInt16(this, value, offset, false)
return offset + 2
}
Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = value
this[offset + 1] = (value >>> 8)
this[offset + 2] = (value >>> 16)
this[offset + 3] = (value >>> 24)
} else objectWriteUInt32(this, value, offset, true)
return offset + 4
}
Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert)
checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (value < 0) value = 0xffffffff + value + 1
if (Buffer.TYPED_ARRAY_SUPPORT) {
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = value
} else objectWriteUInt32(this, value, offset, false)
return offset + 4
}
function checkIEEE754 (buf, value, offset, ext, max, min) {
if (value > max || value < min) throw new TypeError('value is out of bounds')
if (offset + ext > buf.length) throw new TypeError('index out of range')
}
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
}
Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert)
}
Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
return writeFloat(this, value, offset, false, noAssert)
}
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
}
Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert)
}
Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert)
}
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function (target, target_start, start, end) {
var source = this
if (!start) start = 0
if (!end && end !== 0) end = this.length
if (!target_start) target_start = 0
// Copy 0 bytes; we're done
if (end === start) return
if (target.length === 0 || source.length === 0) return
// Fatal error conditions
if (end < start) throw new TypeError('sourceEnd < sourceStart')
if (target_start < 0 || target_start >= target.length)
throw new TypeError('targetStart out of bounds')
if (start < 0 || start >= source.length) throw new TypeError('sourceStart out of bounds')
if (end < 0 || end > source.length) throw new TypeError('sourceEnd out of bounds')
// Are we oob?
if (end > this.length)
end = this.length
if (target.length - target_start < end - start)
end = target.length - target_start + start
var len = end - start
if (len < 100 || !Buffer.TYPED_ARRAY_SUPPORT) {
for (var i = 0; i < len; i++) {
target[i + target_start] = this[i + start]
}
} else {
target._set(this.subarray(start, start + len), target_start)
}
}
// fill(value, start=0, end=buffer.length)
Buffer.prototype.fill = function (value, start, end) {
if (!value) value = 0
if (!start) start = 0
if (!end) end = this.length
if (end < start) throw new TypeError('end < start')
// Fill 0 bytes; we're done
if (end === start) return
if (this.length === 0) return
if (start < 0 || start >= this.length) throw new TypeError('start out of bounds')
if (end < 0 || end > this.length) throw new TypeError('end out of bounds')
var i
if (typeof value === 'number') {
for (i = start; i < end; i++) {
this[i] = value
}
} else {
var bytes = utf8ToBytes(value.toString())
var len = bytes.length
for (i = start; i < end; i++) {
this[i] = bytes[i % len]
}
}
return this
}
/**
* Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
* Added in Node 0.12. Only available in browsers that support ArrayBuffer.
*/
Buffer.prototype.toArrayBuffer = function () {
if (typeof Uint8Array !== 'undefined') {
if (Buffer.TYPED_ARRAY_SUPPORT) {
return (new Buffer(this)).buffer
} else {
var buf = new Uint8Array(this.length)
for (var i = 0, len = buf.length; i < len; i += 1) {
buf[i] = this[i]
}
return buf.buffer
}
} else {
throw new TypeError('Buffer.toArrayBuffer not supported in this browser')
}
}
// HELPER FUNCTIONS
// ================
var BP = Buffer.prototype
/**
* Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
*/
Buffer._augment = function (arr) {
arr._isBuffer = true
// save reference to original Uint8Array get/set methods before overwriting
arr._get = arr.get
arr._set = arr.set
// deprecated, will be removed in node 0.13+
arr.get = BP.get
arr.set = BP.set
arr.write = BP.write
arr.toString = BP.toString
arr.toLocaleString = BP.toString
arr.toJSON = BP.toJSON
arr.equals = BP.equals
arr.compare = BP.compare
arr.copy = BP.copy
arr.slice = BP.slice
arr.readUInt8 = BP.readUInt8
arr.readUInt16LE = BP.readUInt16LE
arr.readUInt16BE = BP.readUInt16BE
arr.readUInt32LE = BP.readUInt32LE
arr.readUInt32BE = BP.readUInt32BE
arr.readInt8 = BP.readInt8
arr.readInt16LE = BP.readInt16LE
arr.readInt16BE = BP.readInt16BE
arr.readInt32LE = BP.readInt32LE
arr.readInt32BE = BP.readInt32BE
arr.readFloatLE = BP.readFloatLE
arr.readFloatBE = BP.readFloatBE
arr.readDoubleLE = BP.readDoubleLE
arr.readDoubleBE = BP.readDoubleBE
arr.writeUInt8 = BP.writeUInt8
arr.writeUInt16LE = BP.writeUInt16LE
arr.writeUInt16BE = BP.writeUInt16BE
arr.writeUInt32LE = BP.writeUInt32LE
arr.writeUInt32BE = BP.writeUInt32BE
arr.writeInt8 = BP.writeInt8
arr.writeInt16LE = BP.writeInt16LE
arr.writeInt16BE = BP.writeInt16BE
arr.writeInt32LE = BP.writeInt32LE
arr.writeInt32BE = BP.writeInt32BE
arr.writeFloatLE = BP.writeFloatLE
arr.writeFloatBE = BP.writeFloatBE
arr.writeDoubleLE = BP.writeDoubleLE
arr.writeDoubleBE = BP.writeDoubleBE
arr.fill = BP.fill
arr.inspect = BP.inspect
arr.toArrayBuffer = BP.toArrayBuffer
return arr
}
var INVALID_BASE64_RE = /[^+\/0-9A-z]/g
function base64clean (str) {
// Node strips out invalid characters like \n and \t from the string, base64-js does not
str = stringtrim(str).replace(INVALID_BASE64_RE, '')
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
while (str.length % 4 !== 0) {
str = str + '='
}
return str
}
function stringtrim (str) {
if (str.trim) return str.trim()
return str.replace(/^\s+|\s+$/g, '')
}
function isArrayish (subject) {
return isArray(subject) || Buffer.isBuffer(subject) ||
subject && typeof subject === 'object' &&
typeof subject.length === 'number'
}
function toHex (n) {
if (n < 16) return '0' + n.toString(16)
return n.toString(16)
}
function utf8ToBytes (str) {
var byteArray = []
for (var i = 0; i < str.length; i++) {
var b = str.charCodeAt(i)
if (b <= 0x7F) {
byteArray.push(b)
} else {
var start = i
if (b >= 0xD800 && b <= 0xDFFF) i++
var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')
for (var j = 0; j < h.length; j++) {
byteArray.push(parseInt(h[j], 16))
}
}
}
return byteArray
}
function asciiToBytes (str) {
var byteArray = []
for (var i = 0; i < str.length; i++) {
// Node's code seems to be doing this and not & 0x7F..
byteArray.push(str.charCodeAt(i) & 0xFF)
}
return byteArray
}
function utf16leToBytes (str) {
var c, hi, lo
var byteArray = []
for (var i = 0; i < str.length; i++) {
c = str.charCodeAt(i)
hi = c >> 8
lo = c % 256
byteArray.push(lo)
byteArray.push(hi)
}
return byteArray
}
function base64ToBytes (str) {
return base64.toByteArray(str)
}
function blitBuffer (src, dst, offset, length) {
for (var i = 0; i < length; i++) {
if ((i + offset >= dst.length) || (i >= src.length))
break
dst[i + offset] = src[i]
}
return i
}
function decodeUtf8Char (str) {
try {
return decodeURIComponent(str)
} catch (err) {
return String.fromCharCode(0xFFFD) // UTF 8 invalid char
}
}
},{"base64-js":47,"ieee754":48,"is-array":49}],47:[function(require,module,exports){
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
;(function (exports) {
'use strict';
var Arr = (typeof Uint8Array !== 'undefined')
? Uint8Array
: Array
var PLUS = '+'.charCodeAt(0)
var SLASH = '/'.charCodeAt(0)
var NUMBER = '0'.charCodeAt(0)
var LOWER = 'a'.charCodeAt(0)
var UPPER = 'A'.charCodeAt(0)
function decode (elt) {
var code = elt.charCodeAt(0)
if (code === PLUS)
return 62 // '+'
if (code === SLASH)
return 63 // '/'
if (code < NUMBER)
return -1 //no match
if (code < NUMBER + 10)
return code - NUMBER + 26 + 26
if (code < UPPER + 26)
return code - UPPER
if (code < LOWER + 26)
return code - LOWER + 26
}
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')
}
// the number of equal signs (place holders)
// if there are two placeholders, than the two characters before it
// represent one byte
// if there is only one, then the three characters before it represent 2 bytes
// this is just a cheap hack to not do indexOf twice
var len = b64.length
placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
// base64 is 4/3 + up to two characters of the original data
arr = new Arr(b64.length * 3 / 4 - placeHolders)
// if there are placeholders, only get up to the last complete 4 chars
l = placeHolders > 0 ? b64.length - 4 : b64.length
var L = 0
function push (v) {
arr[L++] = v
}
for (i = 0, j = 0; i < l; i += 4, j += 3) {
tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
push((tmp & 0xFF0000) >> 16)
push((tmp & 0xFF00) >> 8)
push(tmp & 0xFF)
}
if (placeHolders === 2) {
tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
push(tmp & 0xFF)
} else if (placeHolders === 1) {
tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
push((tmp >> 8) & 0xFF)
push(tmp & 0xFF)
}
return arr
}
function uint8ToBase64 (uint8) {
var i,
extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
output = "",
temp, length
function encode (num) {
return lookup.charAt(num)
}
function tripletToBase64 (num) {
return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
}
// go through the array every three bytes, we'll deal with trailing stuff later
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
output += tripletToBase64(temp)
}
// pad the end with zeros, but make sure to not forget the extra bytes
switch (extraBytes) {
case 1:
temp = uint8[uint8.length - 1]
output += encode(temp >> 2)
output += encode((temp << 4) & 0x3F)
output += '=='
break
case 2:
temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
output += encode(temp >> 10)
output += encode((temp >> 4) & 0x3F)
output += encode((temp << 2) & 0x3F)
output += '='
break
}
return output
}
exports.toByteArray = b64ToByteArray
exports.fromByteArray = uint8ToBase64
}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
},{}],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,
eBias = eMax >> 1,
nBits = -7,
i = isLE ? (nBytes - 1) : 0,
d = isLE ? -1 : 1,
s = buffer[offset + i];
i += d;
e = s & ((1 << (-nBits)) - 1);
s >>= (-nBits);
nBits += eLen;
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
m = e & ((1 << (-nBits)) - 1);
e >>= (-nBits);
nBits += mLen;
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
if (e === 0) {
e = 1 - eBias;
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity);
} else {
m = m + Math.pow(2, mLen);
e = e - eBias;
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
};
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,
rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
i = isLE ? 0 : (nBytes - 1),
d = isLE ? 1 : -1,
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
value = Math.abs(value);
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0;
e = eMax;
} else {
e = Math.floor(Math.log(value) / Math.LN2);
if (value * (c = Math.pow(2, -e)) < 1) {
e--;
c *= 2;
}
if (e + eBias >= 1) {
value += rt / c;
} else {
value += rt * Math.pow(2, 1 - eBias);
}
if (value * c >= 2) {
e++;
c /= 2;
}
if (e + eBias >= eMax) {
m = 0;
e = eMax;
} else if (e + eBias >= 1) {
m = (value * c - 1) * Math.pow(2, mLen);
e = e + eBias;
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
e = 0;
}
}
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
e = (e << mLen) | m;
eLen += mLen;
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
buffer[offset + i - d] |= s * 128;
};
},{}],49:[function(require,module,exports){
/**
* isArray
*/
var isArray = Array.isArray;
/**
* toString
*/
var str = Object.prototype.toString;
/**
* Whether or not the given `val`
* is an array.
*
* example:
*
* isArray([]);
* // > true
* isArray(arguments);
* // > false
* isArray('');
* // > false
*
* @param {mixed} val
* @return {bool}
*/
module.exports = isArray || function (val) {
return !! val && '[object Array]' == str.call(val);
};
},{}],50:[function(require,module,exports){
module.exports=require(7)
},{"./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){
module.exports=require(9)
},{"/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){
module.exports=require(11)
},{"./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){
module.exports=require(13)
},{"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/node_modules/pbkdf2-compat/pbkdf2.js":13,"buffer":46}],57:[function(require,module,exports){
module.exports=require(14)
},{"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/node_modules/ripemd160/lib/ripemd160.js":14,"buffer":46}],58:[function(require,module,exports){
module.exports=require(15)
},{"/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){
module.exports=require(17)
},{"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/node_modules/sha.js/sha1.js":17,"util":68}],61:[function(require,module,exports){
module.exports=require(18)
},{"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/node_modules/sha.js/sha256.js":18,"util":68}],62:[function(require,module,exports){
module.exports=require(19)
},{"/home/elendil/src/bitcoinjs-lib/node_modules/bitcoinjs-lib/node_modules/crypto-browserify/node_modules/sha.js/sha512.js":19,"util":68}],63:[function(require,module,exports){
module.exports=require(20)
},{"/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){
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
},{}],66:[function(require,module,exports){
// shim for using process in browser
var process = module.exports = {};
process.nextTick = (function () {
var canSetImmediate = typeof window !== 'undefined'
&& window.setImmediate;
var canMutationObserver = typeof window !== 'undefined'
&& window.MutationObserver;
var canPost = typeof window !== 'undefined'
&& window.postMessage && window.addEventListener
;
if (canSetImmediate) {
return function (f) { return window.setImmediate(f) };
}
var queue = [];
if (canMutationObserver) {
var hiddenDiv = document.createElement("div");
var observer = new MutationObserver(function () {
var queueList = queue.slice();
queue.length = 0;
queueList.forEach(function (fn) {
fn();
});
});
observer.observe(hiddenDiv, { attributes: true });
return function nextTick(fn) {
if (!queue.length) {
hiddenDiv.setAttribute('yes', 'no');
}
queue.push(fn);
};
}
if (canPost) {
window.addEventListener('message', function (ev) {
var source = ev.source;
if ((source === window || source === null) && ev.data === 'process-tick') {
ev.stopPropagation();
if (queue.length > 0) {
var fn = queue.shift();
fn();
}
}
}, true);
return function nextTick(fn) {
queue.push(fn);
window.postMessage('process-tick', '*');
};
}
return function nextTick(fn) {
setTimeout(fn, 0);
};
})();
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
},{}],67:[function(require,module,exports){
module.exports = function isBuffer(arg) {
return arg && typeof arg === 'object'
&& typeof arg.copy === 'function'
&& typeof arg.fill === 'function'
&& typeof arg.readUInt8 === 'function';
}
},{}],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
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var formatRegExp = /%[sdj%]/g;
exports.format = function(f) {
if (!isString(f)) {
var objects = [];
for (var i = 0; i < arguments.length; i++) {
objects.push(inspect(arguments[i]));
}
return objects.join(' ');
}
var i = 1;
var args = arguments;
var len = args.length;
var str = String(f).replace(formatRegExp, function(x) {
if (x === '%%') return '%';
if (i >= len) return x;
switch (x) {
case '%s': return String(args[i++]);
case '%d': return Number(args[i++]);
case '%j':
try {
return JSON.stringify(args[i++]);
} catch (_) {
return '[Circular]';
}
default:
return x;
}
});
for (var x = args[i]; i < len; x = args[++i]) {
if (isNull(x) || !isObject(x)) {
str += ' ' + x;
} else {
str += ' ' + inspect(x);
}
}
return str;
};
// Mark that a method should not be used.
// Returns a modified function which warns once by default.
// If --no-deprecation is set, then it is a no-op.
exports.deprecate = function(fn, msg) {
// Allow for deprecating things in the process of starting up.
if (isUndefined(global.process)) {
return function() {
return exports.deprecate(fn, msg).apply(this, arguments);
};
}
if (process.noDeprecation === true) {
return fn;
}
var warned = false;
function deprecated() {
if (!warned) {
if (process.throwDeprecation) {
throw new Error(msg);
} else if (process.traceDeprecation) {
console.trace(msg);
} else {
console.error(msg);
}
warned = true;
}
return fn.apply(this, arguments);
}
return deprecated;
};
var debugs = {};
var debugEnviron;
exports.debuglog = function(set) {
if (isUndefined(debugEnviron))
debugEnviron = process.env.NODE_DEBUG || '';
set = set.toUpperCase();
if (!debugs[set]) {
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
var pid = process.pid;
debugs[set] = function() {
var msg = exports.format.apply(exports, arguments);
console.error('%s %d: %s', set, pid, msg);
};
} else {
debugs[set] = function() {};
}
}
return debugs[set];
};
/**
* Echos the value of a value. Trys to print the value out
* in the best way possible given the different types.
*
* @param {Object} obj The object to print out.
* @param {Object} opts Optional options object that alters the output.
*/
/* legacy: obj, showHidden, depth, colors*/
function inspect(obj, opts) {
// default options
var ctx = {
seen: [],
stylize: stylizeNoColor
};
// legacy...
if (arguments.length >= 3) ctx.depth = arguments[2];
if (arguments.length >= 4) ctx.colors = arguments[3];
if (isBoolean(opts)) {
// legacy...
ctx.showHidden = opts;
} else if (opts) {
// got an "options" object
exports._extend(ctx, opts);
}
// set default options
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
if (isUndefined(ctx.depth)) ctx.depth = 2;
if (isUndefined(ctx.colors)) ctx.colors = false;
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
if (ctx.colors) ctx.stylize = stylizeWithColor;
return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
inspect.colors = {
'bold' : [1, 22],
'italic' : [3, 23],
'underline' : [4, 24],
'inverse' : [7, 27],
'white' : [37, 39],
'grey' : [90, 39],
'black' : [30, 39],
'blue' : [34, 39],
'cyan' : [36, 39],
'green' : [32, 39],
'magenta' : [35, 39],
'red' : [31, 39],
'yellow' : [33, 39]
};
// Don't use 'blue' not visible on cmd.exe
inspect.styles = {
'special': 'cyan',
'number': 'yellow',
'boolean': 'yellow',
'undefined': 'grey',
'null': 'bold',
'string': 'green',
'date': 'magenta',
// "name": intentionally not styling
'regexp': 'red'
};
function stylizeWithColor(str, styleType) {
var style = inspect.styles[styleType];
if (style) {
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
'\u001b[' + inspect.colors[style][1] + 'm';
} else {
return str;
}
}
function stylizeNoColor(str, styleType) {
return str;
}
function arrayToHash(array) {
var hash = {};
array.forEach(function(val, idx) {
hash[val] = true;
});
return hash;
}
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 &&
isFunction(value.inspect) &&
// Filter out the util module, it's inspect function is special
value.inspect !== exports.inspect &&
// Also filter out any prototype objects using the circular check.
!(value.constructor && value.constructor.prototype === value)) {
var ret = value.inspect(recurseTimes, ctx);
if (!isString(ret)) {
ret = formatValue(ctx, ret, recurseTimes);
}
return ret;
}
// Primitive types cannot have properties
var primitive = formatPrimitive(ctx, value);
if (primitive) {
return primitive;
}
// Look up the keys of the object.
var keys = Object.keys(value);
var visibleKeys = arrayToHash(keys);
if (ctx.showHidden) {
keys = Object.getOwnPropertyNames(value);
}
// IE doesn't make error fields non-enumerable
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
if (isError(value)
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
return formatError(value);
}
// Some type of object without properties can be shortcutted.
if (keys.length === 0) {
if (isFunction(value)) {
var name = value.name ? ': ' + value.name : '';
return ctx.stylize('[Function' + name + ']', 'special');
}
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
}
if (isDate(value)) {
return ctx.stylize(Date.prototype.toString.call(value), 'date');
}
if (isError(value)) {
return formatError(value);
}
}
var base = '', array = false, braces = ['{', '}'];
// Make Array say that they are Array
if (isArray(value)) {
array = true;
braces = ['[', ']'];
}
// Make functions say that they are functions
if (isFunction(value)) {
var n = value.name ? ': ' + value.name : '';
base = ' [Function' + n + ']';
}
// Make RegExps say that they are RegExps
if (isRegExp(value)) {
base = ' ' + RegExp.prototype.toString.call(value);
}
// Make dates with properties first say the date
if (isDate(value)) {
base = ' ' + Date.prototype.toUTCString.call(value);
}
// Make error with message first say the error
if (isError(value)) {
base = ' ' + formatError(value);
}
if (keys.length === 0 && (!array || value.length == 0)) {
return braces[0] + base + braces[1];
}
if (recurseTimes < 0) {
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
} else {
return ctx.stylize('[Object]', 'special');
}
}
ctx.seen.push(value);
var output;
if (array) {
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
} else {
output = keys.map(function(key) {
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
});
}
ctx.seen.pop();
return reduceToSingleString(output, base, braces);
}
function formatPrimitive(ctx, value) {
if (isUndefined(value))
return ctx.stylize('undefined', 'undefined');
if (isString(value)) {
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
.replace(/'/g, "\\'")
.replace(/\\"/g, '"') + '\'';
return ctx.stylize(simple, 'string');
}
if (isNumber(value))
return ctx.stylize('' + value, 'number');
if (isBoolean(value))
return ctx.stylize('' + value, 'boolean');
// For some reason typeof null is "object", so special case here.
if (isNull(value))
return ctx.stylize('null', 'null');
}
function formatError(value) {
return '[' + Error.prototype.toString.call(value) + ']';
}
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
var output = [];
for (var i = 0, l = value.length; i < l; ++i) {
if (hasOwnProperty(value, String(i))) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
String(i), true));
} else {
output.push('');
}
}
keys.forEach(function(key) {
if (!key.match(/^\d+$/)) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
key, true));
}
});
return output;
}
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) {
str = ctx.stylize('[Getter/Setter]', 'special');
} else {
str = ctx.stylize('[Getter]', 'special');
}
} else {
if (desc.set) {
str = ctx.stylize('[Setter]', 'special');
}
}
if (!hasOwnProperty(visibleKeys, key)) {
name = '[' + key + ']';
}
if (!str) {
if (ctx.seen.indexOf(desc.value) < 0) {
if (isNull(recurseTimes)) {
str = formatValue(ctx, desc.value, null);
} else {
str = formatValue(ctx, desc.value, recurseTimes - 1);
}
if (str.indexOf('\n') > -1) {
if (array) {
str = str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n').substr(2);
} else {
str = '\n' + str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n');
}
}
} else {
str = ctx.stylize('[Circular]', 'special');
}
}
if (isUndefined(name)) {
if (array && key.match(/^\d+$/)) {
return str;
}
name = JSON.stringify('' + key);
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
name = name.substr(1, name.length - 2);
name = ctx.stylize(name, 'name');
} else {
name = name.replace(/'/g, "\\'")
.replace(/\\"/g, '"')
.replace(/(^"|"$)/g, "'");
name = ctx.stylize(name, 'string');
}
}
return name + ': ' + str;
}
function reduceToSingleString(output, base, braces) {
var numLinesEst = 0;
var length = output.reduce(function(prev, cur) {
numLinesEst++;
if (cur.indexOf('\n') >= 0) numLinesEst++;
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
}, 0);
if (length > 60) {
return braces[0] +
(base === '' ? '' : base + '\n ') +
' ' +
output.join(',\n ') +
' ' +
braces[1];
}
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
}
// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
return Array.isArray(ar);
}
exports.isArray = isArray;
function isBoolean(arg) {
return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === 'number';
}
exports.isNumber = isNumber;
function isString(arg) {
return typeof arg === 'string';
}
exports.isString = isString;
function isSymbol(arg) {
return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
exports.isDate = isDate;
function isError(e) {
return isObject(e) &&
(objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;
function isFunction(arg) {
return typeof arg === 'function';
}
exports.isFunction = isFunction;
function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' || // ES6 symbol
typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;
exports.isBuffer = require('./support/isBuffer');
function objectToString(o) {
return Object.prototype.toString.call(o);
}
function pad(n) {
return n < 10 ? '0' + n.toString(10) : n.toString(10);
}
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
'Oct', 'Nov', 'Dec'];
// 26 Feb 16:19:34
function timestamp() {
var d = new Date();
var time = [pad(d.getHours()),
pad(d.getMinutes()),
pad(d.getSeconds())].join(':');
return [d.getDate(), months[d.getMonth()], time].join(' ');
}
// log is just a thin wrapper to console.log that prepends a timestamp
exports.log = function() {
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
};
/**
* Inherit the prototype methods from one constructor into another.
*
* The Function.prototype.inherits from lang.js rewritten as a standalone
* function (not on Function.prototype). NOTE: If this file is to be loaded
* during bootstrapping this function needs to be rewritten using some native
* functions as prototype setup using normal JavaScript does not work as
* expected during bootstrapping (see mirror.js in r114903).
*
* @param {function} ctor Constructor function which needs to inherit the
* prototype.
* @param {function} superCtor Constructor function to inherit prototype from.
*/
exports.inherits = require('inherits');
exports._extend = function(origin, add) {
// Don't do anything if add isn't an object
if (!add || !isObject(add)) return origin;
var keys = Object.keys(add);
var i = keys.length;
while (i--) {
origin[keys[i]] = add[keys[i]];
}
return origin;
};
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./support/isBuffer":67,"_process":66,"inherits":65}],"bitcoinjs-lib":[function(require,module,exports){
(function (Buffer){
module.exports = {
Address: require('./address'),
BigInteger: require('bigi'),
Buffer: Buffer,
base58check: require('bs58check'),
bufferutils: require('./bufferutils'),
crypto: require('./crypto'),
ecdsa: require('./ecdsa'),
ECKey: require('./eckey'),
ECPubKey: require('./ecpubkey'),
ECSignature: require('./ecsignature'),
Message: require('./message'),
opcodes: require('./opcodes'),
HDNode: require('./hdnode'),
Script: require('./script'),
scripts: require('./scripts'),
Transaction: require('./transaction'),
TransactionBuilder: require('./transaction_builder'),
networks: require('./networks'),
Wallet: require('./wallet')
}
}).call(this,require("buffer").Buffer)
},{"./address":27,"./bufferutils":28,"./crypto":29,"./ecdsa":30,"./eckey":31,"./ecpubkey":32,"./ecsignature":33,"./hdnode":34,"./message":35,"./networks":36,"./opcodes":37,"./script":38,"./scripts":39,"./transaction":40,"./transaction_builder":41,"./wallet":43,"bigi":3,"bs58check":6,"buffer":46}]},{},[])("bitcoinjs-lib")
});