+
@@ -38,8 +39,17 @@
+
+
+
@@ -61,7 +71,19 @@
+
+
@@ -38,8 +39,17 @@
+
+ {{$root.flashMessage.type}}:
+ {{$root.flashMessage.message}}
+ Dismiss
+
+
+
-
+ Join wallet
+Open a Existing Wallet
+ +
+
+
+ +
+
+
Join a Network Wallet
@@ -71,7 +93,7 @@
+
+
+
@@ -185,19 +244,19 @@
-
Create a new wallet
+Create a New Wallet
@@ -108,54 +130,91 @@
{{title}}
-
+
-1;
+};
+
+CopayPeer._arrayPushOnce = function(el, array) {
+ var ret = false;
+ if (!CopayPeer._inArray(el, array)) {
+ array.push(el);
+ ret = true;
+ }
+ return ret;
+};
+
+CopayPeer._arrayRemove = function(el, array) {
+ var pos = array.indexOf(el);
+ if (pos >= 0) array.splice(pos, 1);
+
+ return array;
+};
+
+// DEBUG
+CopayPeer.prototype._showConnectedPeers = function() {
+ console.log("### CONNECTED PEERS", this.connectedPeers);
+};
+
+CopayPeer.prototype._onClose = function(peerId) {
+ this.connectedPeers = CopayPeer._arrayRemove(peerId, this.connectedPeers);
+ this._notify();
+};
+
+CopayPeer.prototype._connectToPeers = function(peerIds) {
+ var self = this;
+ var ret = false;
+ var arrayDiff1= CopayPeer._arrayDiff(peerIds, this.connectedPeers);
+ var arrayDiff = CopayPeer._arrayDiff(arrayDiff1, [this.peerId]);
+ arrayDiff.forEach(function(peerId) {
+ console.log('### CONNECTING TO:', peerId);
+ self.connectTo(peerId);
+ ret = true;
+ });
+ return ret;
+};
+
+CopayPeer.prototype._onData = function(data, isInbound) {
+ var obj;
+ try {
+ obj = JSON.parse(data);
+ } catch (e) {
+ console.log('### ERROR ON DATA: "%s" ', data, isInbound, e);
+ return;
+ };
+ console.log('### RECEIVED TYPE: %s FROM %s', obj.data.type, obj.sender);
+
+ switch(obj.data.type) {
+ case 'peerList':
+ this._connectToPeers(obj.data.peers);
+ this._notify();
+ break;
+ case 'disconnect':
+ this._onClose(obj.sender);
+ break;
+ default:
+ this.emit('data', obj.sender, obj.data, isInbound);
+ }
+};
+
+CopayPeer.prototype._sendPeers = function(peerIds) {
+ console.log('#### SENDING PEER LIST: ', this.connectedPeers, ' TO ', peerIds?peerIds: 'ALL');
+ this.send(peerIds, {
+ type: 'peerList',
+ peers: this.connectedPeers,
+ });
+};
+
+CopayPeer.prototype._addPeer = function(peerId, isInbound) {
+
+ var hasChanged = CopayPeer._arrayPushOnce(peerId, this.connectedPeers);
+
+
+ if (isInbound && hasChanged) {
+ this._sendPeers(); //broadcast peer list
+ }
+ else {
+ if (isInbound) {
+ this._sendPeers(peerId);
+ }
+ }
+};
+
+CopayPeer.prototype._setupConnectionHandlers = function(
+ dataConn, isInbound, openCallback, closeCallback) {
+
+ var self=this;
+
+ dataConn.on('open', function() {
+ if (!CopayPeer._inArray(dataConn.peer, self.connectedPeers)) {
+
+ console.log('### DATA CONNECTION READY TO: ADDING PEER: %s (inbound: %s)',
+ dataConn.peer, isInbound);
+
+ self._addPeer(dataConn.peer, isInbound);
+ self._notify( isInbound ? dataConn.peer : null);
+ if (typeof openCallback === 'function') openCallback();
+ }
+ });
+
+ dataConn.on('data', function(data) {
+ self._onData(data, isInbound);
+ });
+
+ dataConn.on('error', function(e) {
+ console.log('### DATA ERROR',e ); //TODO
+ });
+
+ dataConn.on('close', function() {
+ console.log('### CLOSE RECV FROM:', dataConn.peer); //TODO
+ self._onClose(dataConn.peer);
+ if (typeof closeCallback === 'function') closeCallback();
+ });
+};
+
+CopayPeer.prototype._notify = function(newPeer) {
+ this._showConnectedPeers();
+ this.emit('networkChange', newPeer);
+};
+
+CopayPeer.prototype._setupPeerHandlers = function(openCallback) {
+ var self=this;
+ var p = this.peer;
+
+
+ p.on('open', function(peerId) {
+ console.log('### PEER OPEN. I AM:' + peerId);
+ self.peerId = peerId;
+ self.connectedPeers = [peerId];
+ self._notify();
+ return openCallback(peerId);
+ });
+
+ p.on('error', function(err) {
+ console.log('### PEER ERROR:', err);
+ });
+
+ p.on('connection', function(dataConn) {
+
+ console.log('### NEW INBOUND CONNECTION %d/%d', self.connectedPeers.length, self.maxPeers);
+ if (self.connectedPeers.length >= self.maxPeers) {
+ console.log('### PEER REJECTED. PEER MAX LIMIT REACHED');
+ dataConn.on('open', function() {
+ console.log('### CLOSING CONN FROM:' + dataConn.peer);
+ dataConn.close();
+ });
+ }
+ else {
+ self._setupConnectionHandlers(dataConn, true);
+ }
+ });
+};
+
+CopayPeer.prototype.start = function(openCallback) {
+ // Start PeerJS Peer
+ this.peer = new Peer(this.peerId, {
+ key: this.apiKey, // TODO: we need our own PeerServer KEY (http://peerjs.com/peerserver)
+ debug: this.debug,
+ });
+
+ this._setupPeerHandlers(openCallback);
+};
+
+CopayPeer.prototype._sendToOne = function(peerId, data, cb) {
+ if (peerId !== this.peerId) {
+ var conns = this.peer.connections[peerId];
+
+ if (conns) {
+ var str = JSON.stringify({
+ sender: this.peerId,
+ data: data
+ });
+
+ for (var i = 0; i < conns.length; i++) {
+ var conn = conns[i];
+ conn.send(str);
+ }
+ }
+ }
+ if (typeof cb === 'function') cb();
+};
+
+CopayPeer.prototype.send = function(peerIds, data, cb) {
+ var self=this;
+
+ if (!peerIds) {
+ peerIds = this.connectedPeers;
+ data.isBroadcast = 1;
+ }
+console.log('[CopayPeer.js.216:SENDD:]',data); //TODO
+
+ if (Array.isArray(peerIds)) {
+ var l = peerIds.length;
+ var i = 0;
+ peerIds.forEach(function(peerId) {
+ self._sendToOne(peerId, data, function () {
+ if (++i === l && typeof cb === 'function') cb();
+ });
+ });
+ }
+ else if (typeof peerIds === 'string')
+ self._sendToOne(peerIds, data, cb);
+};
+
+CopayPeer.prototype.connectTo = function(peerId, openCallback, closeCallback ) {
+ var self = this;
+
+ console.log('### STARTING TO CONNECT TO:' + peerId );
+
+ var dataConn = this.peer.connect(peerId, {
+// label: 'wallet',
+ serialization: 'none',
+ reliable: true,
+ metadata: { message: 'hi copayer!' }
+ });
+
+ self._setupConnectionHandlers(dataConn, false, openCallback, closeCallback);
+};
+
+CopayPeer.prototype.disconnect = function(peerId, cb) {
+ var self = this;
+
+ this.send(null, { type: 'disconnect' }, function() {
+ self.connectedPeers = [];
+ self.peerId = null;
+ if (self.peer) {
+ self.peer.disconnect();
+ self.peer.destroy();
+ self.peer = null;
+ }
+ if (typeof cb === 'function') cb();
+ });
+};
+
+module.exports = require('soop')(CopayPeer);
+
+},{"events":12,"soop":16}],4:[function(require,module,exports){
+
+'use strict';
+
+
+var imports = require('soop').imports();
+var bitcore = require('bitcore');
+var BIP32 = bitcore.BIP32;
+var Address = bitcore.Address;
+var Script = bitcore.Script;
+var coinUtil = bitcore.util;
+var Transaction = bitcore.Transaction;
+var buffertools = bitcore.buffertools;
+
+var Storage = imports.Storage || require('./Storage');
+var storage = Storage.default();
+
+/*
+ * This follow Electrum convetion, as described in
+ * https://bitcointalk.org/index.php?topic=274182.0
+ *
+ * We should probably adopt the next standard once it's ready, as discussed in:
+ * http://sourceforge.net/p/bitcoin/mailman/message/32148600/
+ *
+ */
+
+var PUBLIC_BRANCH = 'm/0/';
+var CHANGE_BRANCH = 'm/1/';
+
+function PublicKeyRing(opts) {
+ opts = opts || {};
+
+ this.network = opts.networkName === 'livenet' ?
+ bitcore.networks.livenet : bitcore.networks.testnet;
+
+ this.requiredCopayers = opts.requiredCopayers || 3;
+ this.totalCopayers = opts.totalCopayers || 5;
+
+ this.id = opts.id || PublicKeyRing.getRandomId();
+
+ this.dirty = 1;
+ this.copayersBIP32 = [];
+
+ this.changeAddressIndex=0;
+ this.addressIndex=0;
+}
+
+
+PublicKeyRing.getRandomId = function () {
+ return buffertools.toHex(coinUtil.generateNonce());
+};
+
+PublicKeyRing.decrypt = function (passphrase, encPayload) {
+ console.log('[wallet.js.35] TODO READ: passphrase IGNORED');
+ return encPayload;
+};
+
+PublicKeyRing.encrypt = function (passphrase, payload) {
+ console.log('[wallet.js.92] TODO: passphrase IGNORED');
+ return payload;
+};
+
+PublicKeyRing.fromObj = function (data) {
+ var config = { networkName: data.networkName || 'livenet' };
+
+ var w = new PublicKeyRing(config);
+
+ w.requiredCopayers = data.requiredCopayers;
+ w.totalCopayers = data.totalCopayers;
+ w.addressIndex = data.addressIndex;
+ w.changeAddressIndex = data.changeAddressIndex;
+
+// this.bip32 = ;
+ w.copayersBIP32 = data.copayersExtPubKeys.map( function (pk) {
+ return new BIP32(pk);
+ });
+
+ w.dirty = 0;
+
+ return w;
+};
+
+PublicKeyRing.read = function (id, passphrase) {
+ var encPayload = storage.get(id);
+ if (!encPayload)
+ throw new Error('Could not find wallet data');
+ var data;
+ try {
+ data = JSON.parse( PublicKeyRing.decrypt( passphrase, encPayload ));
+ } catch (e) {
+ throw new Error('error in storage: '+ e.toString());
+ return;
+ };
+
+ if (data.id !== id)
+ throw new Error('Wrong id in data');
+
+
+ return PublicKeyRing.fromObj(data);
+};
+
+PublicKeyRing.prototype.toObj = function() {
+ return {
+ id: this.id,
+ networkName: this.network.name,
+ requiredCopayers: this.requiredCopayers,
+ totalCopayers: this.totalCopayers,
+
+ changeAddressIndex: this.changeAddressIndex,
+ addressIndex: this.addressIndex,
+ copayersExtPubKeys: this.copayersBIP32.map( function (b) {
+ return b.extendedPublicKeyString();
+ }),
+ ts: parseInt(Date.now() / 1000),
+ };
+};
+
+PublicKeyRing.prototype.serialize = function () {
+ return JSON.stringify(this.toObj());
+};
+
+
+PublicKeyRing.prototype.store = function (passphrase) {
+
+ if (!this.id)
+ throw new Error('wallet has no id');
+
+ storage.set(this.id, PublicKeyRing.encrypt(passphrase,this.serialize()));
+ this.dirty = 0;
+
+ return true;
+};
+
+PublicKeyRing.prototype.registeredCopayers = function () {
+ return this.copayersBIP32.length;
+};
+
+
+
+PublicKeyRing.prototype.haveAllRequiredPubKeys = function () {
+ return this.registeredCopayers() >= this.totalCopayers;
+};
+
+PublicKeyRing.prototype._checkKeys = function() {
+
+ if (!this.haveAllRequiredPubKeys())
+ throw new Error('dont have required keys yet');
+};
+
+
+PublicKeyRing.prototype._newExtendedPublicKey = function () {
+ return new BIP32(this.network.name)
+ .extendedPublicKeyString();
+};
+
+PublicKeyRing.prototype.addCopayer = function (newEpk) {
+
+ if (this.haveAllRequiredPubKeys())
+ throw new Error('already have all required key:' + this.totalCopayers);
+
+ if (!newEpk) {
+ newEpk = this._newExtendedPublicKey();
+ }
+
+ this.copayersBIP32.forEach(function(b){
+ if (b.extendedPublicKeyString() === newEpk)
+ throw new Error('already have that key');
+ });
+
+ this.copayersBIP32.push(new BIP32(newEpk));
+ this.dirty = 1;
+ return newEpk;
+};
+
+
+PublicKeyRing.prototype.getCopayersPubKeys = function (index, isChange) {
+ this._checkKeys();
+
+ var pubKeys = [];
+ var l = this.copayersBIP32.length;
+ for(var i=0; i this.changeAddressIndex) ||
+ (!isChange && index > this.addressIndex)) {
+ console.log('Out of bounds at getAddress: Index %d isChange: %d', index, isChange);
+ throw new Error('index out of bound');
+ }
+};
+
+PublicKeyRing.prototype.getRedeemScript = function (index, isChange) {
+ this._checkIndexRange(index, isChange);
+
+ var pubKeys = this.getCopayersPubKeys(index, isChange);
+ var script = Script.createMultisig(this.requiredCopayers, pubKeys);
+ return script;
+};
+
+PublicKeyRing.prototype.getAddress = function (index, isChange) {
+ this._checkIndexRange(index, isChange);
+
+ var script = this.getRedeemScript(index,isChange);
+ var hash = coinUtil.sha256ripe160(script.getBuffer());
+ var version = this.network.addressScript;
+ var addr = new Address(version, hash);
+ return addr.as('base58');
+};
+
+//generate a new address, update index.
+PublicKeyRing.prototype.generateAddress = function(isChange) {
+
+ var ret =
+ this.getAddress(isChange ? this.changeAddressIndex : this.addressIndex, isChange);
+ if (isChange)
+ this.changeAddressIndex++;
+ else
+ this.addressIndex++;
+
+ return ret;
+
+};
+
+PublicKeyRing.prototype.getAddresses = function() {
+ var ret = [];
+
+ for (var i=0; i this.changeAddressIndex) {
+ this.changeAddressIndex = inPKR.changeAddressIndex;
+ hasChanged = true;
+ }
+
+ if (inPKR.addressIndex > this.addressIndex) {
+ this.addressIndex = inPKR.addressIndex;
+ hasChanged = true;
+ }
+ return hasChanged;
+};
+
+PublicKeyRing.prototype._mergePubkeys = function(inPKR) {
+ var hasChanged = false;
+ var l= this.copayersBIP32.length;
+
+ var self = this;
+
+ inPKR.copayersExtPubKeys.forEach( function(epk) {
+ var haveIt = false;
+ for(var j=0; j
+ * License: MIT
+ *
+ * `npm install buffer`
+ */
+
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = Buffer
+exports.INSPECT_MAX_BYTES = 50
+Buffer.poolSize = 8192
+
+/**
+ * If `Buffer._useTypedArrays`:
+ * === true Use Uint8Array implementation (fastest)
+ * === false Use Object implementation (compatible down to IE6)
+ */
+Buffer._useTypedArrays = (function () {
+ // Detect if browser supports Typed Arrays. Supported browsers are IE 10+, Firefox 4+,
+ // Chrome 7+, Safari 5.1+, Opera 11.6+, iOS 4.2+. If the browser does not support adding
+ // properties to `Uint8Array` instances, then that's the same as no `Uint8Array` support
+ // because we need to be able to add all the node Buffer API methods. This is an issue
+ // in Firefox 4-29. Now fixed: https://bugzilla.mozilla.org/show_bug.cgi?id=695438
+ try {
+ var buf = new ArrayBuffer(0)
+ var arr = new Uint8Array(buf)
+ arr.foo = function () { return 42 }
+ return 42 === arr.foo() &&
+ typeof arr.subarray === 'function' // Chrome 9-10 lack `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
+
+ // Workaround: node's base64 implementation allows for non-padded strings
+ // while base64-js does not.
+ if (encoding === 'base64' && type === 'string') {
+ subject = stringtrim(subject)
+ while (subject.length % 4 !== 0) {
+ subject = subject + '='
+ }
+ }
+
+ // Find the length
+ var length
+ if (type === 'number')
+ length = coerce(subject)
+ else if (type === 'string')
+ length = Buffer.byteLength(subject, encoding)
+ else if (type === 'object')
+ length = coerce(subject.length) // assume that object is array-like
+ else
+ throw new Error('First argument needs to be a number, array or string.')
+
+ var buf
+ if (Buffer._useTypedArrays) {
+ // 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._useTypedArrays && 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
+ for (i = 0; i < length; i++) {
+ if (Buffer.isBuffer(subject))
+ buf[i] = subject.readUInt8(i)
+ else
+ buf[i] = subject[i]
+ }
+ } else if (type === 'string') {
+ buf.write(subject, 0, encoding)
+ } else if (type === 'number' && !Buffer._useTypedArrays && !noZero) {
+ for (i = 0; i < length; i++) {
+ buf[i] = 0
+ }
+ }
+
+ return buf
+}
+
+// STATIC METHODS
+// ==============
+
+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.isBuffer = function (b) {
+ return !!(b !== null && b !== undefined && b._isBuffer)
+}
+
+Buffer.byteLength = function (str, encoding) {
+ var ret
+ str = str + ''
+ switch (encoding || 'utf8') {
+ case 'hex':
+ ret = str.length / 2
+ break
+ case 'utf8':
+ case 'utf-8':
+ ret = utf8ToBytes(str).length
+ break
+ case 'ascii':
+ case 'binary':
+ case 'raw':
+ ret = str.length
+ break
+ case 'base64':
+ ret = base64ToBytes(str).length
+ break
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ ret = str.length * 2
+ break
+ default:
+ throw new Error('Unknown encoding')
+ }
+ return ret
+}
+
+Buffer.concat = function (list, totalLength) {
+ assert(isArray(list), 'Usage: Buffer.concat(list, [totalLength])\n' +
+ 'list should be an Array.')
+
+ if (list.length === 0) {
+ return new Buffer(0)
+ } else if (list.length === 1) {
+ return list[0]
+ }
+
+ var i
+ if (typeof totalLength !== 'number') {
+ 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 INSTANCE METHODS
+// =======================
+
+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
+ assert(strLen % 2 === 0, '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)
+ assert(!isNaN(byte), 'Invalid hex string')
+ buf[offset + i] = byte
+ }
+ Buffer._charsWritten = i * 2
+ return i
+}
+
+function _utf8Write (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(utf8ToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _asciiWrite (buf, string, offset, length) {
+ var charsWritten = Buffer._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 = Buffer._charsWritten =
+ blitBuffer(base64ToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _utf16leWrite (buf, string, offset, length) {
+ var charsWritten = Buffer._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 Error('Unknown encoding')
+ }
+ return ret
+}
+
+Buffer.prototype.toString = function (encoding, start, end) {
+ var self = this
+
+ encoding = String(encoding || 'utf8').toLowerCase()
+ start = Number(start) || 0
+ end = (end !== undefined)
+ ? Number(end)
+ : end = self.length
+
+ // Fastpath empty strings
+ if (end === start)
+ return ''
+
+ var ret
+ switch (encoding) {
+ case 'hex':
+ ret = _hexSlice(self, start, end)
+ break
+ case 'utf8':
+ case 'utf-8':
+ ret = _utf8Slice(self, start, end)
+ break
+ case 'ascii':
+ ret = _asciiSlice(self, start, end)
+ break
+ case 'binary':
+ ret = _binarySlice(self, start, end)
+ break
+ case 'base64':
+ ret = _base64Slice(self, start, end)
+ break
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ ret = _utf16leSlice(self, start, end)
+ break
+ default:
+ throw new Error('Unknown encoding')
+ }
+ return ret
+}
+
+Buffer.prototype.toJSON = function () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
+
+// 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
+ assert(end >= start, 'sourceEnd < sourceStart')
+ assert(target_start >= 0 && target_start < target.length,
+ 'targetStart out of bounds')
+ assert(start >= 0 && start < source.length, 'sourceStart out of bounds')
+ assert(end >= 0 && end <= source.length, '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._useTypedArrays) {
+ for (var i = 0; i < len; i++)
+ target[i + target_start] = this[i + start]
+ } else {
+ target._set(this.subarray(start, start + len), target_start)
+ }
+}
+
+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 = clamp(start, len, 0)
+ end = clamp(end, len, len)
+
+ if (Buffer._useTypedArrays) {
+ 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
+ }
+}
+
+// `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)
+}
+
+Buffer.prototype.readUInt8 = function (offset, noAssert) {
+ if (!noAssert) {
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'Trying to read beyond buffer length')
+ }
+
+ if (offset >= this.length)
+ return
+
+ return this[offset]
+}
+
+function _readUInt16 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val
+ if (littleEndian) {
+ val = buf[offset]
+ if (offset + 1 < len)
+ val |= buf[offset + 1] << 8
+ } else {
+ val = buf[offset] << 8
+ if (offset + 1 < len)
+ val |= buf[offset + 1]
+ }
+ return val
+}
+
+Buffer.prototype.readUInt16LE = function (offset, noAssert) {
+ return _readUInt16(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readUInt16BE = function (offset, noAssert) {
+ return _readUInt16(this, offset, false, noAssert)
+}
+
+function _readUInt32 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val
+ if (littleEndian) {
+ if (offset + 2 < len)
+ val = buf[offset + 2] << 16
+ if (offset + 1 < len)
+ val |= buf[offset + 1] << 8
+ val |= buf[offset]
+ if (offset + 3 < len)
+ val = val + (buf[offset + 3] << 24 >>> 0)
+ } else {
+ if (offset + 1 < len)
+ val = buf[offset + 1] << 16
+ if (offset + 2 < len)
+ val |= buf[offset + 2] << 8
+ if (offset + 3 < len)
+ val |= buf[offset + 3]
+ val = val + (buf[offset] << 24 >>> 0)
+ }
+ return val
+}
+
+Buffer.prototype.readUInt32LE = function (offset, noAssert) {
+ return _readUInt32(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readUInt32BE = function (offset, noAssert) {
+ return _readUInt32(this, offset, false, noAssert)
+}
+
+Buffer.prototype.readInt8 = function (offset, noAssert) {
+ if (!noAssert) {
+ assert(offset !== undefined && offset !== null,
+ 'missing offset')
+ assert(offset < this.length, 'Trying to read beyond buffer length')
+ }
+
+ if (offset >= this.length)
+ return
+
+ var neg = this[offset] & 0x80
+ if (neg)
+ return (0xff - this[offset] + 1) * -1
+ else
+ return this[offset]
+}
+
+function _readInt16 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val = _readUInt16(buf, offset, littleEndian, true)
+ var neg = val & 0x8000
+ if (neg)
+ return (0xffff - val + 1) * -1
+ else
+ return val
+}
+
+Buffer.prototype.readInt16LE = function (offset, noAssert) {
+ return _readInt16(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readInt16BE = function (offset, noAssert) {
+ return _readInt16(this, offset, false, noAssert)
+}
+
+function _readInt32 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val = _readUInt32(buf, offset, littleEndian, true)
+ var neg = val & 0x80000000
+ if (neg)
+ return (0xffffffff - val + 1) * -1
+ else
+ return val
+}
+
+Buffer.prototype.readInt32LE = function (offset, noAssert) {
+ return _readInt32(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readInt32BE = function (offset, noAssert) {
+ return _readInt32(this, offset, false, noAssert)
+}
+
+function _readFloat (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ return ieee754.read(buf, offset, littleEndian, 23, 4)
+}
+
+Buffer.prototype.readFloatLE = function (offset, noAssert) {
+ return _readFloat(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readFloatBE = function (offset, noAssert) {
+ return _readFloat(this, offset, false, noAssert)
+}
+
+function _readDouble (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset + 7 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ return ieee754.read(buf, offset, littleEndian, 52, 8)
+}
+
+Buffer.prototype.readDoubleLE = function (offset, noAssert) {
+ return _readDouble(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readDoubleBE = function (offset, noAssert) {
+ return _readDouble(this, offset, false, noAssert)
+}
+
+Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xff)
+ }
+
+ if (offset >= this.length) return
+
+ this[offset] = value
+}
+
+function _writeUInt16 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xffff)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ for (var i = 0, j = Math.min(len - 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) {
+ _writeUInt16(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
+ _writeUInt16(this, value, offset, false, noAssert)
+}
+
+function _writeUInt32 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xffffffff)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) {
+ buf[offset + i] =
+ (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+ }
+}
+
+Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
+ _writeUInt32(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
+ _writeUInt32(this, value, offset, false, noAssert)
+}
+
+Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7f, -0x80)
+ }
+
+ if (offset >= this.length)
+ return
+
+ if (value >= 0)
+ this.writeUInt8(value, offset, noAssert)
+ else
+ this.writeUInt8(0xff + value + 1, offset, noAssert)
+}
+
+function _writeInt16 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7fff, -0x8000)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ if (value >= 0)
+ _writeUInt16(buf, value, offset, littleEndian, noAssert)
+ else
+ _writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert)
+}
+
+Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
+ _writeInt16(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
+ _writeInt16(this, value, offset, false, noAssert)
+}
+
+function _writeInt32 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7fffffff, -0x80000000)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ if (value >= 0)
+ _writeUInt32(buf, value, offset, littleEndian, noAssert)
+ else
+ _writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert)
+}
+
+Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
+ _writeInt32(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
+ _writeInt32(this, value, offset, false, noAssert)
+}
+
+function _writeFloat (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
+ verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+}
+
+Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
+ _writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
+ _writeFloat(this, value, offset, false, noAssert)
+}
+
+function _writeDouble (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 7 < buf.length,
+ 'Trying to write beyond buffer length')
+ verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+}
+
+Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
+ _writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
+ _writeDouble(this, value, offset, false, noAssert)
+}
+
+// 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 (typeof value === 'string') {
+ value = value.charCodeAt(0)
+ }
+
+ assert(typeof value === 'number' && !isNaN(value), 'value is not a number')
+ assert(end >= start, 'end < start')
+
+ // Fill 0 bytes; we're done
+ if (end === start) return
+ if (this.length === 0) return
+
+ assert(start >= 0 && start < this.length, 'start out of bounds')
+ assert(end >= 0 && end <= this.length, 'end out of bounds')
+
+ for (var i = start; i < end; i++) {
+ this[i] = value
+ }
+}
+
+Buffer.prototype.inspect = function () {
+ var out = []
+ var len = this.length
+ for (var i = 0; i < len; i++) {
+ out[i] = toHex(this[i])
+ if (i === exports.INSPECT_MAX_BYTES) {
+ out[i + 1] = '...'
+ break
+ }
+ }
+ return ''
+}
+
+/**
+ * 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._useTypedArrays) {
+ 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 Error('Buffer.toArrayBuffer not supported in this browser')
+ }
+}
+
+// HELPER FUNCTIONS
+// ================
+
+function stringtrim (str) {
+ if (str.trim) return str.trim()
+ return str.replace(/^\s+|\s+$/g, '')
+}
+
+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.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
+}
+
+// slice(start, end)
+function clamp (index, len, defaultValue) {
+ if (typeof index !== 'number') return defaultValue
+ index = ~~index; // Coerce to integer.
+ if (index >= len) return len
+ if (index >= 0) return index
+ index += len
+ if (index >= 0) return index
+ return 0
+}
+
+function coerce (length) {
+ // Coerce length to a number (possibly NaN), round up
+ // in case it's fractional (e.g. 123.456) then do a
+ // double negate to coerce a NaN to 0. Easy, right?
+ length = ~~Math.ceil(+length)
+ return length < 0 ? 0 : length
+}
+
+function isArray (subject) {
+ return (Array.isArray || function (subject) {
+ return Object.prototype.toString.call(subject) === '[object Array]'
+ })(subject)
+}
+
+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(str.charCodeAt(i))
+ 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) {
+ var pos
+ 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
+ }
+}
+
+/*
+ * We have to make sure that the value is a valid integer. This means that it
+ * is non-negative. It has no fractional component and that it does not
+ * exceed the maximum allowed value.
+ */
+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 verifsint (value, max, min) {
+ assert(typeof value === 'number', 'cannot write a non-number as a number')
+ assert(value <= max, 'value larger than maximum allowed value')
+ assert(value >= min, 'value smaller than minimum allowed value')
+ assert(Math.floor(value) === value, 'value has a fractional component')
+}
+
+function verifIEEE754 (value, max, min) {
+ assert(typeof value === 'number', 'cannot write a non-number as a number')
+ assert(value <= max, 'value larger than maximum allowed value')
+ assert(value >= min, 'value smaller than minimum allowed value')
+}
+
+function assert (test, message) {
+ if (!test) throw new Error(message || 'Failed assertion')
+}
+
+},{"base64-js":10,"ieee754":11}],10:[function(require,module,exports){
+var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+;(function (exports) {
+ 'use strict';
+
+ var Arr = (typeof Uint8Array !== 'undefined')
+ ? Uint8Array
+ : Array
+
+ var ZERO = '0'.charCodeAt(0)
+ 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
+ }
+
+ module.exports.toByteArray = b64ToByteArray
+ module.exports.fromByteArray = uint8ToBase64
+}())
+
+},{}],11:[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;
+};
+
+},{}],12:[function(require,module,exports){
+// 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.
+
+function EventEmitter() {
+ this._events = this._events || {};
+ this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+ if (!isNumber(n) || n < 0 || isNaN(n))
+ throw TypeError('n must be a positive number');
+ this._maxListeners = n;
+ return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+ var er, handler, len, args, i, listeners;
+
+ if (!this._events)
+ this._events = {};
+
+ // If there is no 'error' event listener then throw.
+ if (type === 'error') {
+ if (!this._events.error ||
+ (isObject(this._events.error) && !this._events.error.length)) {
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
+ } else {
+ throw TypeError('Uncaught, unspecified "error" event.');
+ }
+ return false;
+ }
+ }
+
+ handler = this._events[type];
+
+ if (isUndefined(handler))
+ return false;
+
+ if (isFunction(handler)) {
+ switch (arguments.length) {
+ // fast cases
+ case 1:
+ handler.call(this);
+ break;
+ case 2:
+ handler.call(this, arguments[1]);
+ break;
+ case 3:
+ handler.call(this, arguments[1], arguments[2]);
+ break;
+ // slower
+ default:
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+ handler.apply(this, args);
+ }
+ } else if (isObject(handler)) {
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+
+ listeners = handler.slice();
+ len = listeners.length;
+ for (i = 0; i < len; i++)
+ listeners[i].apply(this, args);
+ }
+
+ return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+ var m;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events)
+ this._events = {};
+
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (this._events.newListener)
+ this.emit('newListener', type,
+ isFunction(listener.listener) ?
+ listener.listener : listener);
+
+ if (!this._events[type])
+ // Optimize the case of one listener. Don't need the extra array object.
+ this._events[type] = listener;
+ else if (isObject(this._events[type]))
+ // If we've already got an array, just append.
+ this._events[type].push(listener);
+ else
+ // Adding the second element, need to change to array.
+ this._events[type] = [this._events[type], listener];
+
+ // Check for listener leak
+ if (isObject(this._events[type]) && !this._events[type].warned) {
+ var m;
+ if (!isUndefined(this._maxListeners)) {
+ m = this._maxListeners;
+ } else {
+ m = EventEmitter.defaultMaxListeners;
+ }
+
+ if (m && m > 0 && this._events[type].length > m) {
+ this._events[type].warned = true;
+ console.error('(node) warning: possible EventEmitter memory ' +
+ 'leak detected. %d listeners added. ' +
+ 'Use emitter.setMaxListeners() to increase limit.',
+ this._events[type].length);
+ console.trace();
+ }
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ var fired = false;
+
+ function g() {
+ this.removeListener(type, g);
+
+ if (!fired) {
+ fired = true;
+ listener.apply(this, arguments);
+ }
+ }
+
+ g.listener = listener;
+ this.on(type, g);
+
+ return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+ var list, position, length, i;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events || !this._events[type])
+ return this;
+
+ list = this._events[type];
+ length = list.length;
+ position = -1;
+
+ if (list === listener ||
+ (isFunction(list.listener) && list.listener === listener)) {
+ delete this._events[type];
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+
+ } else if (isObject(list)) {
+ for (i = length; i-- > 0;) {
+ if (list[i] === listener ||
+ (list[i].listener && list[i].listener === listener)) {
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (list.length === 1) {
+ list.length = 0;
+ delete this._events[type];
+ } else {
+ list.splice(position, 1);
+ }
+
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+ var key, listeners;
+
+ if (!this._events)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (!this._events.removeListener) {
+ if (arguments.length === 0)
+ this._events = {};
+ else if (this._events[type])
+ delete this._events[type];
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ for (key in this._events) {
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = {};
+ return this;
+ }
+
+ listeners = this._events[type];
+
+ if (isFunction(listeners)) {
+ this.removeListener(type, listeners);
+ } else {
+ // LIFO order
+ while (listeners.length)
+ this.removeListener(type, listeners[listeners.length - 1]);
+ }
+ delete this._events[type];
+
+ return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+ var ret;
+ if (!this._events || !this._events[type])
+ ret = [];
+ else if (isFunction(this._events[type]))
+ ret = [this._events[type]];
+ else
+ ret = this._events[type].slice();
+ return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ var ret;
+ if (!emitter._events || !emitter._events[type])
+ ret = 0;
+ else if (isFunction(emitter._events[type]))
+ ret = 1;
+ else
+ ret = emitter._events[type].length;
+ return ret;
+};
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+
+},{}],13:[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 canPost = typeof window !== 'undefined'
+ && window.postMessage && window.addEventListener
+ ;
+
+ if (canSetImmediate) {
+ return function (f) { return window.setImmediate(f) };
+ }
+
+ if (canPost) {
+ var queue = [];
+ 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 = [];
+
+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');
+};
+
+},{}],14:[function(require,module,exports){
+(function (process){
+// 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.
+
+// resolves . and .. elements in a path array with directory names there
+// must be no slashes, empty elements, or device names (c:\) in the array
+// (so also no leading and trailing slashes - it does not distinguish
+// relative and absolute paths)
+function normalizeArray(parts, allowAboveRoot) {
+ // if the path tries to go above the root, `up` ends up > 0
+ var up = 0;
+ for (var i = parts.length - 1; i >= 0; i--) {
+ var last = parts[i];
+ if (last === '.') {
+ parts.splice(i, 1);
+ } else if (last === '..') {
+ parts.splice(i, 1);
+ up++;
+ } else if (up) {
+ parts.splice(i, 1);
+ up--;
+ }
+ }
+
+ // if the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up--; up) {
+ parts.unshift('..');
+ }
+ }
+
+ return parts;
+}
+
+// Split a filename into [root, dir, basename, ext], unix version
+// 'root' is just a slash, or nothing.
+var splitPathRe =
+ /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+var splitPath = function(filename) {
+ return splitPathRe.exec(filename).slice(1);
+};
+
+// path.resolve([from ...], to)
+// posix version
+exports.resolve = function() {
+ var resolvedPath = '',
+ resolvedAbsolute = false;
+
+ for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = (i >= 0) ? arguments[i] : process.cwd();
+
+ // Skip empty and invalid entries
+ if (typeof path !== 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ continue;
+ }
+
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = path.charAt(0) === '/';
+ }
+
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+
+ // Normalize the path
+ resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
+ return !!p;
+ }), !resolvedAbsolute).join('/');
+
+ return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+};
+
+// path.normalize(path)
+// posix version
+exports.normalize = function(path) {
+ var isAbsolute = exports.isAbsolute(path),
+ trailingSlash = substr(path, -1) === '/';
+
+ // Normalize the path
+ path = normalizeArray(filter(path.split('/'), function(p) {
+ return !!p;
+ }), !isAbsolute).join('/');
+
+ if (!path && !isAbsolute) {
+ path = '.';
+ }
+ if (path && trailingSlash) {
+ path += '/';
+ }
+
+ return (isAbsolute ? '/' : '') + path;
+};
+
+// posix version
+exports.isAbsolute = function(path) {
+ return path.charAt(0) === '/';
+};
+
+// posix version
+exports.join = function() {
+ var paths = Array.prototype.slice.call(arguments, 0);
+ return exports.normalize(filter(paths, function(p, index) {
+ if (typeof p !== 'string') {
+ throw new TypeError('Arguments to path.join must be strings');
+ }
+ return p;
+ }).join('/'));
+};
+
+
+// path.relative(from, to)
+// posix version
+exports.relative = function(from, to) {
+ from = exports.resolve(from).substr(1);
+ to = exports.resolve(to).substr(1);
+
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+ return outputParts.join('/');
+};
+
+exports.sep = '/';
+exports.delimiter = ':';
+
+exports.dirname = function(path) {
+ var result = splitPath(path),
+ root = result[0],
+ dir = result[1];
+
+ if (!root && !dir) {
+ // No dirname whatsoever
+ return '.';
+ }
+
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+
+ return root + dir;
+};
+
+
+exports.basename = function(path, ext) {
+ var f = splitPath(path)[2];
+ // TODO: make this comparison case-insensitive on windows?
+ if (ext && f.substr(-1 * ext.length) === ext) {
+ f = f.substr(0, f.length - ext.length);
+ }
+ return f;
+};
+
+
+exports.extname = function(path) {
+ return splitPath(path)[3];
+};
+
+function filter (xs, f) {
+ if (xs.filter) return xs.filter(f);
+ var res = [];
+ for (var i = 0; i < xs.length; i++) {
+ if (f(xs[i], i, xs)) res.push(xs[i]);
+ }
+ return res;
+}
+
+// String.prototype.substr - negative index don't work in IE8
+var substr = 'ab'.substr(-1) === 'b'
+ ? function (str, start, len) { return str.substr(start, len) }
+ : function (str, start, len) {
+ if (start < 0) start = str.length + start;
+ return str.substr(start, len);
+ }
+;
+
+}).call(this,require("/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":13}],15:[function(require,module,exports){
+
+module.exports = function(){
+ var orig = Error.prepareStackTrace;
+ Error.prepareStackTrace = function(_, stack){ return stack; };
+ var err = new Error;
+ Error.captureStackTrace(err, arguments.callee);
+ var stack = err.stack;
+ Error.prepareStackTrace = orig;
+ return stack;
+};
+
+},{}],16:[function(require,module,exports){
+(function (process,global){
+var path = require('path');
+var callsite = require('callsite');
+var realModulePaths = module.paths;
+var realModuleFilename = module.filename;
+
+// Decorate the given constructor with some useful
+// object oriented constructs (mainly a convenient inherit()
+// method and the ability to do a super send)
+module.exports = function(constructor) {
+ // inherit from the given constructor
+ constructor.inherit = function(parent) {
+ if (arguments.length > 1) {
+ // this allows chaining multiple classes in the call
+ parent.inherit(Array.prototype.slice.call(arguments, 1));
+ }
+ this.super_ = parent;
+ this.prototype.__proto__ = parent.prototype;
+ this.__proto__ = parent;
+ };
+
+ // invoke the given method of the parent
+ constructor.super = function(receiver, method, args) {
+ if (!this.super_) return;
+ if (typeof method == 'string') {
+ // invoke the named method
+ return this.super_.prototype[method].apply(receiver, args);
+ } else {
+ // invoke the constructor of the parent
+ return this.super_.apply(receiver, method);
+ }
+ };
+
+ // a standarized way to access a cached default instance
+ constructor.default = function() {
+ if (!this._default) this._default = new this();
+ return this._default;
+ };
+
+ // set the parent if one is specified
+ if (constructor.parent) {
+ constructor.inherit(constructor.parent);
+ }
+
+ return constructor;
+};
+
+// load the given module using the given imports
+// @fname the module name (relative paths are relative to the caller's
+// location in the file system
+// @imports namespace for binding values in the loaded module
+var load = function(fname, imports) {
+ if((fname.slice(0,2) == './') || (fname.slice(0,3) == '../')) {
+ var callerFilename = callsite()[1].getFileName();
+ fname = path.resolve(path.dirname(callerFilename), fname);
+ }
+
+ // fake out module path resolution here
+ module.paths = module.parent.paths;
+ module.filename = module.parent.filename;
+ fname = require.resolve(fname);
+ module.paths = realModulePaths;
+ module.filename = realModuleFilename;
+
+ var cachedModule = require.cache[fname];
+ if (cachedModule) delete require.cache[fname];
+ global._imports = imports;
+ var answer = require(fname);
+ delete require.cache[fname];
+ if (cachedModule) require.cache[fname] = cachedModule;
+ return answer;
+};
+
+var load_browser = function(fname, imports) {
+ global._imports = imports;
+ var answer;
+ try {
+ answer = require('!' + fname);
+ } catch (e) {
+ console.log('SOOP:' + e.message + '\nNote that SOOP requires a custom browserify configuration. please check soop\'s readme');
+ throw e;
+ }
+ return answer;
+};
+
+module.exports.load = process.versions ? load : load_browser;
+
+// access the imports passed from a call to load()
+module.exports.imports = function() {
+ var answer = global._imports || {};
+ global._imports = {};
+ return answer;
+};
+
+}).call(this,require("/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"/Users/colkito/Devel/BitPay/cosign/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":13,"callsite":15,"path":14}],17:[function(require,module,exports){
+
+var FakeStorage = function(){
+ this.storage = {};
+};
+
+FakeStorage.prototype.set = function (id) {
+ return this.storage[id];
+};
+
+FakeStorage.prototype.get = function(id, payload) {
+ this.storage[id] = payload;
+}
+
+module.exports = require('soop')(FakeStorage);
+
+},{"soop":16}]},{},[])
\ No newline at end of file
diff --git a/js/models/CopayPeer.js b/js/models/CopayPeer.js
new file mode 100644
index 000000000..5a25206de
--- /dev/null
+++ b/js/models/CopayPeer.js
@@ -0,0 +1,284 @@
+
+var imports = require('soop').imports();
+var EventEmitter= imports.EventEmitter || require('events').EventEmitter;
+
+/*
+ * Emits
+ * 'networkChange'
+ * when network layout has change (new/lost peers, etc)
+ *
+ * 'data'
+ * when an unknown data type arrives
+ *
+ * Provides
+ * send(toPeerIds, {data}, cb?)
+ *
+ */
+
+function CopayPeer(opts) {
+ opts = opts || {};
+ this.peerId = opts.peerId;
+ this.apiKey = opts.apiKey || 'lwjd5qra8257b9';
+ this.debug = opts.debug || 3;
+ this.maxPeers = opts.maxPeers || 5;
+ this.connectedPeers = [];
+}
+
+CopayPeer.parent=EventEmitter;
+
+// Array helpers
+CopayPeer._arrayDiff = function(a, b) {
+ var seen = [];
+ var diff = [];
+
+ for (var i = 0; i < b.length; i++)
+ seen[b[i]] = true;
+
+ for (var j = 0; j < a.length; j++)
+ if (!seen[a[j]])
+ diff.push(a[j]);
+
+ return diff;
+};
+
+CopayPeer._inArray = function(el, array) {
+ return array.indexOf(el) > -1;
+};
+
+CopayPeer._arrayPushOnce = function(el, array) {
+ var ret = false;
+ if (!CopayPeer._inArray(el, array)) {
+ array.push(el);
+ ret = true;
+ }
+ return ret;
+};
+
+CopayPeer._arrayRemove = function(el, array) {
+ var pos = array.indexOf(el);
+ if (pos >= 0) array.splice(pos, 1);
+
+ return array;
+};
+
+// DEBUG
+CopayPeer.prototype._showConnectedPeers = function() {
+ console.log("### CONNECTED PEERS", this.connectedPeers);
+};
+
+CopayPeer.prototype._onClose = function(peerId) {
+ this.connectedPeers = CopayPeer._arrayRemove(peerId, this.connectedPeers);
+ this._notify();
+};
+
+CopayPeer.prototype._connectToPeers = function(peerIds) {
+ var self = this;
+ var ret = false;
+ var arrayDiff1= CopayPeer._arrayDiff(peerIds, this.connectedPeers);
+ var arrayDiff = CopayPeer._arrayDiff(arrayDiff1, [this.peerId]);
+ arrayDiff.forEach(function(peerId) {
+ console.log('### CONNECTING TO:', peerId);
+ self.connectTo(peerId);
+ ret = true;
+ });
+ return ret;
+};
+
+CopayPeer.prototype._onData = function(data, isInbound) {
+ var obj;
+ try {
+ obj = JSON.parse(data);
+ } catch (e) {
+ console.log('### ERROR ON DATA: "%s" ', data, isInbound, e);
+ return;
+ };
+ console.log('### RECEIVED TYPE: %s FROM %s', obj.data.type, obj.sender);
+
+ switch(obj.data.type) {
+ case 'peerList':
+ this._connectToPeers(obj.data.peers);
+ this._notify();
+ break;
+ case 'disconnect':
+ this._onClose(obj.sender);
+ break;
+ default:
+ this.emit('data', obj.sender, obj.data, isInbound);
+ }
+};
+
+CopayPeer.prototype._sendPeers = function(peerIds) {
+ console.log('#### SENDING PEER LIST: ', this.connectedPeers, ' TO ', peerIds?peerIds: 'ALL');
+ this.send(peerIds, {
+ type: 'peerList',
+ peers: this.connectedPeers,
+ });
+};
+
+CopayPeer.prototype._addPeer = function(peerId, isInbound) {
+
+ var hasChanged = CopayPeer._arrayPushOnce(peerId, this.connectedPeers);
+
+
+ if (isInbound && hasChanged) {
+ this._sendPeers(); //broadcast peer list
+ }
+ else {
+ if (isInbound) {
+ this._sendPeers(peerId);
+ }
+ }
+};
+
+CopayPeer.prototype._setupConnectionHandlers = function(
+ dataConn, isInbound, openCallback, closeCallback) {
+
+ var self=this;
+
+ dataConn.on('open', function() {
+ if (!CopayPeer._inArray(dataConn.peer, self.connectedPeers)) {
+
+ console.log('### DATA CONNECTION READY TO: ADDING PEER: %s (inbound: %s)',
+ dataConn.peer, isInbound);
+
+ self._addPeer(dataConn.peer, isInbound);
+ self._notify( isInbound ? dataConn.peer : null);
+ if (typeof openCallback === 'function') openCallback();
+ }
+ });
+
+ dataConn.on('data', function(data) {
+ self._onData(data, isInbound);
+ });
+
+ dataConn.on('error', function(e) {
+ console.log('### DATA ERROR',e ); //TODO
+ });
+
+ dataConn.on('close', function() {
+ console.log('### CLOSE RECV FROM:', dataConn.peer); //TODO
+ self._onClose(dataConn.peer);
+ if (typeof closeCallback === 'function') closeCallback();
+ });
+};
+
+CopayPeer.prototype._notify = function(newPeer) {
+ this._showConnectedPeers();
+ this.emit('networkChange', newPeer);
+};
+
+CopayPeer.prototype._setupPeerHandlers = function(openCallback) {
+ var self=this;
+ var p = this.peer;
+
+
+ p.on('open', function(peerId) {
+ console.log('### PEER OPEN. I AM:' + peerId);
+ self.peerId = peerId;
+ self.connectedPeers = [peerId];
+ self._notify();
+ return openCallback(peerId);
+ });
+
+ p.on('error', function(err) {
+ console.log('### PEER ERROR:', err);
+ });
+
+ p.on('connection', function(dataConn) {
+
+ console.log('### NEW INBOUND CONNECTION %d/%d', self.connectedPeers.length, self.maxPeers);
+ if (self.connectedPeers.length >= self.maxPeers) {
+ console.log('### PEER REJECTED. PEER MAX LIMIT REACHED');
+ dataConn.on('open', function() {
+ console.log('### CLOSING CONN FROM:' + dataConn.peer);
+ dataConn.close();
+ });
+ }
+ else {
+ self._setupConnectionHandlers(dataConn, true);
+ }
+ });
+};
+
+CopayPeer.prototype.start = function(openCallback) {
+ // Start PeerJS Peer
+ this.peer = new Peer(this.peerId, {
+ key: this.apiKey, // TODO: we need our own PeerServer KEY (http://peerjs.com/peerserver)
+ debug: this.debug,
+ });
+
+ this._setupPeerHandlers(openCallback);
+};
+
+CopayPeer.prototype._sendToOne = function(peerId, data, cb) {
+ if (peerId !== this.peerId) {
+ var conns = this.peer.connections[peerId];
+
+ if (conns) {
+ var str = JSON.stringify({
+ sender: this.peerId,
+ data: data
+ });
+
+ for (var i = 0; i < conns.length; i++) {
+ var conn = conns[i];
+ conn.send(str);
+ }
+ }
+ }
+ if (typeof cb === 'function') cb();
+};
+
+CopayPeer.prototype.send = function(peerIds, data, cb) {
+ var self=this;
+
+ if (!peerIds) {
+ peerIds = this.connectedPeers;
+ data.isBroadcast = 1;
+ }
+console.log('[CopayPeer.js.216:SENDD:]',data); //TODO
+
+ if (Array.isArray(peerIds)) {
+ var l = peerIds.length;
+ var i = 0;
+ peerIds.forEach(function(peerId) {
+ self._sendToOne(peerId, data, function () {
+ if (++i === l && typeof cb === 'function') cb();
+ });
+ });
+ }
+ else if (typeof peerIds === 'string')
+ self._sendToOne(peerIds, data, cb);
+};
+
+CopayPeer.prototype.connectTo = function(peerId, openCallback, closeCallback ) {
+ var self = this;
+
+ console.log('### STARTING TO CONNECT TO:' + peerId );
+
+ var dataConn = this.peer.connect(peerId, {
+// label: 'wallet',
+ serialization: 'none',
+ reliable: true,
+ metadata: { message: 'hi copayer!' }
+ });
+
+ self._setupConnectionHandlers(dataConn, false, openCallback, closeCallback);
+};
+
+CopayPeer.prototype.disconnect = function(peerId, cb) {
+ var self = this;
+
+ this.send(null, { type: 'disconnect' }, function() {
+ self.connectedPeers = [];
+ self.peerId = null;
+ if (self.peer) {
+ self.peer.disconnect();
+ self.peer.destroy();
+ self.peer = null;
+ }
+ if (typeof cb === 'function') cb();
+ });
+};
+
+module.exports = require('soop')(CopayPeer);
diff --git a/js/models/Peer.js b/js/models/Peer.js
new file mode 100644
index 000000000..2d76a7d15
--- /dev/null
+++ b/js/models/Peer.js
@@ -0,0 +1,8 @@
+
+
+function Peer(id) {
+ this.id = id;
+};
+
+
+module.exports = require('soop')(Peer);
diff --git a/js/models/PublicKeyRing.js b/js/models/PublicKeyRing.js
index df6cb2254..ec159403b 100644
--- a/js/models/PublicKeyRing.js
+++ b/js/models/PublicKeyRing.js
@@ -59,22 +59,8 @@ PublicKeyRing.encrypt = function (passphrase, payload) {
return payload;
};
-PublicKeyRing.read = function (id, passphrase) {
- var encPayload = storage.get(id);
- if (!encPayload)
- throw new Error('Could not find wallet data');
- var data;
- try {
- data = JSON.parse( PublicKeyRing.decrypt( passphrase, encPayload ));
- } catch (e) {
- throw new Error('error in storage: '+ e.toString());
- return;
- };
-
- if (data.id !== id)
- throw new Error('Wrong id in data');
-
- var config = { networkName: data.networkName };
+PublicKeyRing.fromObj = function (data) {
+ var config = { networkName: data.networkName || 'livenet' };
var w = new PublicKeyRing(config);
@@ -93,6 +79,25 @@ PublicKeyRing.read = function (id, passphrase) {
return w;
};
+PublicKeyRing.read = function (id, passphrase) {
+ var encPayload = storage.get(id);
+ if (!encPayload)
+ throw new Error('Could not find wallet data');
+ var data;
+ try {
+ data = JSON.parse( PublicKeyRing.decrypt( passphrase, encPayload ));
+ } catch (e) {
+ throw new Error('error in storage: '+ e.toString());
+ return;
+ };
+
+ if (data.id !== id)
+ throw new Error('Wrong id in data');
+
+
+ return PublicKeyRing.fromObj(data);
+};
+
PublicKeyRing.prototype.toObj = function() {
return {
id: this.id,
diff --git a/js/models/Storage.js b/js/models/Storage.js
index c6036747c..6f9ce6e59 100644
--- a/js/models/Storage.js
+++ b/js/models/Storage.js
@@ -7,12 +7,20 @@ function Storage() {
}
Storage.prototype.get = function(k) {
- return this.data[k];
+ return JSON.parse(localStorage.getItem(k));
};
Storage.prototype.set = function(k,v) {
- this.data[k]=v;
+ localStorage.setItem(k, JSON.stringify(v));
+};
+
+Storage.prototype.remove = function(k) {
+ localStorage.removeItem(k);
};
+Storage.prototype.clearAll = function() {
+ localStorage.clear();
+};
+
module.exports = require('soop')(Storage);
diff --git a/js/services/network.js b/js/services/network.js
index 6cea32267..d1cf09fcc 100644
--- a/js/services/network.js
+++ b/js/services/network.js
@@ -3,274 +3,176 @@
angular.module('copay.network')
.factory('Network', function($rootScope, Storage) {
var peer;
- $rootScope.connectedPeers = [];
- $rootScope.peerId = null;
- // Array helpers
- var _arrayDiff = function(a, b) {
- var seen = [];
- var diff = [];
- for (var i = 0; i < b.length; i++)
- seen[b[i]] = true;
-
- for (var i = 0; i < a.length; i++)
- if (!seen[a[i]])
- diff.push(a[i]);
-
- return diff;
+ var _refreshUx = function() {
+ var cp = $rootScope.cp;
+ console.log('*** UPDATING UX'); //TODO
+ $rootScope.peerId = cp.peerId;
+ $rootScope.connectedPeers = cp.connectedPeers;
+ $rootScope.$digest();
};
- var _inArray = function(el, array) {
- return array.indexOf(el) > -1;
- };
-
- var _arrayPushOnce = function(el, array) {
- if (!_inArray(el, array)) array.push(el);
- };
-
- var _arrayRemove = function(el, array) {
- var pos = array.indexOf(el);
- if (pos >= 0) array.splice(pos, 1);
-
- return array;
- };
-
- // General helpers
- var _saveDataStorage = function() {
- Storage.save('peerData', {
+ var _store = function() {
+ Storage.set($rootScope.walletId, 'peerData', {
peerId: $rootScope.peerId,
connectedPeers: $rootScope.connectedPeers
});
};
- var _sendToOne = function(pid, data, cb) {
- if (pid !== $rootScope.peerId) {
- var conns = peer.connections[pid];
-
- if (conns) {
- var str = JSON.stringify({
- sender: $rootScope.peerId,
- data: data
- });
-
- for (var i = 0; i < conns.length; i++) {
- var conn = conns[i];
- conn.send(str);
- }
-
- if (typeof cb === 'function') cb();
- }
- }
- };
-
- var _onData = function(data, isOutbound) {
- var obj = JSON.parse(data);
- console.log('### RECEIVED TYPE: %s FROM %s', obj.data.type, obj.sender);
- switch(obj.data.type) {
- case 'peerList':
- if (_connectToPeers(obj.data.peers)) {
- //TODO Remove log
- console.log('### BROADCASTING PEER LIST');
- _send( $rootScope.connectedPeers, {
- type: 'peerList',
- peers: $rootScope.connectedPeers,
- isBroadcast: 1,
- });
- $rootScope.$digest();
- }
- else if (!isOutbound && !obj.data.isBroadcast) {
- // replying always to connecting peer
- console.log('### REPLYING PEERLIST TO:', obj.sender );
- _send( obj.sender, {
- type: 'peerList',
- peers: $rootScope.connectedPeers
- });
- }
- break;
- case 'disconnect':
- _onClose(obj.sender);
- break;
- case 'publicKeyRing':
- console.log('### RECEIVED PKR FROM:', obj.sender);
-
- if ($rootScope.publicKeyRing.merge(obj.data.publicKeyRing, true)) {
- //TODO Remove log
- console.log('### BROADCASTING PRK');
- _send( $rootScope.connectedPeers, {
- type: 'publicKeyRing',
- publicKeyRing: $rootScope.publicKeyRing.toObj(),
- isBroadcast: 1,
- });
- $rootScope.$digest();
- }
- else if (!isOutbound && !obj.data.isBroadcast) {
- // replying always to connecting peer
- console.log('### REPLYING PRK TO:', obj.sender );
- _send( obj.sender, {
- type: 'publicKeyRing',
- publicKeyRing: $rootScope.publicKeyRing.toObj(),
- });
-
- }
-
- //TODO Remove log
- console.log('*** PRK:', $rootScope.publicKeyRing.toObj());
- break;
- }
- };
-
- var _onClose = function(pid) {
- $rootScope.connectedPeers = _arrayRemove(pid, $rootScope.connectedPeers);
- _saveDataStorage();
-
- $rootScope.$digest();
- };
-
- var _connectToPeers = function(peers) {
- var ret = false;
- var arrayDiff1= _arrayDiff(peers, $rootScope.connectedPeers);
- var arrayDiff = _arrayDiff(arrayDiff1, [$rootScope.peerId]);
- arrayDiff.forEach(function(pid) {
- console.log('### CONNECTING TO:',pid);
- ret = true;
- connect(pid);
+ // set new inbound connections
+ var _setNewPeer = function(newPeer) {
+ var cp = $rootScope.cp;
+ console.log('#### SENDING PKR 1111 ');
+ cp.send(newPeer, {
+ type: 'publicKeyRing',
+ publicKeyRing: $rootScope.publicKeyRing.toObj(),
});
+ };
+
+ var _handleNetworkChange = function(newPeer) {
+ var cp = $rootScope.cp;
+
+ if (newPeer)
+ _setNewPeer(newPeer);
+
+ _store();
+ _refreshUx();
+ };
+
+ // TODO -> probably not in network.js
+ var createWallet = function(walletId) {
+ console.log('### CREATING WALLET. ID:' + walletId);
+
+ //TODO create a wallet and WalletId, not only pkr
+ var pkr = new copay.PublicKeyRing({
+ network: config.networkName,
+ id: walletId,
+ });
+ pkr.addCopayer();
+ console.log('\t### PublicKeyRing Initialized:');
+ Storage.addWalletId(pkr.id);
+ Storage.set(pkr.id, 'publicKeyRing', pkr.toObj());
+
+ $rootScope.walletId = pkr.id;
+ $rootScope.publicKeyRing = pkr;
+ };
+
+ var openWallet = function (walletId) {
+ var ret = false;
+ var pkr = Storage.get(walletId, 'publicKeyRing');
+
+ if (pkr) {
+ console.log('### WALLET OPENED:', walletId, pkr);
+ $rootScope.walletId = walletId;
+ $rootScope.publicKeyRing = new copay.PublicKeyRing.fromObj(pkr);
+ ret = true;
+ }
return ret;
};
+ var closeWallet = function() {
+ console.log('### CLOSING WALLET');
+ $rootScope.walletId = null;
+ $rootScope.publicKeyRing = null;
+ //TODO
+ };
+
+ var _checkWallet = function(walletId) {
+ console.log('[network.js.79:_checkWallet:]',walletId); //TODO
+
+ if ($rootScope.walletId && $rootScope.walletId !== walletId)
+ closeWallet();
+
+ if ($rootScope.walletId)
+ return;
+
+ if (!openWallet(walletId)) {
+ createWallet(walletId);
+ }
+ };
+
+ var _handleData = function(senderId, data, isInbound) {
+ var cp = $rootScope.cp;
+
+ switch(data.type) {
+ case 'publicKeyRing':
+ _checkWallet(data.publicKeyRing.id);
+ var shouldSend = false;
+
+ var recipients, pkr = $rootScope.publicKeyRing;
+ if (pkr.merge(data.publicKeyRing, true) && !data.isBroadcast) {
+ console.log('### BROADCASTING PKR');
+ recipients = null;
+ shouldSend = true;
+ }
+ else if (isInbound && !data.isBroadcast) {
+ // always replying to connecting peer
+ console.log('### REPLYING PKR TO:', senderId);
+ recipients = senderId;
+ shouldSend = true;
+ }
+
+ if (shouldSend) {
+ console.log('### SENDING PKR TO:', recipients);
+ cp.send( recipients, {
+ type: 'publicKeyRing',
+ publicKeyRing: $rootScope.publicKeyRing.toObj(),
+ });
+ }
+
+ _refreshUx();
+ break;
+ }
+ };
+ var _setupHandlers = function () {
+ var cp = $rootScope.cp;
+ cp.on('networkChange', _handleNetworkChange);
+ cp.on('data', _handleData);
+ };
+
// public methods
var init = function(cb) {
- peer = new Peer($rootScope.peerId, {
- key: 'lwjd5qra8257b9', // TODO: we need our own PeerServer KEY (http://peerjs.com/peerserver)
- debug: 3
- });
+ var cp = $rootScope.cp = new copay.CopayPeer({
+ apiKey: config.p2pApiKey,
+ debug: config.p2pDebug,
+ maxPeers: config.maxPeers, // TODO: This should be on wallet configuration
+ });
+ _setupHandlers();
- $rootScope.publicKeyRing = new copay.PublicKeyRing({
- network: config.networkName,
- });
- $rootScope.publicKeyRing.addCopayer();
- console.log('### PublicKeyRing Initialized');
-
-
- peer.on('open', function(pid) {
- console.log('### PEER OPEN. I AM:' + pid);
- $rootScope.peerId = pid;
- _saveDataStorage();
-
- cb();
- $rootScope.$digest();
- });
-
- peer.on('connection', function(dataConn) {
- if (dataConn.label === 'wallet') {
- console.log('### NEW INBOUND CONNECTION'); //TODO
- dataConn.on('open', function() {
- if (!_inArray(dataConn.peer, $rootScope.connectedPeers)) {
- console.log('### INBOUND DATA CONNECTION READY TO:' + dataConn.peer); //TODO
- _arrayPushOnce(dataConn.peer, $rootScope.connectedPeers);
- _saveDataStorage();
-
- $rootScope.$digest();
- }
- });
-
- dataConn.on('data', _onData);
- dataConn.on('error', function(e) {
- console.log('### ## INBOUND DATA ERROR',e ); //TODO
- _onClose(dataConn.peer);
- });
- dataConn.on('close', function() {
- _onClose(dataConn.peer);
- });
- }
+ // inicia session
+ cp.start(function(peerId) {
+ return cb();
});
};
- var connect = function(pid, cb) {
- if (pid !== $rootScope.peerId) {
+ var disconnect = function() {
+ if ($rootScope.cp) {
+ $rootScope.cp.disconnect();
+ }
+ Storage.remove('peerData');
+ $rootScope.isLogged = false;
+ _refreshUx();
+ };
- console.log('### STARTING CONNECT TO:' + pid );
-
- var dataConn = peer.connect(pid, {
- label: 'wallet',
- serialization: 'none',
- reliable: true,
- metadata: { message: 'hi copayer!' }
- });
-
- dataConn.on('open', function() {
-
- console.log('### OUTBOUND DATA CONN READY TO:' + pid );
- _arrayPushOnce(pid, $rootScope.connectedPeers);
- _saveDataStorage();
-
- console.log('#### SENDING PEER LIST: ' +$rootScope.connectedPeers);
- _send(pid, {
- type: 'peerList',
- peers: $rootScope.connectedPeers
- });
-
-
- console.log('#### SENDING PKR ');
- _send(dataConn.peer, {
- type: 'publicKeyRing',
- publicKeyRing: $rootScope.publicKeyRing.toObj(),
- });
-
- if (typeof cb === 'function') cb();
-
- $rootScope.$digest();
- });
-
- dataConn.on('data', function(data) {
- _onData(data,true);
- });
-
- dataConn.on('error', function(e) {
- console.log('### ## INBOUND DATA ERROR',e ); //TODO
- _onClose(dataConn.peer);
- });
-
- dataConn.on('close', function() {
- _onClose(dataConn.peer);
+ var connect = function(peerId, openCallback, failCallBack) {
+ if ($rootScope.cp) {
+ $rootScope.cp.connectTo(peerId, openCallback, function () {
+ disconnect();
+ failCallBack();
});
}
+ else
+ return failCallBack();
};
- var _send = function(pids, data, cb) {
- if (Array.isArray(pids))
- pids.forEach(function(pid) {
- _sendToOne(pid, data, cb);
- });
- else if (typeof pids === 'string')
- _sendToOne(pids, data, cb);
- };
-
- var disconnect = function(cb) {
- Storage.remove('peerData');
- var conns = $rootScope.connectedPeers.length;
- var i = 1;
- _send($rootScope.connectedPeers, { type: 'disconnect' }, function() {
- i += 1;
-
- if (i === conns) {
-
- $rootScope.connectedPeers = [];
- $rootScope.peerId = null;
- peer.disconnect();
- peer.destroy();
- if (typeof cb === 'function') cb();
- }
- });
- }
-
return {
init: init,
connect: connect,
- send: _send,
- disconnect: disconnect
+ disconnect: disconnect,
+ createWallet: createWallet,
+ openWallet: openWallet,
}
});
diff --git a/js/services/storage.js b/js/services/storage.js
index d315ded79..b35cf499e 100644
--- a/js/services/storage.js
+++ b/js/services/storage.js
@@ -2,21 +2,63 @@
angular.module('copay.storage')
.factory('Storage', function($rootScope) {
+
+
+ var _key = function(walletId, key) {
+ return walletId + '::' + key;
+ };
+
+ var _pushKey = function(walletId, key) {
+ var keys = localStorage.getItem(walletId);
+ localStorage.setItem(walletId, (keys?keys+',':'') +key);
+ };
+
return {
- get: function(key) {
+ getGlobal: function( key) {
return JSON.parse(localStorage.getItem(key));
},
-
- set: function(key, data) {
+ setGlobal: function( key, data) {
localStorage.setItem(key, JSON.stringify(data));
},
-
- remove: function(key) {
- localStorage.removeItem(key);
+ get: function(walletId, key) {
+ if (!walletId) return;
+ return JSON.parse(localStorage.getItem(_key(walletId,key)));
+ },
+ set: function(walletId, key, data) {
+ if (!walletId) return;
+ var k = _key(walletId,key);
+ localStorage.setItem(k, JSON.stringify(data));
+ _pushKey(walletId, k);
+ },
+ remove: function(walletId, key) {
+ localStorage.removeItem(_key(walletId,key));
+ },
+ clearAll: function(walletId){
+ var keys = localStorage.getItem(walletId);
+ keys.split(',').forEach(function(k){
+ localStorage.removeItem(key);
+ });
+ },
+ addWalletId: function(walletId) {
+ var ids = localStorage.getItem('walletIds');
+ localStorage.setItem('walletIds', (ids?ids+',':'') + walletId);
+ },
+ delWalletId: function(walletId) {
+ var ids = localStorage.getItem('walletIds');
+ if (ids) {
+ var is = ids.split(',');
+ var newIds = [];
+ is.forEach(function(i) {
+ if (i != walletId) {
+ newIds.push(i);
+ }
+ });
+ localStorage.setItem('walletIds', newIds.join(',') );
+ }
+ },
+ getWalletIds: function() {
+ var ids = localStorage.getItem('walletIds');
+ return ids ? ids.split(',') : [];
},
-
- clearAll: function() {
- localStorage.clear();
- }
};
});
diff --git a/package.json b/package.json
index 8e593f154..2ecb362db 100644
--- a/package.json
+++ b/package.json
@@ -32,6 +32,8 @@
"browserify": "~3.32.1",
"browser-pack": "~2.0.1",
"commander": "~2.1.0",
- "uglifyify": "~1.2.3"
+ "uglifyify": "~1.2.3",
+ "soop": "~0.1.5",
+ "bitcore": "~0.1.11"
}
}
diff --git a/util/build.js b/util/build.js
index d1d16a476..af65fd1d6 100755
--- a/util/build.js
+++ b/util/build.js
@@ -63,7 +63,7 @@ if (require.main === module) {
.option('-o, --stdout', 'Specify output as stdout')
.parse(process.argv);
var copayBundle = createBundle(program);
- copayBundle.pipe(program.stdout ? process.stdout : fs.createWriteStream('lib/copayBundle.js'));
+ copayBundle.pipe(program.stdout ? process.stdout : fs.createWriteStream('js/copayBundle.js'));
}
module.exports.createBundle = createBundle;
Backup to email
diff --git a/js/config.js b/js/config.js index 1d866dd7f..abead97d4 100644 --- a/js/config.js +++ b/js/config.js @@ -2,4 +2,7 @@ var config = { networkName: 'testnet', + p2pApiKey: 'lwjd5qra8257b9', + p2pDebug: 3, + maxPeers: 5, }; diff --git a/js/controllers/header.js b/js/controllers/header.js index 5e510854a..6a2787e54 100644 --- a/js/controllers/header.js +++ b/js/controllers/header.js @@ -32,9 +32,12 @@ angular.module('copay.header').controller('HeaderController', }; $scope.signout = function() { - $rootScope.isLogged = false; Network.disconnect(function() { $location.path('signin'); }); }; + + $scope.clearFlashMessage = function() { + $rootScope.flashMessage = {}; + }; }); diff --git a/js/controllers/signin.js b/js/controllers/signin.js index 42b4183a5..fee00a14a 100644 --- a/js/controllers/signin.js +++ b/js/controllers/signin.js @@ -2,26 +2,52 @@ angular.module('copay.signin').controller('SigninController', function($scope, $rootScope, $location, Network, Storage) { - var peerData = Storage.get('peerData'); + + var peerData = Storage.get($rootScope.walletId, 'peerData'); $scope.loading = false; $rootScope.peerId = peerData ? peerData.peerId : null; + $scope.listWalletIds = function() { + return Storage.getWalletIds(); + }; + $scope.create = function() { $scope.loading = true; + Network.createWallet(); Network.init(function() { $location.path('peer'); + $rootScope.$digest(); }); }; + $scope.open = function(walletId) { + $scope.loading = true; + + if (Network.openWallet(walletId)) { + Network.init(function() { + $location.path('peer'); + $rootScope.$digest(); + }); + } + }; + $scope.join = function(cid) { $scope.loading = true; if (cid) { Network.init(function() { - Network.connect(cid, function() { - $location.path('peer'); + Network.connect(cid, + function() { + $location.path('peer'); + $rootScope.$digest(); + }, function() { + +console.log('[signin.js.46] SETTING MESSAGE'); //TODO + $rootScope.flashMessage = { message: 'Connection refussed', type: 'error'}; + $location.path('home'); + $rootScope.$digest(); }); }); } diff --git a/js/copayBundle.js b/js/copayBundle.js new file mode 100644 index 000000000..b1dfb62b1 --- /dev/null +++ b/js/copayBundle.js @@ -0,0 +1,2958 @@ +require= +// modules are defined as an array +// [ module function, map of requireuires ] +// +// map of requireuires is short require name -> numeric require +// +// anything defined in a previous bundle is accessed via the +// orig method which is the requireuire for previous bundles +(function outer (modules, cache, entry) { + // Save the require from previous bundle to this closure if any + var previousRequire = typeof require == "function" && require; + + function newRequire(name, jumped, inSkipCache){ + + var m, skipCache = inSkipCache; + if (typeof name === 'string') { + if (name.charAt(0) === '!' ) { + name = name.substr(1); + skipCache=true; + } + } + if(skipCache || !cache[name]) { + if(!modules[name]) { + // if we cannot find the the module within our internal map or + // cache jump to the current global require ie. the last bundle + // that was added to the page. + var currentRequire = typeof require == "function" && require; + if (!jumped && currentRequire) return currentRequire(name, true); + + // If there are other bundles on this page the require from the + // previous one is saved to 'previousRequire'. Repeat this as + // many times as there are bundles until the module is found or + // we exhaust the require chain. + if (previousRequire) return previousRequire(name, true); + throw new Error('Cannot find module \'' + name + '\''); + } + + m = {exports:{}}; + var nextSkipCache = inSkipCache ? false : skipCache; + if (!skipCache) cache[name] = m; + skipCache = false; + modules[name][0].call(m.exports, function(x){ + var id = modules[name][1][x]; + return newRequire(id ? id : x, false, nextSkipCache); + },m,m.exports,outer,modules,cache,entry); + } + return m ? m.exports:cache[name].exports; + } + for(var i=0;i