keys.deriveKey(password, plain.salt, null, function (derivedKey) {
if (derivedKey.error) return onRegistered(derivedKey);
if (!Buffer.isBuffer(derivedKey)) {
derivedKey = new Buffer(derivedKey, "hex");
}
var encryptedPrivateKey = new Buffer(keys.encrypt(
plain.privateKey,
derivedKey.slice(0, 16),
plain.iv
), "base64").toString("hex");
// encrypt private key using derived key and IV, then
// store encrypted key & IV, indexed by handle
var keystore = {
address: abi.format_address(keys.privateKeyToAddress(plain.privateKey)),
crypto: {
cipher: keys.constants.cipher,
ciphertext: encryptedPrivateKey,
cipherparams: {iv: plain.iv.toString("hex")},
kdf: constants.KDF,
kdfparams: {
c: keys.constants[constants.KDF].c,
dklen: keys.constants[constants.KDF].dklen,
prf: keys.constants[constants.KDF].prf,
salt: plain.salt.toString("hex")
},
mac: keys.getMAC(derivedKey, encryptedPrivateKey)
},
version: 3,
id: uuid.v4()
};
augur.db.put(handle, keystore, function (result) {
if (!result) return onRegistered(errors.DB_WRITE_FAILED);
if (result.error) return onRegistered(result);
// set web.account object
self.account = {
handle: handle,
privateKey: plain.privateKey,
address: keystore.address,
keystore: keystore
};
console.log("account:", self.account);
if (options.persist) {
augur.db.putPersistent(self.account);
}
augur.ramble.invoke = self.invoke;
augur.ramble.context = self;
augur.ramble.from = self.account.address;
if (options.doNotFund) return onRegistered(self.account);
self.fund(self.account, augur.branches.dev, onRegistered, onSendEther, onSent, onSuccess, onFailed);
}); // augur.db.put
}); // deriveKey
keythereum.exportToFile(keyObject, path.resolve('./wallets'), function (filePath) {
let resultWallet = {
address: keythereum.privateKeyToAddress(dk.privateKey),
privateKey: dk.privateKey.toString('hex'),
filePath: filePath.replace('/root/wtchatnew', ''),
passwordKeystore: pass_wallet
};
let ETHbalance = 0, ABABCoinBalance = 0, ETHUSDbalance = 0;
if (web3.isConnected()) {
ETHbalance = +(+web3.eth.getBalance(resultWallet.address) / 1000000000000000000).toFixed(8);
// ABABCoinBalance = (+contract.balanceOf(resultWallet.address) / sol_config._contract_fixed).toFixed(2);
ETHUSDbalance = ETHbalance * rateETHUSD;
}
new db.wallets({
user: db.mongoose.Types.ObjectId(user._id),
active: true,
type: param.type,
wallet: {
address: resultWallet.address,
balance: {
eth: ETHbalance,
abab: ABABCoinBalance,
ethusd: ETHUSDbalance,
},
KeystoreURL: resultWallet.filePath,
PrivateKey: resultWallet.privateKey,
passwordKeystore: resultWallet.passwordKeystore
}
}).save().then(function (res) {
return callback && callback(null, {
user_id: res.user_id,
active: res.active,
type: res.type,
wallet: {
address: res.wallet.address,
approve: res.wallet.approve,
balance: res.wallet.balance,
KeystoreURL: res.wallet.KeystoreURL,
PrivateKey: res.wallet.PrivateKey,
passwordKeystore: res.wallet.passwordKeystore
}
})
}).catch(function (err) {
return callback && callback(null, {
error: error.api(err.message, 'db', err, 9),
success: false
});
});
});
function getPrivateKeyFromString(privateKey) {
privateKey = Buffer.from(speedomatic.strip0xPrefix(privateKey), "hex");
var address = keythereum.privateKeyToAddress(privateKey);
if (debugOptions.cannedMarkets) console.log(chalk.green.dim("sender:"), chalk.green(address));
return { accountType: "privateKey", signer: privateKey, address: address };
}