Add src/bitgo/keyutil

* Move simplified `getPrivateKeyBuffer` and `fromPublicKeyBuffer` to
  `src/bitgo/keyutil`.

* Use new helper funcs in `getPublicKeyBuffer` and
  `fromPublicKeyBuffer`

* Add deprecation notices

Author: OttoAllmendinger

src/bitgo/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  keyutil: require('./keyutil')
+}

src/bitgo/keyutil.js

@@ -0,0 +1,38 @@
+const ecurve = require('ecurve')
+const BigInteger = require('bigi')
+const ECPair = require('../ecpair')
+
+/**
+ * Create an ECPair from the raw private key bytes
+ * @param {Buffer} buffer - Private key for the ECPair. Must be exactly 32 bytes.
+ * @param {Object} [network] - Network for the ECPair. Defaults to bitcoin.
+ * @return {ECPair}
+ */
+function privateKeyBufferToECPair (buffer, network) {
+  if (!Buffer.isBuffer(buffer) || buffer.length !== 32) {
+    throw new Error('invalid private key buffer')
+  }
+
+  const d = BigInteger.fromBuffer(buffer)
+  return new ECPair(d, null, { network })
+}
+
+/**
+ * Get the private key as a 32 bytes buffer. If it is smaller than 32 bytes, pad it with zeros
+ * @param {ECPair} ecPair
+ * @return {Buffer} 32 bytes
+ */
+function privateKeyBufferFromECPair (ecPair) {
+  if (!(ecPair instanceof ECPair)) {
+    throw new TypeError(`invalid argument ecpair`)
+  }
+
+  if (!ecPair.d) throw new Error('Missing private key')
+
+  return ecPair.d.toBuffer(32)
+}
+
+module.exports = {
+  privateKeyBufferToECPair,
+  privateKeyBufferFromECPair
+}

src/ecpair.js

@@ -60,22 +60,6 @@ ECPair.fromPublicKeyBuffer = function (buffer, network) {
     network: network
   })
 }
