bip32-ed25519 0.0.5 → 0.0.6

package/index.js

@@ -4,6 +4,7 @@ var elliptic = require('elliptic');
 var utils = elliptic.utils;
 var EDDSA = require('./elliptic_eddsa_variant');
 var eddsa = new EDDSA('ed25519');
+var pbkdf2 = require('pbkdf2');
 
 function sha512(data) {
     var digest = hash.sha512().update(data).digest();
@@ -48,6 +49,16 @@ function fromSeed2(seed) {
     return Buffer.concat([extended, block.slice(32, 64)])
 }
 
+function fromEntropy(entropy) {
+    const xprv = pbkdf2.pbkdf2Sync('', entropy, 4096, 96, 'sha512')
+
+    xprv[0] &= 248
+    xprv[31] &= 31
+    xprv[31] |= 64
+
+    return Buffer.from(xprv)
+}
+
 function derivePrivate(xprv, index) {
     var kl = xprv.slice(0, 32);
     var kr = xprv.slice(32, 64);
@@ -160,6 +171,7 @@ function verify(message, sig, xpub) {
 module.exports = {
     fromSeed2: fromSeed2,
     fromSeed: generateFromSeed,
+    fromEntropy,
     generateFromSeed: generateFromSeed,
     derivePrivate: derivePrivate,
     derivePublic: derivePublic,

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "bip32-ed25519",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "main": "index.js",
   "scripts": {},
   "dependencies": {
-    "bn.js": "^5.1.1",
-    "elliptic": "^6.5.4",
-    "hash.js": "^1.1.7"
+    "bn.js": "^5.2.3",
+    "elliptic": "^6.6.1",
+    "hash.js": "^1.1.7",
+    "pbkdf2": "^3.1.5"
   },
   "devDependencies": {
+    "bip39": "^3.1.0",
     "mocha": "^10.3.0",
     "should": "^11.2.1"
   },

package/test/derive.test.js

@@ -1,7 +1,8 @@
 var should = require('should');
+var bip39 = require('bip39');
 
-var bip32Edd25519 = require('../index');
-var eddsa = bip32Edd25519.eddsa;
+var bip32Ed25519 = require('../index');
+var eddsa = bip32Ed25519.eddsa;
 
 describe('derive', function() {
 
@@ -9,19 +10,19 @@ describe('derive', function() {
 
     it('general', function(done) {
         var seed = Buffer.from('e2282f95e0c16a0f2837553c9000c22c82d87e667b5ded17b26d15bdb60245f0e89067d412aa8c41caa4dfbbdcf8fd3095cb974c0104bc0a9309491f929681e1', 'hex');
-        var xprv = bip32Edd25519.generateFromSeed(seed);
+        var xprv = bip32Ed25519.generateFromSeed(seed);
         console.log('xprv:', xprv.toString('hex'));
 
-        var xpub = bip32Edd25519.toPublic(xprv);
+        var xpub = bip32Ed25519.toPublic(xprv);
         console.log('xpub:', xpub.toString('hex'));
 
         var total = 10000000;
         for (var i = 0; i < 100000; i++) {
             var index = parseInt(Math.random() * 100000);
             console.log('[' + i + '/' + total + '] ' + index);
-            var derivedPrivateKey = bip32Edd25519.derivePrivate(xprv, index);
-            var derivedPublicKey = bip32Edd25519.derivePublic(xpub, index);
-            var toPublicKey = bip32Edd25519.toPublic(derivedPrivateKey);
+            var derivedPrivateKey = bip32Ed25519.derivePrivate(xprv, index);
+            var derivedPublicKey = bip32Ed25519.derivePublic(xpub, index);
+            var toPublicKey = bip32Ed25519.toPublic(derivedPrivateKey);
 
             should.equal(derivedPublicKey.toString('hex'), toPublicKey.toString('hex'));
 
@@ -30,8 +31,8 @@ describe('derive', function() {
             should.equal(derivedPublicKey.slice(0, 32).toString('hex'), publicKey.toString('hex'));
 
             var message = Buffer.from('hello world');
-            var sig = bip32Edd25519.sign(message, derivedPrivateKey);
-            var verify = bip32Edd25519.verify(message, sig, derivedPublicKey);
+            var sig = bip32Ed25519.sign(message, derivedPrivateKey);
+            var verify = bip32Ed25519.verify(message, sig, derivedPublicKey);
             should.equal(verify, true, 'verify failed: index=' + index)
         }
 
@@ -42,33 +43,60 @@ describe('derive', function() {
         var seed = Buffer.from('3660a6289d878f317fa7b180ce0b375178bd5ffe0ada03fca6905255fe25028166c802750d85f90bb0123b07608bbcfbc6b1be84519d68f37935e2a2a4b43cfe', 'hex');
         var path = 'm/53686/60791/4984';
 
-        var xprv = bip32Edd25519.generateFromSeed(seed);
+        var xprv = bip32Ed25519.generateFromSeed(seed);
         console.log('xprv:', xprv.toString('hex'));
 
-        var xpub = bip32Edd25519.toPublic(xprv);
+        var xpub = bip32Ed25519.toPublic(xprv);
         console.log('xpub:', xpub.toString('hex'));
 
         var indexes = path.split('/').slice(1);
-        var xprv = bip32Edd25519.generateFromSeed(seed);
-        var xpub = bip32Edd25519.toPublic(xprv);
+        var xprv = bip32Ed25519.generateFromSeed(seed);
+        var xpub = bip32Ed25519.toPublic(xprv);
 
         var derivedPrivateKey = xprv;
         var derivedPublicKey = xpub;
 
         for (var j = 0; j < indexes.length; j++) {
-            derivedPrivateKey = bip32Edd25519.derivePrivate(derivedPrivateKey, parseInt(indexes[j]));
-            derivedPublicKey = bip32Edd25519.derivePublic(derivedPublicKey, parseInt(indexes[j]));
+            derivedPrivateKey = bip32Ed25519.derivePrivate(derivedPrivateKey, parseInt(indexes[j]));
+            derivedPublicKey = bip32Ed25519.derivePublic(derivedPublicKey, parseInt(indexes[j]));
 
             const keyPair = eddsa.keyFromSecret(derivedPrivateKey.slice(0, 32));
             var publicKey = Buffer.from(keyPair.getPublic(true, true));
             should.equal(derivedPublicKey.slice(0, 32).toString('hex'), publicKey.toString('hex'));
 
             var message = Buffer.from('hello world');
-            var sig = bip32Edd25519.sign(message, derivedPrivateKey);
-            var verify = bip32Edd25519.verify(message, sig, derivedPublicKey);
+            var sig = bip32Ed25519.sign(message, derivedPrivateKey);
+            var verify = bip32Ed25519.verify(message, sig, derivedPublicKey);
             should.equal(verify, true, 'verify failed')
         }
 
         done();
     });
+
+    it('fromEntropy', function(done) {
+        const mnemonic = 'expire found smooth ride piece swamp blast model slot fiction under gate escape animal reform'
+
+        const path1 = "m/44'/1815'/0'"
+        const expectedPublicKey1 = "ac9f7fabfa177eb5f5c44ae2a6bf84ede53bdbc256db64f22e9bcfdd8a82fb14015b1f5744f995b434f26e597e7aeae8c053a59fcb69aedf5c8c218846063eff"
+        const path2 = "m/1852'/1815'/0'"
+        const expectedPublicKey2 = "6b8d464521e3c433c33837a7aca2b70baaef19d48b8984f7a0eba66e32f3b62aedbdac20b6aa6bef253c15f9779487d6a5601ec35b915070c5370dceee11bd56"
+
+        let key1 = bip32Ed25519.fromEntropy(Buffer.from(bip39.mnemonicToEntropy(mnemonic), 'hex'))
+        let arr1 = path1.split("/")
+        for (let i = 1; i < arr1.length; i++) {
+            key1 = bip32Ed25519.derivePrivate(key1, arr1[i].indexOf("'") > 0 ? (parseInt(arr1[i].slice(0, arr1[i].length - 1)) + 0x80000000) : parseInt(arr1[i]))
+        }
+        console.log(bip32Ed25519.toPublic(key1).toString('hex'))
+        should.equal(bip32Ed25519.toPublic(key1).toString('hex'), expectedPublicKey1);
+
+        let key2 = bip32Ed25519.fromEntropy(Buffer.from(bip39.mnemonicToEntropy(mnemonic), 'hex'))
+        let arr2 = path2.split("/")
+        for (let i = 1; i < arr2.length; i++) {
+            key2 = bip32Ed25519.derivePrivate(key2, arr2[i].indexOf("'") > 0 ? (parseInt(arr2[i].slice(0, arr2[i].length - 1)) + 0x80000000) : parseInt(arr2[i]))
+        }
+        console.log(bip32Ed25519.toPublic(key2).toString('hex'))
+        should.equal(bip32Ed25519.toPublic(key2).toString('hex'), expectedPublicKey2);
+
+        done();
+    });
 });