split up Key into Key.browser and Key.node

lib/Key.browser.js

@@ -0,0 +1,102 @@
+var ECKey = require('../browser/vendor-bundle.js').ECKey;
+var buffertools = require('buffertools');
+
+var Key = function() {
+  this._pub = null;
+  this.compressed = true; // default
+};
+
+var bufferToArray = Key.bufferToArray = function(buffer) {
+  var ret = [];
+
+  var l = buffer.length;
+  for(var i =0; i<l; i++) {
+    ret.push(buffer.readUInt8(i));
+  }
+
+  return ret;
+}
+
+
+Object.defineProperty(Key.prototype, 'public', {
+  set: function(p){
+    if (!Buffer.isBuffer(p) ) {
+      throw new Error('Arg should be a buffer');
+    }
+    var type = p[0];
+    this.compressed = type!==0x04;
+    this._pub = p;
+  },
+  get: function(){
+    return this._pub;
+  }
+});
+
+Key.generateSync = function() {
+  var eck = new ECKey();
+  eck.setCompressed(true);
+  var pub = eck.getPub();
+
+  var ret = new Key();
+  ret.private = new Buffer(eck.priv.toByteArrayUnsigned());
+  ret.public  = new Buffer(pub);
+  return ret;
+};
+
+Key.prototype.regenerateSync = function() {
+  if (!this.private) {
+    throw new Error('Key does not have a private key set');
+  }
+
+  var eck = new ECKey(buffertools.toHex(this.private));
+  eck.setCompressed(this.compressed);
+  this.public = new Buffer(eck.getPub());
+  return this;
+};
+
+Key.prototype.signSync = function(hash) {
+  if (!this.private) {
+    throw new Error('Key does not have a private key set');
+  }
+
+  if (!Buffer.isBuffer(hash) || hash.length !== 32) {
+    throw new Error('Arg should be a 32 bytes hash buffer');
+  }
+  var eck = new ECKey(buffertools.toHex(this.private));
+  eck.setCompressed(this.compressed);
+  var signature = eck.sign(bufferToArray(hash));
+  // return it as a buffer to keep c++ compatibility
+  return new Buffer(signature);
+};
+
+Key.prototype.verifySignature = function(hash, sig, callback) {
+  try {
+    var result = this.verifySignatureSync(hash, sig);
+    callback(null, result);
+  } catch (e) {
+    callback(e);
+  }
+};
+
+Key.prototype.verifySignatureSync = function(hash, sig) {
+  var self = this;
+
+  if (!Buffer.isBuffer(hash) || hash.length !== 32) {
+    throw new Error('Arg 1 should be a 32 bytes hash buffer');
+  }
+  if (!Buffer.isBuffer(sig)) {
+    throw new Error('Arg 2 should be a buffer');
+  }
+  if (!self.public) {
+    throw new Error('Key does not have a public key set');
+  }
+
+  var eck = new ECKey();
+  eck.setPub(bufferToArray(self.public));
+  eck.setCompressed(self.compressed);
+  var sigA = bufferToArray(sig);
+  var ret = eck.verify(bufferToArray(hash),sigA);
+  return ret;
+};
+
+module.exports = Key;

lib/Key.js

@@ -1,115 +1,5 @@
-
-
 if (process.versions) {
-  // c++ native version
+  module.exports = require('./Key.node');
-  var KeyModule = require('bindings')('KeyModule');
+  return;
-  var Key = KeyModule.Key;
-  module.exports = Key;
-} else {
-  // pure js version
-  var ECKey = require('../browser/vendor-bundle.js').ECKey;
-  var buffertools = require('buffertools');
-
-  var kSpec = function() {
-    this._pub = null;
-    this.compressed = true; // default
-  };
-
-  var bufferToArray = kSpec.bufferToArray = function(buffer) {
-    var ret = [];
-
-    var l = buffer.length;
-    for(var i =0; i<l; i++) {
-      ret.push(buffer.readUInt8(i));
 }
-
+module.exports = require('./Key.browser');
-    return ret;
-  }
-
-
-  Object.defineProperty(kSpec.prototype, 'public', {
-    set: function(p){
-      if (!Buffer.isBuffer(p) ) {
-        throw new Error('Arg should be a buffer');
-      }
-      var type = p[0];
-      this.compressed = type!==0x04;
-      this._pub = p;
-    },
-    get: function(){
-      return this._pub;
-    }
-  });
-
-  kSpec.generateSync = function() {
-    var eck = new ECKey();
-    eck.setCompressed(true);
-    var pub = eck.getPub();
-
-    var ret = new kSpec();
-    ret.private = new Buffer(eck.priv.toByteArrayUnsigned());
-    ret.public  = new Buffer(pub);
-    return ret;
-  };
-
-  kSpec.prototype.regenerateSync = function() {
-    if (!this.private) {
-      throw new Error('Key does not have a private key set');
-    }
-
-    var eck = new ECKey(buffertools.toHex(this.private));
-    eck.setCompressed(this.compressed);
-    this.public = new Buffer(eck.getPub());
-    return this;
-  };
-
-  kSpec.prototype.signSync = function(hash) {
-    if (!this.private) {
-      throw new Error('Key does not have a private key set');
-    }
-
-    if (!Buffer.isBuffer(hash) || hash.length !== 32) {
-      throw new Error('Arg should be a 32 bytes hash buffer');
-    }
-    var eck = new ECKey(buffertools.toHex(this.private));
-    eck.setCompressed(this.compressed);
-    var signature = eck.sign(bufferToArray(hash));
-    // return it as a buffer to keep c++ compatibility
-    return new Buffer(signature);
-  };
-  
-  kSpec.prototype.verifySignature = function(hash, sig, callback) {
-    try {
-      var result = this.verifySignatureSync(hash, sig);
-      callback(null, result);
-    } catch (e) {
-      callback(e);
-    }
-  };
-
-  kSpec.prototype.verifySignatureSync = function(hash, sig) {
-    var self = this;
-
-    if (!Buffer.isBuffer(hash) || hash.length !== 32) {
-      throw new Error('Arg 1 should be a 32 bytes hash buffer');
-    }
-    if (!Buffer.isBuffer(sig)) {
-      throw new Error('Arg 2 should be a buffer');
-    }
-    if (!self.public) {
-      throw new Error('Key does not have a public key set');
-    }
-
-    var eck = new ECKey();
-    eck.setPub(bufferToArray(self.public));
-    eck.setCompressed(self.compressed);
-    var sigA = bufferToArray(sig);
-    var ret = eck.verify(bufferToArray(hash),sigA);
-    return ret;
-  };
-
-  module.exports = kSpec;
-
-}
-
-

lib/Key.node.js

@@ -0,0 +1 @@
+module.exports = require('bindings')('KeyModule').Key;