-
-/**
- * Create an ECPair from the raw private key bytes
- * @param buffer {Buffer} Private key for the ECPair. Must be exactly 32 bytes.
- * @param network {Object} Network for the ECPair. Defaults to bitcoin.
- * @return {ECPair}
- */
-ECPair.fromPrivateKeyBuffer = function (buffer, network) {
-  if (!Buffer.isBuffer(buffer) || buffer.length !== 32) {
-    throw new Error('invalid private key buffer')
-  }
-
-  var d = BigInteger.fromBuffer(buffer)
-  return new ECPair(d, null, { network: network })
-}
-
 ECPair.fromWIF = function (string, network) {
   var decoded = wif.decode(string)
   var version = decoded.version
@@ -131,16 +115,6 @@ ECPair.prototype.getPublicKeyBuffer = function () {
   return this.Q.getEncoded(this.compressed)
 }
 
-/**
- * Get the private key as a 32 bytes buffer. If it is smaller than 32 bytes, pad it with zeros
- * @return Buffer
- */
-ECPair.prototype.getPrivateKeyBuffer = function () {
-  if (!this.d) throw new Error('Missing private key')
-
-  return this.d.toBuffer(32)
-}
-
 ECPair.prototype.sign = function (hash) {
   if (!this.d) throw new Error('Missing private key')
 
@@ -161,4 +135,26 @@ ECPair.prototype.verify = function (hash, signature) {
   return ecdsa.verify(hash, signature, this.Q)
 }
 
+/**
+ * @deprecated
+ * Use {@see keyutil.privateKeyBufferToECPair} instead
+ * Will be removed in next major version (BLOCK-267)
+ */
+ECPair.fromPrivateKeyBuffer = function (buffer, network) {
+  // toplevel import unavailable due to circular dependency
+  var keyutil = require('./bitgo/keyutil')
+  return keyutil.privateKeyBufferToECPair(buffer, network)
+}
+
+/**
+ * @deprecated
+ * Use {@see keyutil.privateKeyBufferFromECPair} instead
+ * Will be removed in next major version (BLOCK-267)
+ */
+ECPair.prototype.getPrivateKeyBuffer = function () {
+  // toplevel import unavailable due to circular dependency
+  var keyutil = require('./bitgo/keyutil')
+  return keyutil.privateKeyBufferFromECPair(this)
+}
+
 module.exports = ECPair

src/index.js

@@ -6,6 +6,7 @@ for (var key in templates) {
 }
 
 module.exports = {
+  bitgo: require('./bitgo'),
   bufferutils: require('./bufferutils'), // TODO: remove in 4.0.0
 
   Block: require('./block'),

test/bitgo/keyutil.js

@@ -0,0 +1,73 @@
+/* global describe, it */
+
+const assert = require('assert')
+var randombytes = require('randombytes')
+
+const BigInteger = require('bigi')
+
+const {
+  bitgo: {
+    keyutil: {
+      privateKeyBufferToECPair,
+      privateKeyBufferFromECPair
+    }
+  },
+  ECPair
+} = require('../../src')
+
+describe('privateKeyBufferFromECPair', function () {
+  it('pads short private keys', function () {
+    var keyPair = new ECPair(BigInteger.ONE)
+    assert.strictEqual(privateKeyBufferFromECPair(keyPair).byteLength, 32)
+    assert.strictEqual(privateKeyBufferFromECPair(keyPair).toString('hex'),
+      '0000000000000000000000000000000000000000000000000000000000000001')
+  })
+
+  it('does not pad 32 bytes private keys', function () {
+    var hexString = 'a000000000000000000000000000000000000000000000000000000000000000'
+    var keyPair = new ECPair(new BigInteger(hexString, 16))
+    assert.strictEqual(privateKeyBufferFromECPair(keyPair).byteLength, 32)
+    assert.strictEqual(privateKeyBufferFromECPair(keyPair).toString('hex'), hexString)
+  })
+
+  it('throws if the key is too long', function () {
+    var hexString = '10000000000000000000000000000000000000000000000000000000000000000'
+
+    assert.throws(function () {
+      var keyPair = new ECPair(new BigInteger(hexString, 16))
+      privateKeyBufferFromECPair(keyPair)
+    }, new RegExp('Private key must be less than the curve order'))
+  })
+})
+
+describe('privateKeyBufferToECPair', function () {
+  it('constructs an ECPair from a random private key buffer', function () {
+    var prvKeyBuffer = randombytes(32)
+    var ecPair = privateKeyBufferToECPair(prvKeyBuffer)
+    var ecPairPrvBuffer = privateKeyBufferFromECPair(ecPair)
+    assert.strictEqual(Buffer.compare(ecPairPrvBuffer, prvKeyBuffer), 0)
+  })
+
+  it('throws if the private key is out of range', function () {
+    var prvKeyBuffer = Buffer.alloc(32, 0xff)
+    assert.throws(function () {
+      privateKeyBufferToECPair(prvKeyBuffer)
+    }, new RegExp('private key out of range'))
+  })
+
+  it('throws if the private key buffer is not a buffer', function () {
+    assert.throws(function () {
+      privateKeyBufferToECPair('not a buffer')
+    }, new RegExp('invalid private key buffer'))
+  })
+
+  it('throws if the private key buffer is not 32 bytes', function () {
+    assert.throws(function () {
+      privateKeyBufferToECPair(Buffer.alloc(31, 0x00))
+    }, new RegExp('invalid private key buffer'))
+
+    assert.throws(function () {
+      privateKeyBufferToECPair(Buffer.alloc(33, 0x00))
+    }, new RegExp('invalid private key buffer'))
+  })
+})

test/ecpair.js

@@ -84,6 +84,11 @@ describe('ECPair', function () {
     }))
   })
 
+  /**
+   * @deprecated
+   * Use {@see keyutil.privateKeyBufferToECPair} instead
+   * Will be removed in next major version (BLOCK-267)
+   */
   describe('getPrivateKeyBuffer', function () {
     it('pads short private keys', sinon.test(function () {
       var keyPair = new ECPair(BigInteger.ONE)
@@ -301,6 +306,11 @@ describe('ECPair', function () {
     })
   })
 
+  /**
+   * @deprecated
+   * Use {@see keyutil.privateKeyBufferToECPair} instead
+   * Will be removed in next major version (BLOCK-267)
+   */
   describe('fromPrivateKeyBuffer', function () {
     it('constructs an ECPair from a random private key buffer', function () {
       var prvKeyBuffer = randombytes(32)