Address._deriveAddress = function(scriptType, publicKeyRing, path, m, network) {
$.checkArgument(_.contains(_.values(Constants.SCRIPT_TYPES), scriptType));
var publicKeys = _.map(publicKeyRing, function(item) {
var xpub = new Bitcore.HDPublicKey(item.xPubKey);
return xpub.derive(path).publicKey;
});
var bitcoreAddress;
switch (scriptType) {
case Constants.SCRIPT_TYPES.P2SH:
bitcoreAddress = Bitcore.Address.createMultisig(publicKeys, m, network);
break;
case Constants.SCRIPT_TYPES.P2PKH:
$.checkState(_.isArray(publicKeys) && publicKeys.length == 1);
bitcoreAddress = Bitcore.Address.fromPublicKey(publicKeys[0], network);
break;
}
return {
address: bitcoreAddress.toString(),
path: path,
publicKeys: _.invoke(publicKeys, 'toString'),
};
};
function cmdAccountAddress(newAddr)
{
var privkeyObj = wallet.privkeys[0];
var acctObj = wallet.accounts[wallet.defaultAccount];
// Select last|next key to display|generate
var keyIndex;
if (newAddr)
keyIndex = acctObj.nextKey;
else {
if (acctObj.nextKey == 0) {
console.error("no key yet generated");
return;
}
keyIndex = acctObj.nextKey - 1;
}
// Verify this is BIP 44 etc. compatible
var hdpath_hard = "m/44'/0'/" +
acctObj.index.toString() + "'";
var hdpath_pub = "m/0/" +
keyIndex.toString();
// Get pubkey for hardened path
var hdpriv = new bitcore.HDPrivateKey(privkeyObj.data);
var derivedKey = hdpriv.derive(hdpath_hard);
var hdpub = derivedKey.hdPublicKey;
// Derive address for public path
var address = new bitcore.Address(hdpub.derive(hdpath_pub).publicKey,
network);
// Output [generated] address
var addressStr = address.toString();
console.log(addressStr);
// If creating a new address, store new cache entry
if (newAddr) {
var matchObj = {
address: addressStr,
createTime: getUnixtime(),
account: acctObj.name,
acctIndex: acctObj.index,
keyIndex: keyIndex,
change: false,
};
acctObj.nextKey++;
modified = true;
wcache.matchAddresses[addressStr] = matchObj;
wcacheModified = true;
}
}
Network.prototype._verifyMessage = function(message, contact, callback) {
if (!utils.isCompatibleVersion(contact.protocol)) {
this._router.removeContact(contact);
return callback(new Error('Protocol version is incompatible'));
}
var messagekey = kad.Message.isRequest(message) ? 'params' : 'result';
var nonce = message[messagekey].nonce;
var signature = message[messagekey].signature;
if (Date.now() > (constants.NONCE_EXPIRE + nonce)) {
return callback(new Error('Message signature expired'));
}
var addr = bitcore.Address.fromPublicKeyHash(Buffer(contact.nodeID, 'hex'));
var signobj = this._createSignatureObject(signature);
this._verifySignature({
message: message,
nonce: nonce,
signobj: signobj,
address: addr,
contact: contact,
signature: signature
}, callback);
};
CWPrivateKey.prototype.isValid = function() {
try {
return bitcore.Address.isValid(this.getAddress(), NETWORK, bitcore.Address.Pay2PubKeyHash);
} catch (err) {
return false;
}
}
CWBitcore.isValidAddress = function(val) {
try {
return bitcore.Address.isValid(val, NETWORK, bitcore.Address.Pay2PubKeyHash);
} catch (err) {
return false;
}
};
this._validateContact(contact, function(err) {
if (err && Network.RPC_VALIDATION_EXEMPT.indexOf(message.method) === -1) {
return callback(err);
}
var messagekey = kad.Message.isRequest(message) ? 'params' : 'result';
var nonce = message[messagekey].nonce;
var signature = message[messagekey].signature;
if (Date.now() > (constants.NONCE_EXPIRE + nonce)) {
return callback(new Error('Message signature expired'));
}
var addr = bitcore.Address.fromPublicKeyHash(Buffer(contact.nodeID, 'hex'));
var signobj = self._createSignatureObject(signature);
self._verifySignature({
message: message,
nonce: nonce,
signobj: signobj,
address: addr,
contact: contact,
signature: signature
}, callback);
});
Contract.prototype.verify = function(actor, pubkeyhash) {
var property = actor + '_signature';
var message = Message(this._getSigningData());
var address = bitcore.Address.fromPublicKeyHash(Buffer(pubkeyhash, 'hex'));
return message.verify(address, this.get(property));
};
PayPro._getPayProRefundOutputs = function(addrStr, amount) {
amount = amount.toString(10);
var output = new BitcorePayPro.Output();
var addr = new Bitcore.Address(addrStr);
var s;
if (addr.isPayToPublicKeyHash()) {
s = Bitcore.Script.buildPublicKeyHashOut(addr);
} else if (addr.isPayToScriptHash()) {
s = Bitcore.Script.buildScriptHashOut(addr);
} else {
throw new Error('Unrecognized address type ' + addr.type);
}
// console.log('PayPro refund address set to:', addrStr,s);
output.set('script', s.toBuffer());
output.set('amount', amount);
return [output];
};
CWBitcore.isValidAddress = function(val) {
try {
var p2pkh = bitcore.Address.isValid(val, NETWORK, bitcore.Address.Pay2PubKeyHash);
if (!p2pkh) {
var bech32 = bitcoinjs.address.fromBech32(val);
return typeof(bech32) !== 'undefined';
}
return p2pkh;
} catch (err) {
return false;
}
}
Network.prototype._verifyMessage = function(message, contact, callback) {
var nonce, signature;
if (!utils.isCompatibleVersion(contact.protocol)) {
return callback(new Error('Protocol version is incompatible'));
}
if (kad.Message.isRequest(message)) {
nonce = message.params.nonce;
signature = message.params.signature;
} else {
nonce = message.result.nonce;
signature = message.result.signature;
}
if (Date.now() > (constants.NONCE_EXPIRE + nonce)) {
return callback(new Error('Message signature expired'));
}
var target = message.id + nonce;
var addr = bitcore.Address.fromPublicKeyHash(Buffer(contact.nodeID, 'hex'));
var compactSig;
var signobj;
try {
compactSig = new Buffer(signature, 'base64');
signobj = bitcore.crypto.Signature.fromCompact(compactSig);
} catch (err) {
return callback(new Error('Signature verification failed'));
}
var signedmsg = Message(target);
var ecdsa = new bitcore.crypto.ECDSA();
ecdsa.hashbuf = signedmsg.magicHash();
ecdsa.sig = signobj;
this._pubkeys[contact.nodeID] = ecdsa.toPublicKey();
if (!signedmsg.verify(addr, signature)) {
return callback(new Error('Signature verification failed'));
}
callback();
};
scard.fzcRedeemScript = function(year, month, day, hours, minutes, privKey) {
var tr = scard.getLockTime(year, month, day, hours, minutes);
var redeemScript = bitcorelib.Script.empty()
// useful generic way to get the minimal encoding of the locktime stack argument
.add(bitcorelib.crypto.BN.fromNumber(tr.locktime).toScriptNumBuffer())
.add('OP_NOP2').add('OP_DROP')
.add(bitcorelib.Script.buildPublicKeyHashOut(privKey.toAddress()));
var p2shAddress = bitcorelib.Address.payingTo(redeemScript);
return {
date: tr.date,
locktime: tr.locktime,
hex: redeemScript.toHex(),
asm: redeemScript.toASM(),
redeemScript: redeemScript,
scriptPubKey: redeemScript.toScriptHashOut(),
address: p2shAddress,
privKey: privKey
}
}
CWBitcore.pubKeyToPubKeyHash = function(pubKey) {
return bitcore.Address.fromPublicKey(bitcore.PublicKey(pubKey, {network: NETWORK}), NETWORK).toString();
}
function cmdSpend(spendFn)
{
spendInfo = JSON.parse(fs.readFileSync(spendFn, 'utf8'));
var account = spendInfo.account;
var acctObj = wallet.accounts[account];
// List UTXOs for this account
var acctUtxos = [];
var privkeys = [];
for (var utxoId in wcache.unspent) {
var utxo = wcache.unspent[utxoId];
var addrInfo = wcache.matchAddresses[utxo.address];
if (addrInfo.account == account) {
var utxoObj = new bitcore.Transaction.UnspentOutput(utxo);
acctUtxos.push(utxoObj);
privkeys.push(privkeyFromAddress(utxoObj.address));
}
}
//
// Generate change address
//
// Verify this is BIP 44 etc. compatible
var keyIndex = acctObj.nextKey;
var hdpath_hard = "m/44'/0'/" +
acctObj.index.toString() + "'";
var hdpath_pub = "m/1/" +
keyIndex.toString();
// Get pubkey for hardened path
var privkeyObj = wallet.privkeys[0];
var hdpriv = new bitcore.HDPrivateKey(privkeyObj.data);
var derivedKey = hdpriv.derive(hdpath_hard);
var hdpub = derivedKey.hdPublicKey;
// Derive address for public path
var changeAddr = new bitcore.Address(hdpub.derive(hdpath_pub).publicKey,
network);
var addressStr = changeAddr.toString();
// Build new match object for new change address
var matchObj = {
address: addressStr,
createTime: getUnixtime(),
account: acctObj.name,
acctIndex: acctObj.index,
keyIndex: keyIndex,
change: true,
};
// Store match obj in cache
acctObj.nextKey++;
modified = true;
wcache.matchAddresses[addressStr] = matchObj;
wcacheModified = true;
if ('btc' in spendInfo.to)
spendInfo.to.satoshis = bitcore.Unit.fromBTC(spendInfo.to.btc).toSatoshis();
// Generate and sign bitcoin transaction
var tx = new bitcore.Transaction()
.from(acctUtxos)
.to(spendInfo.to.address, spendInfo.to.satoshis)
.change(changeAddr)
.sign(privkeys);
// Add new tx to internal cache
scanTx(tx, null);
// Sync db
walletWrite();
cacheWrite();
// Output transaction (hex) to console
console.log(tx.toString());
// Init bitcoind RPC
rpcInfoRead();
const rpc = new RpcClient(rpcInfoObj);
rpc.sendRawTransaction(tx.toString(), function (err, res) {
if (err) {
console.error("Send TX failed, " + err);
return;
}
console.log("Sent txid " + tx.hash);
});
}
KeyPair.prototype.getAddress = function() {
return bitcore.Address.fromPublicKeyHash(
new Buffer(this.getNodeID(), 'hex')
).toString();
};
bitcore.Networks.defaultNetwork = bitcore.Networks.testnet; // works for regtest
// note: using a fixed private key of 1 for ease of demonstration only.
// address = mrCDrCybB6J1vRfbwM5hemdJz73FwDBC8r
// privKey WIF = cMahea7zqjxrtgAbB7LSGbcQUr1uX1ojuat9jZodMN87JcbXMTcA
const privKey = bitcore.PrivateKey(bitcore.crypto.BN.One);
const redeemScript = bitcore.Script.empty()
// useful generic way to get the minimal encoding of the locktime stack argument
.add(bitcore.crypto.BN.fromNumber(LOCK_UNTIL_BLOCK).toScriptNumBuffer())
.add('OP_CHECKLOCKTIMEVERIFY').add('OP_DROP')
.add(bitcore.Script.buildPublicKeyHashOut(privKey.toAddress()));
// address = 2MxEcV5dx8CsDAByqN5PbB3NPmhyBkNLHVD
const p2shAddress = bitcore.Address.payingTo(redeemScript);
const freezeTransaction = new bitcore.Transaction().from({
txid: args.txid, // tran id of an utxo associated with the privKey's address
vout: Number(args.vout), // output index of the utxo within the transaction with id = txid
scriptPubKey: args.scriptPubKey, // scriptPubKey of the utxo txid[vout]
satoshis: Number(args.satoshis), // value of the utxo txid[vout]
})
.to(p2shAddress, Number(args.satoshis) - 100000)
.sign(privKey);
const getSpendTransaction = function(lockTime, sequenceNumber) {
const result = new bitcore.Transaction().from({
txid: freezeTransaction.id,
vout: 0,
scriptPubKey: redeemScript.toScriptHashOut(),
var params = JSON.parse(process.argv[2]);
var pubKeys = [];
var external = (params.isExternal === 'external') ? 0 : 1;
params.extendedPubKeys.forEach(function(extendedPubKeyBase58) {
var extendedPubKey = new bitcore.HDPublicKey(extendedPubKeyBase58);
pubKeys.push(extendedPubKey.derive(external).derive(params.derivation).publicKey);
});
var redeemScript = bitcore.Script.buildMultisigOut(pubKeys, params.signRequired);
var script = redeemScript.toScriptHashOut();
var multisigAddress = new bitcore.Address(script, bitcore.Networks.livenet);
var stdout = {
redeemScript: redeemScript.toBuffer().toString('hex'), // serialize to Hex format the redeemScript
address: multisigAddress.toString(),
pubKeys: pubKeys.map(function(pubkey) { return pubkey.toString(); }).sort() // get pubKeys and sort them alphabetically
};
if (bitcore.Address.isValid(multisigAddress.toString(), bitcore.Networks.livenet, bitcore.Address.PayToScriptHash)) {
// stdout
console.log(JSON.stringify(stdout));
} else {
throw new Error('Address generated is invalid (not a PayToScriptHash).');