import pls work

hdkey.ts

@@ -1,4 +1,4 @@
-const HDKey = require('hdkey');
+const hdKey = require('hdkey');
 const bitcoin = require('bitcoinjs-lib');
 const bip39 = require('bip39')
 const assert = require('bsert');
@@ -7,127 +7,132 @@ export
 type network = 'testnet' | 'mainnet'
 export
 type keyType =  "public" | "private"
-/**
- * Generate a BIP39 menemonic
- */
-export function  randomMenemonic():string{
-    return bip39.generateMnemonic()
-}
-
-/**
- * Generate a pseudo-random seed from BIP39 menemonic
- * @param menemonic 
- */
-export function  seedFromMenemonic(menemonic:string):string{
-    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
- */
-export function  deriveAccount(seed:string, net:network = "mainnet", n:number = 0):{publicExtendedKey:string, privateExtendedKey:string}{
-    assert(n >= 0)
+class HDKey{
+    /**
+     * Generate a BIP39 menemonic
+     */
+    randomMenemonic():string{
+        return bip39.generateMnemonic()
+    }
 
-    let version
-    if(net === 'testnet'){
-        version = {private: 0x04358394, public: 0x043587CF} // HDKey does not support testnet keys out of the box
+    /**
+     * Generate a pseudo-random seed from BIP39 menemonic
+     * @param menemonic 
+     */
+    seedFromMenemonic(menemonic:string):string{
+        assert(bip39.validateMnemonic(menemonic))
+        return bip39.mnemonicToSeedSync(menemonic).toString('hex')
     }
-    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/
+    /**
+     * 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
+     */
+    deriveAccount(seed:string, net:network = "mainnet", n:number = 0):{publicExtendedKey:string, privateExtendedKey:string}{
+        assert(n >= 0)
 
-// 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
- */
-export function  generateAddress(extendedKey:string, n:number = 0):string{
-    assert(n >= 0)
-    let version
-    let t = checkHDKey(extendedKey)
-    if(!t){
-        throw new Error("Not an extended key: "+extendedKey)
-    }
-    if(t.net == "testnet"){
-        version = {private: 0x04358394, public: 0x043587CF} //HDKey does not support testnet keys out of the box
+        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
     }
-    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
-}
 
+    //doc https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki
+    //lib https://github.com/cryptocoinjs/hdkey
+    //gen http://bip32.org/
 
-export function  HDKeyFromExtendedKey(extendedKeyB58: string): any | false{
-    let hdkey
-    let version
-    let t = checkHDKey(extendedKeyB58)
-    if(!t){
-        return false
-    }
-    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)
+    // 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
+     */
+    generateAddress(extendedKey:string, n:number = 0):string{
+        assert(n >= 0)
+        let version
+        let t = this.checkHDKey(extendedKey)
+        if(!t){
+            throw new Error("Not an extended key: "+extendedKey)
+        }
+        if(t.net == "testnet"){
+            version = {private: 0x04358394, public: 0x043587CF} //HDKey does not support testnet keys out of the box
+        }
+        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
     }
-    return hdkey
-}
 
-export function  checkHDKey(key: string): {net: network, type: keyType} | false{
-    if(key.startsWith('x')){
-        if(key.startsWith('xpub')){
-            return {net:'mainnet', type: 'public'}
-        }else{
-            return {net:'mainnet', type: 'private'}
+
+    HDKeyFromExtendedKey(extendedKeyB58: string): any | false{
+        let hdkey
+        let version
+        let t = this.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{
-            return {net:'testnet', type: 'private'}
+            hdkey = hdkey.fromExtendedKey(extendedKeyB58, version)
         }
+        return hdkey
     }
-    return false
-}
 
-export function  deriveAddress(extendedKey: string, n: number, derivationPrefix = 'm/0/'): string | false{
-    let t = checkHDKey(extendedKey)
-    let childkey = deriveKey(extendedKey, n, derivationPrefix)
-    if(!t || !childkey){
+    checkHDKey(key: string): {net: network, type: keyType} | false{
+        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
     }
-    return addressFromHDKey(childkey._publicKey, t.net)
-}
 
-export function  deriveKey(extendedKey: string, n: number, derivationPrefix = 'm/0/'): any | false{
-    let t = checkHDKey(extendedKey)
-    let hdkey = HDKeyFromExtendedKey(extendedKey)
-    if(!t || !hdkey){
-        return false
+    deriveAddress(extendedKey: string, n: number, derivationPrefix = 'm/0/'): string | false{
+        let t = this.checkHDKey(extendedKey)
+        let childkey = this.deriveKey(extendedKey, n, derivationPrefix)
+        if(!t || !childkey){
+            return false
+        }
+        return this.addressFromHDKey(childkey._publicKey, t.net)
+    }
+
+    deriveKey(extendedKey: string, n: number, derivationPrefix = 'm/0/'): any | false{
+        let t = this.checkHDKey(extendedKey)
+        let hdkey = this.HDKeyFromExtendedKey(extendedKey)
+        if(!t || !hdkey){
+            return false
+        }
+        return hdkey.derive(derivationPrefix+n)
+    }
+
+    addressFromHDKey(hdkey:string, net: network = "mainnet"){
+        return <string>bitcoin.payments.p2pkh({ pubkey: Buffer.from(hdkey), network: bitcoin.networks[net] }).address
     }
-    return hdkey.derive(derivationPrefix+n)
 }
 
-export function  addressFromHDKey(hdkey:string, net: network = "mainnet"){
-    return <string>bitcoin.payments.p2pkh({ pubkey: Buffer.from(hdkey), network: bitcoin.networks[net] }).address
-}
+export const hdkey = new HDKey()

package.json

@@ -1,6 +1,6 @@
 {
   "name": "btc-hdkey",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "Hierarchical Deterministic Wallet support for BTC",
   "main": "hdkey.min.js",
   "types": "hdkey.d.ts",