function generateAddress(prefix) {
var ecdh = createECDH('secp256k1'),
publicPrefix = prefix || defaultPrefix,
privatePrefix = ((Number('0x' + publicPrefix) + 128) % 256).toString(16);
privatePrefix = (privatePrefix.length === 1) ? '0' + privatePrefix : privatePrefix;
ecdh.generateKeys();
var publicKey = ecdh.getPublicKey(),
privateKey = ecdh.getPrivateKey('hex');
var sha256hash = createHash('sha256').update(publicKey).digest(),
ripemd160hash = ripemd160(sha256hash),
ripemd160hashX = publicPrefix + ripemd160hash.toString('hex'),
base58Public = base58check.encode(new Buffer(ripemd160hashX, 'hex')),
base58Private = base58check.encode(new Buffer(privatePrefix + privateKey, 'hex'));
return {
address: base58Public,
keys: {
public: {
hex: publicKey.toString('hex').toUpperCase()
},
private: {
hex: privateKey.toString('hex').toUpperCase(),
b58: base58Private
}
}
};
}
function encode (version, privateKey, compressed) {
if (typeof version === 'number') return bs58check.encode(encodeRaw(version, privateKey, compressed))
return bs58check.encode(
encodeRaw(
version.version,
version.privateKey,
version.compressed
)
)
}
Address.prototype.toBase58Check = function () {
var payload = new Buffer(21)
payload.writeUInt8(this.version, 0)
this.hash.copy(payload, 1)
return base58check.encode(payload)
}
lazy.prop(o, 'address', function () {
if (!o.hash) return
const payload = Buffer.allocUnsafe(21)
payload.writeUInt8(network.scriptHash, 0)
o.hash.copy(payload, 1)
return bs58check.encode(payload)
})
function getAddress (d, compressed) {
var Q = curve.G.multiply(d).getEncoded(compressed)
var hash = hash160(Q)
var payload = Buffer.allocUnsafe(21)
payload.writeUInt8(0x00, 0) // XXX TODO FIXME bitcoin only??? damn you BIP38
hash.copy(payload, 1)
return bs58check.encode(payload)
}
function toBase58Check (hash, version) {
typeforce(types.tuple(types.Hash160bit, types.UInt8), arguments)
var payload = new Buffer(21)
payload.writeUInt8(version, 0)
hash.copy(payload, 1)
return bs58check.encode(payload)
}
ECPair.prototype.getAddress = function () {
var pubKey = this.getPublicKeyBuffer()
var pubKeyHash = bcrypto.hash160(pubKey)
var payload = new Buffer(21)
payload.writeUInt8(this.network.pubKeyHash, 0)
pubKeyHash.copy(payload, 1)
return bs58check.encode(payload)
}
HDNode.prototype.getSerializedPublicKey = function () {
var buffer = new Buffer(78)
buffer.writeUInt32BE(network.bip32.public, 0)
buffer.writeUInt8(this.depth, 4)
buffer.writeUInt32BE(this.parentFingerprint, 5)
buffer.writeUInt32BE(this.index, 9)
this.chainCode.copy(buffer, 13)
this.getPublicKey().copy(buffer, 45)
return base58check.encode(buffer)
}
HDNode.prototype.getSerializedPrivateKey = function () {
if (this.isNeutered()) throw new Error('HDNode is neutered')
var buffer = new Buffer(78)
buffer.writeUInt32BE(network.bip32.private, 0)
buffer.writeUInt8(this.depth, 4)
buffer.writeUInt32BE(this.parentFingerprint, 5)
buffer.writeUInt32BE(this.index, 9)
this.chainCode.copy(buffer, 13)
buffer.writeUInt8(0, 45)
this.privateKey.copy(buffer, 46)
return base58check.encode(buffer)
}
ECKey.prototype.toWIF = function(network) {
network = network || networks.bitcoin
var bufferLen = this.pub.compressed ? 34 : 33
var buffer = new Buffer(bufferLen)
buffer.writeUInt8(network.wif, 0)
this.d.toBuffer(32).copy(buffer, 1)
if (this.pub.compressed) {
buffer.writeUInt8(0x01, 33)
}
return base58check.encode(buffer)
}
var createXpub = function(depth, fingerprint, childnum, chainCode, publicKey, testnet) {
var xpub;
if (testnet) {
xpub = new ByteString("043587CF", GP.HEX);
}
else {
xpub = new ByteString("0488B21E", GP.HEX);
}
xpub = xpub.concat(new ByteString(Convert.toHexByte(depth), GP.HEX));
xpub = xpub.concat(fingerprint);
xpub = xpub.concat(childnum);
xpub = xpub.concat(chainCode);
xpub = xpub.concat(publicKey);
return base58check.encode(xpub.toBuffer());
}
HDNode.prototype.toBase58 = function (__isPrivate) {
assert.strictEqual(__isPrivate, undefined, 'Unsupported argument in 2.0.0')
// Version
var network = this.keyPair.network
var version = this.keyPair.d ? network.bip32.private : network.bip32.public
var buffer = new Buffer(HDNode.LENGTH)
// 4 bytes: version bytes
buffer.writeUInt32BE(version, 0)
// Depth
// 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ....
buffer.writeUInt8(this.depth, 4)
// 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)
buffer.writeUInt32BE(this.parentFingerprint, 5)
// 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.
// This is encoded in Big endian. (0x00000000 if master key)
buffer.writeUInt32BE(this.index, 9)
// 32 bytes: the chain code
this.chainCode.copy(buffer, 13)
// 33 bytes: the public key or private key data
if (this.keyPair.d) {
// 0x00 + k for private keys
buffer.writeUInt8(0, 45)
this.keyPair.d.toBuffer(32).copy(buffer, 46)
// 33 bytes: the public key
} else {
// X9.62 encoding for public keys
this.keyPair.getPublicKeyBuffer().copy(buffer, 45)
}
return base58check.encode(buffer)
}
stream.on('data', function (row) { addresses.push(base58check.encode(row.address.buffer)) })
get: function () {
var pkhex = this.key.getPublic('hex');
var buffer = new Buffer(pkhex, 'hex');
var bs58hash = bs58check.encode(buffer);
return bs58hash;
}
get: function () {
var rmd160buffer = this.publicKeyrmd160;
var bs58pk = bs58check.encode(rmd160buffer);
return bs58pk;
}
function encode (version, d, compressed) {
return bs58check.encode(encodeRaw(version, d, compressed))
}
function ypubToXpub(ypub) {
var data = b58.decode(ypub)
data = data.slice(4)
data = Buffer.concat([Buffer.from('0488b21e', 'hex'), data])
return b58.encode(data)
}
HDNode.prototype.toBase58 = function() {
return base58check.encode(this.toBuffer())
}
function encrypt (buffer, compressed, passphrase, progressCallback, scryptParams) {
return bs58check.encode(encryptRaw(buffer, compressed, passphrase, progressCallback, scryptParams))
}
HDNode.prototype.toBase58 = function(isPrivate) {
return base58check.encode(this.toBuffer(isPrivate, true))
}