exports.config = function config(localConfig) {
if (localConfig) _.merge(pluginConfig, localConfig);
var bip39 = new BIP39();
pluginConfig.seed = bip39.mnemonicToSeed(pluginConfig.guid);
pluginConfig.hdwallet = Bitcoin.HDWallet.fromSeedHex(pluginConfig.seed, pluginConfig.network);
ga = new wallet(pluginConfig);
};
rl.question('Enter your mnemonic phrase or xpub key:', function(mnemonic){
if(!bip39.validateMnemonic(mnemonic)){
var hdNode = bitcoin.HDNode.fromBase58(mnemonic);
console.log("Generating addresses for pubkey: "+ mnemonic);
for(i=1;i<10;i++){
var path = '0/'+i;
var key1 = hdNode.derivePath(path);
console.log(path + ": "+key1.keyPair.getAddress());
}
}else{
console.log("Generating addresses for mnemonics: "+ mnemonic);
var seed = bip39.mnemonicToSeed(mnemonic);
var bitcoinNetwork = bitcoin.networks.bitcoin;
var hdMaster = bitcoin.HDNode.fromSeedBuffer(seed, bitcoinNetwork);
for(i=0;i<10;i++){
var path = '0/'+i;
var key1 = hdMaster.derivePath('m/44\'/0\'/0\'/'+path);
console.log(path + ": "+key1.keyPair.getAddress());
}
}
rl.close();
});
it('can export a BIP32 xpub', function () {
var mnemonic = 'praise you muffin lion enable neck grocery crumble super myself license ghost'
var seed = bip39.mnemonicToSeed(mnemonic)
var node = bitcoin.HDNode.fromSeedBuffer(seed)
var string = node.neutered().toBase58()
assert.equal(string, 'xpub661MyMwAqRbcGhVeaVfEBA25e3cP9DsJQZoE8iep5fZSxy3TnPBNBgWnMZx56oreNc48ZoTkQfatNJ9VWnQ7ZcLZcVStpaXLTeG8bGrzX3n')
})
it('can export a BIP32 xpub', () => {
const mnemonic = 'praise you muffin lion enable neck grocery crumble super myself license ghost'
const seed = bip39.mnemonicToSeed(mnemonic)
const node = bip32.fromSeed(seed)
const string = node.neutered().toBase58()
assert.strictEqual(string, 'xpub661MyMwAqRbcGhVeaVfEBA25e3cP9DsJQZoE8iep5fZSxy3TnPBNBgWnMZx56oreNc48ZoTkQfatNJ9VWnQ7ZcLZcVStpaXLTeG8bGrzX3n')
})
MyWallet.browserCheck = function () {
var mnemonic = 'daughter size twenty place alter glass small bid purse october faint beyond';
var seed = BIP39.mnemonicToSeed(mnemonic, '');
var masterkey = Bitcoin.HDNode.fromSeedBuffer(seed);
var account = masterkey.deriveHardened(44).deriveHardened(0).deriveHardened(0);
var address = account.derive(0).derive(0).getAddress();
return address === '1QBWUDG4AFL2kFmbqoZ9y4KsSpQoCTZKRw';
};
it('can export a BIP32 xpriv, then import it', function () {
var mnemonic = 'praise you muffin lion enable neck grocery crumble super myself license ghost'
var seed = bip39.mnemonicToSeed(mnemonic)
var node = bitcoin.HDNode.fromSeedBuffer(seed)
var string = node.toBase58()
var restored = bitcoin.HDNode.fromBase58(string)
assert.equal(node.getAddress(), restored.getAddress()) // same public key
assert.equal(node.keyPair.toWIF(), restored.keyPair.toWIF()) // same private key
})
it('can export a BIP32 xpriv, then import it', () => {
const mnemonic = 'praise you muffin lion enable neck grocery crumble super myself license ghost'
const seed = bip39.mnemonicToSeed(mnemonic)
const node = bip32.fromSeed(seed)
const string = node.toBase58()
const restored = bip32.fromBase58(string)
assert.strictEqual(getAddress(node), getAddress(restored)) // same public key
assert.strictEqual(node.toWIF(), restored.toWIF()) // same private key
})
self.addEventListener('message', function(e) {
var data = e.data || {}
var mnemonic = data.passphrase || bip39.entropyToMnemonic(data.entropy)
var valid = bip39.validate(mnemonic)
if(!valid) {
return self.postMessage({error: "Invalid passphrase"})
}
var seed = bip39.mnemonicToSeed(mnemonic)
self.postMessage({seed: seed, mnemonic: mnemonic})
}, false);
var main = function(program){
var mnemonic = program.mnemonic;
if(!bip39.validateMnemonic(program.mnemonic)){
console.log("invalid mnemonic");
process.exit(-1);
}
var password = program.password || undefined; // option
var network = program.network || "bitcoin";
var masterseed = bip39.mnemonicToSeed(mnemonic, password);
var hdnode = bitcoin.HDNode.fromSeedBuffer(masterseed, bitcoin.networks[network]);
var masterprv = hdnode.toBase58();
console.log(masterprv)
}
it('can create a BIP49, bitcoin testnet, account 0, external address', () => {
const mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
const seed = bip39.mnemonicToSeed(mnemonic)
const root = bip32.fromSeed(seed)
const path = "m/49'/1'/0'/0/0"
const child = root.derivePath(path)
const { address } = bitcoin.payments.p2sh({
redeem: bitcoin.payments.p2wpkh({ pubkey: child.publicKey, network: bitcoin.networks.testnet }),
network: bitcoin.networks.testnet
})
assert.strictEqual(address, '2Mww8dCYPUpKHofjgcXcBCEGmniw9CoaiD2')
})
StateManager = function(options) {
var self = this;
if (options == null) {
options = {};
}
if (options.fork) {
this.blockchain = new ForkedBlockchain(options);
} else {
this.blockchain = new BlockchainDouble(options);
}
this.vm = this.blockchain.vm;
this.stateTrie = this.blockchain.stateTrie;
this.accounts = {};
this.secure = !!options.secure;
this.account_passwords = {}
this.personal_accounts = {}
this.total_accounts = options.total_accounts || 10;
this.coinbase = null;
this.latest_filter_id = 1;
// This queue manages actions that shouldn't be run in parallel.
// The action_processing flag ensures new actions are queued instead of
// run immediately.
this.action_queue = [];
this.action_processing == false;
this.snapshots = [];
this.logger = options.logger || console;
this.net_version = options.network_id;
this.rng = seedrandom(options.seed);
this.mnemonic = options.mnemonic || bip39.entropyToMnemonic(random.randomBytes(16, this.rng).toString("hex"));
this.wallet = hdkey.fromMasterSeed(bip39.mnemonicToSeed(this.mnemonic));
this.wallet_hdpath = "m/44'/60'/0'/0/";
this.gasPriceVal = '0x4A817C800'; // 0.02 szabo
if (options.gasPrice) {
this.gasPriceVal = utils.stripHexPrefix(utils.intToHex(options.gasPrice));
}
this.is_mining = true;
this.blocktime = options.blocktime;
this.is_mining_on_interval = !!options.blocktime;
this.mining_interval_timeout = null;
}
it('can use BIP39 to generate BIP32 addresses', function () {
// var mnemonic = bip39.generateMnemonic()
var mnemonic = 'praise you muffin lion enable neck grocery crumble super myself license ghost'
assert(bip39.validateMnemonic(mnemonic))
var seed = bip39.mnemonicToSeed(mnemonic)
var root = bitcoin.HDNode.fromSeedBuffer(seed)
// receive addresses
assert.strictEqual(root.derivePath("m/0'/0/0").getAddress(), '1AVQHbGuES57wD68AJi7Gcobc3RZrfYWTC')
assert.strictEqual(root.derivePath("m/0'/0/1").getAddress(), '1Ad6nsmqDzbQo5a822C9bkvAfrYv9mc1JL')
// change addresses
assert.strictEqual(root.derivePath("m/0'/1/0").getAddress(), '1349KVc5NgedaK7DvuD4xDFxL86QN1Hvdn')
assert.strictEqual(root.derivePath("m/0'/1/1").getAddress(), '1EAvj4edpsWcSer3duybAd4KiR4bCJW5J6')
})
it('can create a BIP49, bitcoin testnet, account 0, external address', function () {
var mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about'
var seed = bip39.mnemonicToSeed(mnemonic)
var root = bitcoin.HDNode.fromSeedBuffer(seed)
var path = "m/49'/1'/0'/0/0"
var child = root.derivePath(path)
var keyhash = bitcoin.crypto.hash160(child.getPublicKeyBuffer())
var scriptSig = bitcoin.script.witnessPubKeyHash.output.encode(keyhash)
var addressBytes = bitcoin.crypto.hash160(scriptSig)
var outputScript = bitcoin.script.scriptHash.output.encode(addressBytes)
var address = bitcoin.address.fromOutputScript(outputScript, bitcoin.networks.testnet)
assert.equal(address, '2Mww8dCYPUpKHofjgcXcBCEGmniw9CoaiD2')
})
function HDWalletProvider(mnemonic, provider_url, address_index) {
this.mnemonic = mnemonic;
this.hdwallet = hdkey.fromMasterSeed(bip39.mnemonicToSeed(mnemonic));
if (address_index == null) {
address_index = 0;
}
this.wallet_hdpath = "m/44'/60'/0'/0/";
this.wallet = this.hdwallet.derivePath(this.wallet_hdpath + address_index).getWallet();
this.address = "0x" + this.wallet.getAddress().toString("hex");
this.engine = new ProviderEngine();
this.engine.addProvider(new WalletSubprovider(this.wallet, {}));
this.engine.addProvider(new FiltersSubprovider());
this.engine.addProvider(new Web3Subprovider(new Web3.providers.HttpProvider(provider_url)));
this.engine.start(); // Required by the provider engine.
};
rl.question('Enter your mnemonic phrase:', function(mnemonic){
if(!bip39.validateMnemonic(mnemonic)){
throw('Check mnemonics, it is wrong: '+ mnemonic);
}else{
console.log("Generating addresses for mnemonics: "+ mnemonic);
var h = hdkey.fromMasterSeed(bip39.mnemonicToSeed(mnemonic));
for(i=0;i<10;i++){
var path = '0/'+i;
var wallet = h.derivePath("m/44'/60'/0'/"+path).getWallet();
console.log(path + ": "+wallet.getAddressString());
}
}
rl.close();
});
var WalletSweeper = function (backupData, bitcoinDataClient, options) {
var self = this;
this.defaultSettings = {
network: 'btc',
testnet: false,
logging: false,
sweepBatchSize: 200
};
this.settings = _.merge({}, this.defaultSettings, options);
this.bitcoinDataClient = bitcoinDataClient;
this.utxoFinder = new unspentOutputFinder(bitcoinDataClient, this.settings);
this.sweepData = null;
// set the bitcoinlib network
this.network = this.getBitcoinNetwork(this.settings.network, this.settings.testnet);
backupData.walletVersion = backupData.walletVersion || 2; //default to version 2 wallets
// validate backup data, cleanup input, and prepare seeds
if (!Array.isArray(backupData.blocktrailKeys)) {
throw new Error('blocktrail pub keys are required (must be type Array)');
}
if (backupData.walletVersion == 1) {
if (typeof backupData.primaryMnemonic == "undefined" || !backupData.primaryMnemonic) {
throw new Error('missing primary mnemonic for version 1 wallet');
}
if (typeof backupData.backupMnemonic == "undefined" || !backupData.backupMnemonic) {
throw new Error('missing backup mnemonic for version 1 wallet');
}
if (typeof backupData.primaryPassphrase == "undefined") {
throw new Error('missing primary passphrase for version 1 wallet');
}
// cleanup copy paste errors from mnemonics
backupData.primaryMnemonic = backupData.primaryMnemonic.trim().replace(new RegExp("\r\n", 'g'), " ").replace(new RegExp("\n", 'g'), " ").replace(/\s+/g, " ");
backupData.backupMnemonic = backupData.backupMnemonic.trim().replace(new RegExp("\r\n", 'g'), " ").replace(new RegExp("\n", 'g'), " ").replace(/\s+/g, " ");
} else {
if (typeof backupData.encryptedPrimaryMnemonic == "undefined" || !backupData.encryptedPrimaryMnemonic) {
throw new Error('missing encrypted primary seed for version 2 wallet');
}
if (typeof backupData.backupMnemonic == "undefined" || !backupData.backupMnemonic) {
throw new Error('missing backup seed for version 2 wallet');
}
//can either recover with password and password encrypted secret, or with encrypted recovery secret and a decryption key
var usePassword = typeof backupData.password != "undefined" && backupData.password != null;
if (usePassword) {
if (typeof backupData.passwordEncryptedSecretMnemonic == "undefined" || !backupData.passwordEncryptedSecretMnemonic) {
throw new Error('missing password encrypted secret for version 2 wallet');
}
if (typeof backupData.password == "undefined") {
throw new Error('missing primary passphrase for version 2 wallet');
}
} else {
if (typeof backupData.encryptedRecoverySecretMnemonic == "undefined" || !backupData.encryptedRecoverySecretMnemonic) {
throw new Error('missing encrypted recovery secret for version 2 wallet (recovery without password)');
}
if (!backupData.recoverySecretDecryptionKey) {
throw new Error('missing recovery secret decryption key for version 2 wallet (recovery without password)');
}
}
// cleanup copy paste errors from mnemonics
backupData.encryptedPrimaryMnemonic = backupData.encryptedPrimaryMnemonic.trim().replace(new RegExp("\r\n", 'g'), " ").replace(new RegExp("\n", 'g'), " ").replace(/\s+/g, " ");
backupData.backupMnemonic = backupData.backupMnemonic.trim().replace(new RegExp("\r\n", 'g'), " ").replace(new RegExp("\n", 'g'), " ").replace(/\s+/g, " ");
if (usePassword) {
backupData.passwordEncryptedSecretMnemonic = backupData.passwordEncryptedSecretMnemonic.trim().replace(new RegExp("\r\n", 'g'), " ").replace(new RegExp("\n", 'g'), " ").replace(/\s+/g, " ");
} else {
backupData.encryptedRecoverySecretMnemonic = backupData.encryptedRecoverySecretMnemonic.trim().replace(new RegExp("\r\n", 'g'), " ").replace(new RegExp("\n", 'g'), " ").replace(/\s+/g, " ");
}
}
// create BIP32 HDNodes for the Blocktrail public keys
this.blocktrailPublicKeys = {};
_.each(backupData.blocktrailKeys, function(blocktrailKey, index) {
self.blocktrailPublicKeys[blocktrailKey['keyIndex']] = bitcoin.HDNode.fromBase58(blocktrailKey['pubkey'], self.network);
});
// convert the primary and backup mnemonics to seeds (using BIP39)
var primarySeed, backupSeed;
if (backupData.walletVersion == 1) {
primarySeed = bip39.mnemonicToSeed(backupData.primaryMnemonic, backupData.primaryPassphrase);
backupSeed = bip39.mnemonicToSeed(backupData.backupMnemonic, "");
} else {
// if a version 2 wallet, need to process backup data a bit more first...
// convert mnemonics to hex (bip39) and then base64 for decryption
backupData.encryptedPrimaryMnemonic = blocktrail.convert(bip39.mnemonicToEntropy(backupData.encryptedPrimaryMnemonic), 'hex', 'base64');
if (usePassword) {
backupData.passwordEncryptedSecretMnemonic = blocktrail.convert(bip39.mnemonicToEntropy(backupData.passwordEncryptedSecretMnemonic), 'hex', 'base64');
} else {
backupData.encryptedRecoverySecretMnemonic = blocktrail.convert(bip39.mnemonicToEntropy(backupData.encryptedRecoverySecretMnemonic), 'hex', 'base64');
}
// decrypt encryption secret
var secret;
if (usePassword) {
secret = CryptoJS.AES.decrypt(backupData.passwordEncryptedSecretMnemonic, backupData.password).toString(CryptoJS.enc.Utf8);
} else {
secret = CryptoJS.AES.decrypt(backupData.encryptedRecoverySecretMnemonic, backupData.recoverySecretDecryptionKey).toString(CryptoJS.enc.Utf8);
}
if (!secret) {
throw new Error("Could not decrypt secret with " + (usePassword ? "password" : "decryption key"));
}
// now finally decrypt the primary seed and convert to buffer (along with backup seed)
primarySeed = new Buffer(CryptoJS.AES.decrypt(backupData.encryptedPrimaryMnemonic, secret).toString(CryptoJS.enc.Utf8), 'base64');
backupSeed = new Buffer(bip39.mnemonicToEntropy(backupData.backupMnemonic), 'hex');
}
// convert the primary and backup seeds to private keys (using BIP32)
this.primaryPrivateKey = bitcoin.HDNode.fromSeedBuffer(primarySeed, this.network);
this.backupPrivateKey = bitcoin.HDNode.fromSeedBuffer(backupSeed, this.network);
if (this.settings.logging) {
console.log('using password method: ' + usePassword);
console.log("Primary Prv Key: " + this.primaryPrivateKey.toBase58());
console.log("Primary Pub Key: " + this.primaryPrivateKey.neutered().toBase58());
console.log("Backup Prv Key: " + this.backupPrivateKey.toBase58());
console.log("Backup Pub Key: " + this.backupPrivateKey.neutered().toBase58());
}
};
function getMasterHex (seedHex, bip39Password, cipher){
var mnemonic = decryptMnemonic(seedHex, cipher);
var passphrase = decryptPassphrase(bip39Password, cipher);
return BIP39.mnemonicToSeed(mnemonic, passphrase);
}
var bip39 = require('bip39');
var hdkey = require('ethereumjs-wallet/hdkey');
var mnemonic = bip39.generateMnemonic();
console.log("Mnemonics: "+mnemonic);
var h = hdkey.fromMasterSeed(bip39.mnemonicToSeed(mnemonic));
console.log("Extended PK: "+h.privateExtendedKey());
var wallet = h.derivePath("m/44'/60'/0'/0/0").getWallet();
console.log("pkey: "+ wallet.getPrivateKeyString());
console.log("Address: "+ wallet.getAddressString());