btc-hdkey - npm Package Compare versions

Comparing version 0.0.4 to 0.0.5

index.d.ts

@@ -6,3 +6,3 @@ export declare type network = 'testnet' | 'mainnet';
  */
-export declare function randomMenemonic(): string;
+declare function randomMenemonic(): string;
 /**
@@ -12,3 +12,3 @@ * Generate a pseudo-random seed from BIP39 menemonic
  */
-export declare function seedFromMenemonic(menemonic: string): string;
+declare function seedFromMenemonic(menemonic: string): string;
 /**
@@ -20,3 +20,3 @@ * Derive an extended keypair from seed
  */
-export declare function deriveAccount(seed: string, net?: network, n?: number): {
+declare function deriveAccount(seed: string, net?: network, n?: number): {
     publicExtendedKey: string;
@@ -31,10 +31,15 @@ privateExtendedKey: string;
  */
-export declare function generateAddress(extendedKey: string, n?: number): string;
-export declare function HDKeyFromExtendedKey(extendedKeyB58: string): any | false;
-export declare function checkHDKey(key: string): {
-    net: network;
-    type: keyType;
-} | false;
-export declare function deriveAddress(extendedKey: string, n: number, derivationPrefix?: string): string | false;
-export declare function deriveKey(extendedKey: string, n: number, derivationPrefix?: string): any | false;
-export declare function addressFromHDKey(hdkey: string, net?: network): string;
+declare function generateAddress(extendedKey: string, n?: number): string;
+declare function HDKeyFromExtendedKey(extendedKeyB58: string): any | false;
+declare function deriveAddress(extendedKey: string, n: number, derivationPrefix?: string): string | false;
+declare function addressFromHDKey(hdkey: string, net?: network): string;
+export declare const exprt: {
+    addressFromHDKey: typeof addressFromHDKey;
+    deriveAccount: typeof deriveAccount;
+    deriveAddress: typeof deriveAddress;
+    generateAddress: typeof generateAddress;
+    HDKeyFromExtendedKey: typeof HDKeyFromExtendedKey;
+    seedFromMenemonic: typeof seedFromMenemonic;
+    randomMenemonic: typeof randomMenemonic;
+};
+export {};

index.js

@@ -1,141 +0,132 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HDKey = require('hdkey');
+const bitcoin = require('bitcoinjs-lib');
+const bip39 = require('bip39');
+const assert = require('bsert');
+/**
+ * Generate a BIP39 menemonic
+ */
+function randomMenemonic() {
+    return bip39.generateMnemonic();
+}
+/**
+ * Generate a pseudo-random seed from BIP39 menemonic
+ * @param menemonic
+ */
+function seedFromMenemonic(menemonic) {
+    assert(bip39.validateMnemonic(menemonic));
+    return bip39.mnemonicToSeedSync(menemonic).toString('hex');
+}
+/**
+ * Derive an extended keypair from seed
+ * @param seed The seed-string to use for generating the HDKey
+ * @param net Network to use ("testnet", "mainnet")
+ * @param n n-th derived keypair default:0
+ */
+function deriveAccount(seed, net = "mainnet", n = 0) {
+    assert(n >= 0);
+    let version;
+    if (net === 'testnet') {
+        version = { private: 0x04358394, public: 0x043587CF }; // HDKey does not support testnet keys out of the box
     }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports"], factory);
+    let rootKey = HDKey.fromMasterSeed(seed, version);
+    let childKey = rootKey.derive('m/' + n + '\'');
+    childKey.network = version;
+    return childKey;
+}
+//doc https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+//lib https://github.com/cryptocoinjs/hdkey
+//gen http://bip32.org/
+// enter bip32  key of the following formats:
+// - extended public mainnet key  (xpub prefix) 
+// - extended private mainnet key (xprv prefix) (not reccomended)
+// - extended public testnet key  (tpub prefix) 
+// - extended private testnet key (tprv prefix) (not reccomended)
+/**
+ *
+ * @param extendedKey Extended key to generate address from
+ * @param networkName Network to use ("testnet", "mainnet")
+ * @param n n-th derived address default:0
+ */
+function generateAddress(extendedKey, n = 0) {
+    assert(n >= 0);
+    let version;
+    let t = checkHDKey(extendedKey);
+    if (!t) {
+        throw new Error("Not an extended key: " + extendedKey);
     }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    const HDKey = require('hdkey');
-    const bitcoin = require('bitcoinjs-lib');
-    const bip39 = require('bip39');
-    const assert = require('bsert');
-    /**
-     * Generate a BIP39 menemonic
-     */
-    function randomMenemonic() {
-        return bip39.generateMnemonic();
+    if (t.net == "testnet") {
+        version = { private: 0x04358394, public: 0x043587CF }; //HDKey does not support testnet keys out of the box
     }
-    exports.randomMenemonic = randomMenemonic;
-    /**
-     * Generate a pseudo-random seed from BIP39 menemonic
-     * @param menemonic
-     */
-    function seedFromMenemonic(menemonic) {
-        assert(bip39.validateMnemonic(menemonic));
-        return bip39.mnemonicToSeedSync(menemonic).toString('hex');
+    const hdkey = HDKey.fromExtendedKey(extendedKey, version);
+    const childkey = hdkey.derive('m/0/' + n);
+    const address = bitcoin.payments.p2pkh({ pubkey: childkey._publicKey, network: bitcoin.networks[t.net] }).address;
+    return address;
+}
+function HDKeyFromExtendedKey(extendedKeyB58) {
+    let hdkey;
+    let version;
+    let t = checkHDKey(extendedKeyB58);
+    if (!t) {
+        return false;
     }
-    exports.seedFromMenemonic = seedFromMenemonic;
-    /**
-     * Derive an extended keypair from seed
-     * @param seed The seed-string to use for generating the HDKey
-     * @param net Network to use ("testnet", "mainnet")
-     * @param n n-th derived keypair default:0
-     */
-    function deriveAccount(seed, net = "mainnet", n = 0) {
-        assert(n >= 0);
-        let version;
-        if (net === 'testnet') {
-            version = { private: 0x04358394, public: 0x043587CF }; // HDKey does not support testnet keys out of the box
-        }
-        let rootKey = HDKey.fromMasterSeed(seed, version);
-        let childKey = rootKey.derive('m/' + n + '\'');
-        childKey.network = version;
-        return childKey;
+    if (t.net === 'testnet') {
+        version = { private: 0x04358394, public: 0x043587CF }; // HDKey does not support testnet keys out of the box
     }
-    exports.deriveAccount = deriveAccount;
-    //doc https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
-    //lib https://github.com/cryptocoinjs/hdkey
-    //gen http://bip32.org/
-    // enter bip32  key of the following formats:
-    // - extended public mainnet key  (xpub prefix) 
-    // - extended private mainnet key (xprv prefix) (not reccomended)
-    // - extended public testnet key  (tpub prefix) 
-    // - extended private testnet key (tprv prefix) (not reccomended)
-    /**
-     *
-     * @param extendedKey Extended key to generate address from
-     * @param networkName Network to use ("testnet", "mainnet")
-     * @param n n-th derived address default:0
-     */
-    function generateAddress(extendedKey, n = 0) {
-        assert(n >= 0);
-        let version;
-        let t = checkHDKey(extendedKey);
-        if (!t) {
-            throw new Error("Not an extended key: " + extendedKey);
+    if (t.type === 'public') {
+        hdkey = HDKey.fromExtendedKey(extendedKeyB58, version);
+    }
+    else {
+        hdkey = HDKey.fromExtendedKey(extendedKeyB58, version);
+    }
+    return hdkey;
+}
+function checkHDKey(key) {
+    if (key.startsWith('x')) {
+        if (key.startsWith('xpub')) {
+            return { net: 'mainnet', type: 'public' };
         }
-        if (t.net == "testnet") {
-            version = { private: 0x04358394, public: 0x043587CF }; //HDKey does not support testnet keys out of the box
+        else {
+            return { net: 'mainnet', type: 'private' };
         }
-        const hdkey = HDKey.fromExtendedKey(extendedKey, version);
-        const childkey = hdkey.derive('m/0/' + n);
-        const address = bitcoin.payments.p2pkh({ pubkey: childkey._publicKey, network: bitcoin.networks[t.net] }).address;
-        return address;
     }
-    exports.generateAddress = generateAddress;
-    function HDKeyFromExtendedKey(extendedKeyB58) {
-        let hdkey;
-        let version;
-        let t = checkHDKey(extendedKeyB58);
-        if (!t) {
-            return false;
+    if (key.startsWith('t')) {
+        if (key.startsWith('tpub')) {
+            return { net: 'testnet', type: 'public' };
         }
-        if (t.net === 'testnet') {
-            version = { private: 0x04358394, public: 0x043587CF }; // HDKey does not support testnet keys out of the box
-        }
-        if (t.type === 'public') {
-            hdkey = HDKey.fromExtendedKey(extendedKeyB58, version);
-        }
         else {
-            hdkey = HDKey.fromExtendedKey(extendedKeyB58, version);
+            return { net: 'testnet', type: 'private' };
         }
-        return hdkey;
     }
-    exports.HDKeyFromExtendedKey = HDKeyFromExtendedKey;
-    function checkHDKey(key) {
-        if (key.startsWith('x')) {
-            if (key.startsWith('xpub')) {
-                return { net: 'mainnet', type: 'public' };
-            }
-            else {
-                return { net: 'mainnet', type: 'private' };
-            }
-        }
-        if (key.startsWith('t')) {
-            if (key.startsWith('tpub')) {
-                return { net: 'testnet', type: 'public' };
-            }
-            else {
-                return { net: 'testnet', type: 'private' };
-            }
-        }
+    return false;
+}
+function deriveAddress(extendedKey, n, derivationPrefix = 'm/0/') {
+    let t = checkHDKey(extendedKey);
+    let childkey = deriveKey(extendedKey, n, derivationPrefix);
+    if (!t || !childkey) {
         return false;
     }
-    exports.checkHDKey = checkHDKey;
-    function deriveAddress(extendedKey, n, derivationPrefix = 'm/0/') {
-        let t = checkHDKey(extendedKey);
-        let childkey = deriveKey(extendedKey, n, derivationPrefix);
-        if (!t || !childkey) {
-            return false;
-        }
-        return addressFromHDKey(childkey._publicKey, t.net);
+    return addressFromHDKey(childkey._publicKey, t.net);
+}
+function deriveKey(extendedKey, n, derivationPrefix = 'm/0/') {
+    let t = checkHDKey(extendedKey);
+    let hdkey = HDKeyFromExtendedKey(extendedKey);
+    if (!t || !hdkey) {
+        return false;
     }
-    exports.deriveAddress = deriveAddress;
-    function deriveKey(extendedKey, n, derivationPrefix = 'm/0/') {
-        let t = checkHDKey(extendedKey);
-        let hdkey = HDKeyFromExtendedKey(extendedKey);
-        if (!t || !hdkey) {
-            return false;
-        }
-        return hdkey.derive(derivationPrefix + n);
-    }
-    exports.deriveKey = deriveKey;
-    function addressFromHDKey(hdkey, net = "mainnet") {
-        return bitcoin.payments.p2pkh({ pubkey: Buffer.from(hdkey), network: bitcoin.networks[net] }).address;
-    }
-    exports.addressFromHDKey = addressFromHDKey;
-});
+    return hdkey.derive(derivationPrefix + n);
+}
+function addressFromHDKey(hdkey, net = "mainnet") {
+    return bitcoin.payments.p2pkh({ pubkey: Buffer.from(hdkey), network: bitcoin.networks[net] }).address;
+}
+exports.exprt = {
+    addressFromHDKey: addressFromHDKey,
+    deriveAccount: deriveAccount,
+    deriveAddress: deriveAddress,
+    generateAddress: generateAddress,
+    HDKeyFromExtendedKey: HDKeyFromExtendedKey,
+    seedFromMenemonic: seedFromMenemonic,
+    randomMenemonic: randomMenemonic
+};
+module.exports = exports.exprt;

package.json

 {
   "name": "btc-hdkey",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Hierarchical Deterministic Wallet support for BTC",
@@ -5,0 +5,0 @@ "main": "index.js",

No alert changes

Worsened metrics

Total package byte prevSize

6608

decreased by-10.87%

Lines of code

173

decreased by-2.26%

No dependency changes