1848 lines
44 KiB
JavaScript
1848 lines
44 KiB
JavaScript
/*!
|
|
* rpc.js - bitcoind-compatible json rpc for bcoin.
|
|
* Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
|
|
* https://github.com/bcoin-org/bcoin
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var assert = require('assert');
|
|
var fs = require('../utils/fs');
|
|
var util = require('../utils/util');
|
|
var co = require('../utils/co');
|
|
var crypto = require('../crypto/crypto');
|
|
var Amount = require('../btc/amount');
|
|
var Script = require('../script/script');
|
|
var Address = require('../primitives/address');
|
|
var KeyRing = require('../primitives/keyring');
|
|
var Lock = require('../utils/lock');
|
|
var MerkleBlock = require('../primitives/merkleblock');
|
|
var MTX = require('../primitives/mtx');
|
|
var Outpoint = require('../primitives/outpoint');
|
|
var Output = require('../primitives/output');
|
|
var TX = require('../primitives/tx');
|
|
var encoding = require('../utils/encoding');
|
|
var consensus = require('../protocol/consensus');
|
|
var pkg = require('../pkg');
|
|
|
|
/**
|
|
* Bitcoin Core RPC
|
|
* @alias module:wallet.RPC
|
|
* @constructor
|
|
* @param {Node} node
|
|
*/
|
|
|
|
function RPC(walletdb) {
|
|
if (!(this instanceof RPC))
|
|
return new RPC(walletdb);
|
|
|
|
assert(walletdb, 'RPC requires a WalletDB.');
|
|
|
|
this.network = walletdb.network;
|
|
this.logger = walletdb.logger;
|
|
this.walletdb = walletdb;
|
|
this.wallet = null;
|
|
|
|
this.locker = new Lock();
|
|
|
|
this.feeRate = null;
|
|
}
|
|
|
|
RPC.magic = 'Bitcoin Signed Message:\n';
|
|
|
|
RPC.prototype.attach = function attach(rpc) {
|
|
rpc.add('fundrawtransaction', this.fundrawtransaction, this);
|
|
rpc.add('resendwallettransactions', this.resendwallettransactions, this);
|
|
rpc.add('abandontransaction', this.abandontransaction, this);
|
|
rpc.add('addmultisigaddress', this.addmultisigaddress, this);
|
|
rpc.add('addwitnessaddress', this.addwitnessaddress, this);
|
|
rpc.add('backupwallet', this.backupwallet, this);
|
|
rpc.add('dumpprivkey', this.dumpprivkey, this);
|
|
rpc.add('dumpwallet', this.dumpwallet, this);
|
|
rpc.add('encryptwallet', this.encryptwallet, this);
|
|
rpc.add('getaccountaddress', this.getaccountaddress, this);
|
|
rpc.add('getaccount', this.getaccount, this);
|
|
rpc.add('getaddressesbyaccount', this.getaddressesbyaccount, this);
|
|
rpc.add('getbalance', this.getbalance, this);
|
|
rpc.add('getnewaddress', this.getnewaddress, this);
|
|
rpc.add('getrawchangeaddress', this.getrawchangeaddress, this);
|
|
rpc.add('getreceivedbyaccount', this.getreceivedbyaccount, this);
|
|
rpc.add('getreceivedbyaddress', this.getreceivedbyaddress, this);
|
|
rpc.add('gettransaction', this.gettransaction, this);
|
|
rpc.add('getunconfirmedbalance', this.getunconfirmedbalance, this);
|
|
rpc.add('getwalletinfo', this.getwalletinfo, this);
|
|
rpc.add('importprivkey', this.importprivkey, this);
|
|
rpc.add('importwallet', this.importwallet, this);
|
|
rpc.add('importaddress', this.importaddress, this);
|
|
rpc.add('importprunedfunds', this.importprunedfunds, this);
|
|
rpc.add('importpubkey', this.importpubkey, this);
|
|
rpc.add('keypoolrefill', this.keypoolrefill, this);
|
|
rpc.add('listaccounts', this.listaccounts, this);
|
|
rpc.add('listaddressgroupings', this.listaddressgroupings, this);
|
|
rpc.add('listlockunspent', this.listlockunspent, this);
|
|
rpc.add('listreceivedbyaccount', this.listreceivedbyaccount, this);
|
|
rpc.add('listreceivedbyaddress', this.listreceivedbyaddress, this);
|
|
rpc.add('listsinceblock', this.listsinceblock, this);
|
|
rpc.add('listtransactions', this.listtransactions, this);
|
|
rpc.add('listunspent', this.listunspent, this);
|
|
rpc.add('lockunspent', this.lockunspent, this);
|
|
rpc.add('move', this.move, this);
|
|
rpc.add('sendfrom', this.sendfrom, this);
|
|
rpc.add('sendmany', this.sendmany, this);
|
|
rpc.add('sendtoaddress', this.sendtoaddress, this);
|
|
rpc.add('setaccount', this.setaccount, this);
|
|
rpc.add('settxfee', this.settxfee, this);
|
|
rpc.add('signmessage', this.signmessage, this);
|
|
rpc.add('walletlock', this.walletlock, this);
|
|
rpc.add('walletpassphrasechange', this.walletpassphrasechange, this);
|
|
rpc.add('walletpassphrase', this.walletpassphrase, this);
|
|
rpc.add('removeprunedfunds', this.removeprunedfunds, this);
|
|
};
|
|
|
|
RPC.prototype.execute = function execute(json, help) {
|
|
switch (json.method) {
|
|
case 'fundrawtransaction':
|
|
return this.fundrawtransaction(json.params, help);
|
|
case 'resendwallettransactions':
|
|
return this.resendwallettransactions(json.params, help);
|
|
case 'abandontransaction':
|
|
return this.abandontransaction(json.params, help);
|
|
case 'addmultisigaddress':
|
|
return this.addmultisigaddress(json.params, help);
|
|
case 'addwitnessaddress':
|
|
return this.addwitnessaddress(json.params, help);
|
|
case 'backupwallet':
|
|
return this.backupwallet(json.params, help);
|
|
case 'dumpprivkey':
|
|
return this.dumpprivkey(json.params, help);
|
|
case 'dumpwallet':
|
|
return this.dumpwallet(json.params, help);
|
|
case 'encryptwallet':
|
|
return this.encryptwallet(json.params, help);
|
|
case 'getaccountaddress':
|
|
return this.getaccountaddress(json.params, help);
|
|
case 'getaccount':
|
|
return this.getaccount(json.params, help);
|
|
case 'getaddressesbyaccount':
|
|
return this.getaddressesbyaccount(json.params, help);
|
|
case 'getbalance':
|
|
return this.getbalance(json.params, help);
|
|
case 'getnewaddress':
|
|
return this.getnewaddress(json.params, help);
|
|
case 'getrawchangeaddress':
|
|
return this.getrawchangeaddress(json.params, help);
|
|
case 'getreceivedbyaccount':
|
|
return this.getreceivedbyaccount(json.params, help);
|
|
case 'getreceivedbyaddress':
|
|
return this.getreceivedbyaddress(json.params, help);
|
|
case 'gettransaction':
|
|
return this.gettransaction(json.params, help);
|
|
case 'getunconfirmedbalance':
|
|
return this.getunconfirmedbalance(json.params, help);
|
|
case 'getwalletinfo':
|
|
return this.getwalletinfo(json.params, help);
|
|
case 'importprivkey':
|
|
return this.importprivkey(json.params, help);
|
|
case 'importwallet':
|
|
return this.importwallet(json.params, help);
|
|
case 'importaddress':
|
|
return this.importaddress(json.params, help);
|
|
case 'importprunedfunds':
|
|
return this.importprunedfunds(json.params, help);
|
|
case 'importpubkey':
|
|
return this.importpubkey(json.params, help);
|
|
case 'keypoolrefill':
|
|
return this.keypoolrefill(json.params, help);
|
|
case 'listaccounts':
|
|
return this.listaccounts(json.params, help);
|
|
case 'listaddressgroupings':
|
|
return this.listaddressgroupings(json.params, help);
|
|
case 'listlockunspent':
|
|
return this.listlockunspent(json.params, help);
|
|
case 'listreceivedbyaccount':
|
|
return this.listreceivedbyaccount(json.params, help);
|
|
case 'listreceivedbyaddress':
|
|
return this.listreceivedbyaddress(json.params, help);
|
|
case 'listsinceblock':
|
|
return this.listsinceblock(json.params, help);
|
|
case 'listtransactions':
|
|
return this.listtransactions(json.params, help);
|
|
case 'listunspent':
|
|
return this.listunspent(json.params, help);
|
|
case 'lockunspent':
|
|
return this.lockunspent(json.params, help);
|
|
case 'move':
|
|
return this.move(json.params, help);
|
|
case 'sendfrom':
|
|
return this.sendfrom(json.params, help);
|
|
case 'sendmany':
|
|
return this.sendmany(json.params, help);
|
|
case 'sendtoaddress':
|
|
return this.sendtoaddress(json.params, help);
|
|
case 'setaccount':
|
|
return this.setaccount(json.params, help);
|
|
case 'settxfee':
|
|
return this.settxfee(json.params, help);
|
|
case 'signmessage':
|
|
return this.signmessage(json.params, help);
|
|
case 'walletlock':
|
|
return this.walletlock(json.params, help);
|
|
case 'walletpassphrasechange':
|
|
return this.walletpassphrasechange(json.params, help);
|
|
case 'walletpassphrase':
|
|
return this.walletpassphrase(json.params, help);
|
|
case 'removeprunedfunds':
|
|
return this.removeprunedfunds(json.params, help);
|
|
default:
|
|
return Promise.reject(new Error('Unknown RPC call: ' + json.method));
|
|
}
|
|
};
|
|
|
|
RPC.prototype.fundrawtransaction = co(function* fundrawtransaction(args, help) {
|
|
var wallet = this.wallet;
|
|
var feeRate = this.feeRate;
|
|
var tx, options, changeAddress;
|
|
|
|
if (help || args.length < 1 || args.length > 2)
|
|
throw new RPCError('fundrawtransaction "hexstring" ( options )');
|
|
|
|
if (!util.isHex(args[0]))
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
tx = MTX.fromRaw(args[0], 'hex');
|
|
|
|
if (tx.outputs.length === 0)
|
|
throw new RPCError('TX must have at least one output.');
|
|
|
|
if (args.length > 1) {
|
|
options = toObject(args[1]);
|
|
changeAddress = toString(options.changeAddress);
|
|
|
|
if (changeAddress)
|
|
changeAddress = Address.fromBase58(changeAddress, this.network);
|
|
|
|
feeRate = options.feeRate;
|
|
|
|
if (feeRate != null)
|
|
feeRate = toSatoshi(feeRate);
|
|
}
|
|
|
|
options = {
|
|
rate: feeRate,
|
|
changeAddress: changeAddress
|
|
};
|
|
|
|
yield wallet.fund(tx, options);
|
|
|
|
return {
|
|
hex: tx.toRaw().toString('hex'),
|
|
changepos: tx.changeIndex,
|
|
fee: Amount.btc(tx.getFee(), true)
|
|
};
|
|
});
|
|
|
|
RPC.prototype._createRedeem = co(function* _createRedeem(args, help) {
|
|
var wallet = this.wallet;
|
|
var i, m, n, keys, hash, script, key, ring;
|
|
|
|
if (!util.isNumber(args[0])
|
|
|| !Array.isArray(args[1])
|
|
|| args[0] < 1
|
|
|| args[1].length < args[0]
|
|
|| args[1].length > 16) {
|
|
throw new RPCError('Invalid parameter.');
|
|
}
|
|
|
|
m = args[0];
|
|
n = args[1].length;
|
|
keys = args[1];
|
|
|
|
for (i = 0; i < keys.length; i++) {
|
|
key = keys[i];
|
|
|
|
if (!util.isBase58(key)) {
|
|
if (!util.isHex(key))
|
|
throw new RPCError('Invalid key.');
|
|
keys[i] = new Buffer(key, 'hex');
|
|
continue;
|
|
}
|
|
|
|
hash = Address.getHash(key, 'hex');
|
|
|
|
if (!hash)
|
|
throw new RPCError('Invalid key.');
|
|
|
|
ring = yield wallet.getKey(hash);
|
|
|
|
if (!ring)
|
|
throw new RPCError('Invalid key.');
|
|
|
|
keys[i] = ring.publicKey;
|
|
}
|
|
|
|
try {
|
|
script = Script.fromMultisig(m, n, keys);
|
|
} catch (e) {
|
|
throw new RPCError('Invalid parameters.');
|
|
}
|
|
|
|
if (script.getSize() > consensus.MAX_SCRIPT_PUSH)
|
|
throw new RPCError('Redeem script exceeds size limit.');
|
|
|
|
return script;
|
|
});
|
|
|
|
RPC.prototype.createmultisig = co(function* createmultisig(args, help) {
|
|
var script, address;
|
|
|
|
if (help || args.length < 2 || args.length > 2)
|
|
throw new RPCError('createmultisig nrequired ["key",...]');
|
|
|
|
script = yield this._createRedeem(args);
|
|
address = script.getAddress();
|
|
|
|
return {
|
|
address: address.toBase58(this.network),
|
|
redeemScript: script.toJSON()
|
|
};
|
|
});
|
|
|
|
/*
|
|
* Wallet
|
|
*/
|
|
|
|
RPC.prototype.resendwallettransactions = co(function* resendwallettransactions(args, help) {
|
|
var wallet = this.wallet;
|
|
var hashes = [];
|
|
var i, tx, txs;
|
|
|
|
if (help || args.length !== 0)
|
|
throw new RPCError('resendwallettransactions');
|
|
|
|
txs = yield wallet.resend();
|
|
|
|
for (i = 0; i < txs.length; i++) {
|
|
tx = txs[i];
|
|
hashes.push(tx.txid());
|
|
}
|
|
|
|
return hashes;
|
|
});
|
|
|
|
RPC.prototype.addmultisigaddress = co(function* addmultisigaddress(args, help) {
|
|
if (help || args.length < 2 || args.length > 3) {
|
|
throw new RPCError('addmultisigaddress'
|
|
+ ' nrequired ["key",...] ( "account" )');
|
|
}
|
|
|
|
// Impossible to implement in bcoin (no address book).
|
|
throw new Error('Not implemented.');
|
|
});
|
|
|
|
RPC.prototype.addwitnessaddress = co(function* addwitnessaddress(args, help) {
|
|
if (help || args.length < 1 || args.length > 1)
|
|
throw new RPCError('addwitnessaddress "address"');
|
|
|
|
// Unlikely to be implemented.
|
|
throw new Error('Not implemented.');
|
|
});
|
|
|
|
RPC.prototype.backupwallet = co(function* backupwallet(args, help) {
|
|
var dest;
|
|
|
|
if (help || args.length !== 1)
|
|
throw new RPCError('backupwallet "destination"');
|
|
|
|
dest = toString(args[0]);
|
|
|
|
yield this.walletdb.backup(dest);
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.dumpprivkey = co(function* dumpprivkey(args, help) {
|
|
var wallet = this.wallet;
|
|
var hash, ring;
|
|
|
|
if (help || args.length !== 1)
|
|
throw new RPCError('dumpprivkey "bitcoinaddress"');
|
|
|
|
hash = Address.getHash(toString(args[0]), 'hex');
|
|
|
|
if (!hash)
|
|
throw new RPCError('Invalid address.');
|
|
|
|
ring = yield wallet.getPrivateKey(hash);
|
|
|
|
if (!ring)
|
|
throw new RPCError('Key not found.');
|
|
|
|
return ring.toSecret();
|
|
});
|
|
|
|
RPC.prototype.dumpwallet = co(function* dumpwallet(args, help) {
|
|
var wallet = this.wallet;
|
|
var i, file, time, address, fmt, str, out, hash, hashes, ring;
|
|
|
|
if (help || args.length !== 1)
|
|
throw new RPCError('dumpwallet "filename"');
|
|
|
|
if (!args[0] || typeof args[0] !== 'string')
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
file = toString(args[0]);
|
|
time = util.date();
|
|
out = [
|
|
util.fmt('# Wallet Dump created by Bcoin %s', pkg.version),
|
|
util.fmt('# * Created on %s', time),
|
|
util.fmt('# * Best block at time of backup was %d (%s),',
|
|
this.chain.height, this.chain.tip.rhash()),
|
|
util.fmt('# mined on %s', util.date(this.chain.tip.ts)),
|
|
util.fmt('# * File: %s', file),
|
|
''
|
|
];
|
|
|
|
hashes = yield wallet.getAddressHashes();
|
|
|
|
for (i = 0; i < hashes.length; i++) {
|
|
hash = hashes[i];
|
|
ring = yield wallet.getPrivateKey(hash);
|
|
|
|
if (!ring)
|
|
continue;
|
|
|
|
address = ring.getAddress('base58');
|
|
fmt = '%s %s label= addr=%s';
|
|
|
|
if (ring.branch === 1)
|
|
fmt = '%s %s change=1 addr=%s';
|
|
|
|
str = util.fmt(fmt, ring.toSecret(), time, address);
|
|
|
|
out.push(str);
|
|
}
|
|
|
|
out.push('');
|
|
out.push('# End of dump');
|
|
out.push('');
|
|
|
|
out = out.join('\n');
|
|
|
|
if (fs.unsupported)
|
|
return out;
|
|
|
|
yield fs.writeFile(file, out, 'utf8');
|
|
|
|
return out;
|
|
});
|
|
|
|
RPC.prototype.encryptwallet = co(function* encryptwallet(args, help) {
|
|
var wallet = this.wallet;
|
|
var passphrase;
|
|
|
|
if (!wallet.master.encrypted && (help || args.length !== 1))
|
|
throw new RPCError('encryptwallet "passphrase"');
|
|
|
|
if (wallet.master.encrypted)
|
|
throw new RPCError('Already running with an encrypted wallet');
|
|
|
|
passphrase = toString(args[0]);
|
|
|
|
if (passphrase.length < 1)
|
|
throw new RPCError('encryptwallet "passphrase"');
|
|
|
|
yield wallet.setPassphrase(passphrase);
|
|
|
|
return 'wallet encrypted; we do not need to stop!';
|
|
});
|
|
|
|
RPC.prototype.getaccountaddress = co(function* getaccountaddress(args, help) {
|
|
var wallet = this.wallet;
|
|
var account;
|
|
|
|
if (help || args.length !== 1)
|
|
throw new RPCError('getaccountaddress "account"');
|
|
|
|
account = toString(args[0]);
|
|
|
|
if (!account)
|
|
account = 'default';
|
|
|
|
account = yield wallet.getAccount(account);
|
|
|
|
if (!account)
|
|
return '';
|
|
|
|
return account.receive.getAddress('base58');
|
|
});
|
|
|
|
RPC.prototype.getaccount = co(function* getaccount(args, help) {
|
|
var wallet = this.wallet;
|
|
var hash, path;
|
|
|
|
if (help || args.length !== 1)
|
|
throw new RPCError('getaccount "bitcoinaddress"');
|
|
|
|
hash = Address.getHash(args[0], 'hex');
|
|
|
|
if (!hash)
|
|
throw new RPCError('Invalid address.');
|
|
|
|
path = yield wallet.getPath(hash);
|
|
|
|
if (!path)
|
|
return '';
|
|
|
|
return path.name;
|
|
});
|
|
|
|
RPC.prototype.getaddressesbyaccount = co(function* getaddressesbyaccount(args, help) {
|
|
var wallet = this.wallet;
|
|
var i, path, account, address, addrs, paths;
|
|
|
|
if (help || args.length !== 1)
|
|
throw new RPCError('getaddressesbyaccount "account"');
|
|
|
|
account = toString(args[0]);
|
|
|
|
if (!account)
|
|
account = 'default';
|
|
|
|
addrs = [];
|
|
|
|
paths = yield wallet.getPaths(account);
|
|
|
|
for (i = 0; i < paths.length; i++) {
|
|
path = paths[i];
|
|
address = path.toAddress();
|
|
addrs.push(address.toBase58(this.network));
|
|
}
|
|
|
|
return addrs;
|
|
});
|
|
|
|
RPC.prototype.getbalance = co(function* getbalance(args, help) {
|
|
var wallet = this.wallet;
|
|
var minconf = 0;
|
|
var account, value, balance;
|
|
|
|
if (help || args.length > 3)
|
|
throw new RPCError('getbalance ( "account" minconf includeWatchonly )');
|
|
|
|
if (args.length >= 1) {
|
|
account = toString(args[0]);
|
|
|
|
if (!account)
|
|
account = 'default';
|
|
|
|
if (account === '*')
|
|
account = null;
|
|
}
|
|
|
|
if (args.length >= 2)
|
|
minconf = toNumber(args[1], 0);
|
|
|
|
balance = yield wallet.getBalance(account);
|
|
|
|
if (minconf)
|
|
value = balance.confirmed;
|
|
else
|
|
value = balance.unconfirmed;
|
|
|
|
return Amount.btc(value, true);
|
|
});
|
|
|
|
RPC.prototype.getnewaddress = co(function* getnewaddress(args, help) {
|
|
var wallet = this.wallet;
|
|
var account, address;
|
|
|
|
if (help || args.length > 1)
|
|
throw new RPCError('getnewaddress ( "account" )');
|
|
|
|
if (args.length === 1)
|
|
account = toString(args[0]);
|
|
|
|
if (!account)
|
|
account = 'default';
|
|
|
|
address = yield wallet.createReceive(account);
|
|
|
|
return address.getAddress('base58');
|
|
});
|
|
|
|
RPC.prototype.getrawchangeaddress = co(function* getrawchangeaddress(args, help) {
|
|
var wallet = this.wallet;
|
|
var address;
|
|
|
|
if (help || args.length > 1)
|
|
throw new RPCError('getrawchangeaddress');
|
|
|
|
address = yield wallet.createChange();
|
|
|
|
return address.getAddress('base58');
|
|
});
|
|
|
|
RPC.prototype.getreceivedbyaccount = co(function* getreceivedbyaccount(args, help) {
|
|
var wallet = this.wallet;
|
|
var minconf = 0;
|
|
var total = 0;
|
|
var filter = {};
|
|
var lastConf = -1;
|
|
var i, j, path, wtx, output, conf, hash, account, paths, txs;
|
|
|
|
if (help || args.length < 1 || args.length > 2)
|
|
throw new RPCError('getreceivedbyaccount "account" ( minconf )');
|
|
|
|
account = toString(args[0]);
|
|
|
|
if (!account)
|
|
account = 'default';
|
|
|
|
if (args.length === 2)
|
|
minconf = toNumber(args[1], 0);
|
|
|
|
paths = yield wallet.getPaths(account);
|
|
|
|
for (i = 0; i < paths.length; i++) {
|
|
path = paths[i];
|
|
filter[path.hash] = true;
|
|
}
|
|
|
|
txs = yield wallet.getHistory(account);
|
|
|
|
for (i = 0; i < txs.length; i++) {
|
|
wtx = txs[i];
|
|
|
|
conf = wtx.getDepth(this.chain.height);
|
|
|
|
if (conf < minconf)
|
|
continue;
|
|
|
|
if (lastConf === -1 || conf < lastConf)
|
|
lastConf = conf;
|
|
|
|
for (j = 0; j < wtx.tx.outputs.length; j++) {
|
|
output = wtx.tx.outputs[j];
|
|
hash = output.getHash('hex');
|
|
if (hash && filter[hash])
|
|
total += output.value;
|
|
}
|
|
}
|
|
|
|
return Amount.btc(total, true);
|
|
});
|
|
|
|
RPC.prototype.getreceivedbyaddress = co(function* getreceivedbyaddress(args, help) {
|
|
var wallet = this.wallet;
|
|
var minconf = 0;
|
|
var total = 0;
|
|
var i, j, hash, wtx, output, txs;
|
|
|
|
if (help || args.length < 1 || args.length > 2)
|
|
throw new RPCError('getreceivedbyaddress "bitcoinaddress" ( minconf )');
|
|
|
|
hash = Address.getHash(toString(args[0]), 'hex');
|
|
|
|
if (!hash)
|
|
throw new RPCError('Invalid address');
|
|
|
|
if (args.length === 2)
|
|
minconf = toNumber(args[1], 0);
|
|
|
|
txs = yield wallet.getHistory();
|
|
|
|
for (i = 0; i < txs.length; i++) {
|
|
wtx = txs[i];
|
|
|
|
if (wtx.getDepth(this.chain.height) < minconf)
|
|
continue;
|
|
|
|
for (j = 0; j < wtx.tx.outputs.length; j++) {
|
|
output = wtx.tx.outputs[j];
|
|
if (output.getHash('hex') === hash)
|
|
total += output.value;
|
|
}
|
|
}
|
|
|
|
return Amount.btc(total, true);
|
|
});
|
|
|
|
RPC.prototype._toWalletTX = co(function* _toWalletTX(wtx) {
|
|
var wallet = this.wallet;
|
|
var details = yield wallet.toDetails(wtx);
|
|
var det = [];
|
|
var sent = 0;
|
|
var received = 0;
|
|
var receive = true;
|
|
var i, member;
|
|
|
|
if (!details)
|
|
throw new RPCError('TX not found.');
|
|
|
|
for (i = 0; i < details.inputs.length; i++) {
|
|
member = details.inputs[i];
|
|
if (member.path) {
|
|
receive = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < details.outputs.length; i++) {
|
|
member = details.outputs[i];
|
|
|
|
if (member.path) {
|
|
if (member.path.branch === 1)
|
|
continue;
|
|
|
|
det.push({
|
|
account: member.path.name,
|
|
address: member.address.toBase58(this.network),
|
|
category: 'receive',
|
|
amount: Amount.btc(member.value, true),
|
|
label: member.path.name,
|
|
vout: i
|
|
});
|
|
|
|
received += member.value;
|
|
|
|
continue;
|
|
}
|
|
|
|
if (receive)
|
|
continue;
|
|
|
|
det.push({
|
|
account: '',
|
|
address: member.address
|
|
? member.address.toBase58(this.network)
|
|
: null,
|
|
category: 'send',
|
|
amount: -(Amount.btc(member.value, true)),
|
|
fee: -(Amount.btc(details.fee, true)),
|
|
vout: i
|
|
});
|
|
|
|
sent += member.value;
|
|
}
|
|
|
|
return {
|
|
amount: Amount.btc(receive ? received : -sent, true),
|
|
confirmations: details.confirmations,
|
|
blockhash: details.block ? util.revHex(details.block) : null,
|
|
blockindex: details.index,
|
|
blocktime: details.ts,
|
|
txid: util.revHex(details.hash),
|
|
walletconflicts: [],
|
|
time: details.ps,
|
|
timereceived: details.ps,
|
|
'bip125-replaceable': 'no',
|
|
details: det,
|
|
hex: details.tx.toRaw().toString('hex')
|
|
};
|
|
});
|
|
|
|
RPC.prototype.gettransaction = co(function* gettransaction(args, help) {
|
|
var wallet = this.wallet;
|
|
var hash, wtx;
|
|
|
|
if (help || args.length < 1 || args.length > 2)
|
|
throw new RPCError('gettransaction "txid" ( includeWatchonly )');
|
|
|
|
hash = toHash(args[0]);
|
|
|
|
if (!hash)
|
|
throw new RPCError('Invalid parameter');
|
|
|
|
wtx = yield wallet.getTX(hash);
|
|
|
|
if (!wtx)
|
|
throw new RPCError('TX not found.');
|
|
|
|
return yield this._toWalletTX(wtx);
|
|
});
|
|
|
|
RPC.prototype.abandontransaction = co(function* abandontransaction(args, help) {
|
|
var wallet = this.wallet;
|
|
var hash, result;
|
|
|
|
if (help || args.length !== 1)
|
|
throw new RPCError('abandontransaction "txid"');
|
|
|
|
hash = toHash(args[0]);
|
|
|
|
if (!hash)
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
result = yield wallet.abandon(hash);
|
|
|
|
if (!result)
|
|
throw new RPCError('Transaction not in wallet.');
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.getunconfirmedbalance = co(function* getunconfirmedbalance(args, help) {
|
|
var wallet = this.wallet;
|
|
var balance;
|
|
|
|
if (help || args.length > 0)
|
|
throw new RPCError('getunconfirmedbalance');
|
|
|
|
balance = yield wallet.getBalance();
|
|
|
|
return Amount.btc(balance.unconfirmed, true);
|
|
});
|
|
|
|
RPC.prototype.getwalletinfo = co(function* getwalletinfo(args, help) {
|
|
var wallet = this.wallet;
|
|
var balance;
|
|
|
|
if (help || args.length !== 0)
|
|
throw new RPCError('getwalletinfo');
|
|
|
|
balance = yield wallet.getBalance();
|
|
|
|
return {
|
|
walletid: wallet.id,
|
|
walletversion: 6,
|
|
balance: Amount.btc(balance.unconfirmed, true),
|
|
unconfirmed_balance: Amount.btc(balance.unconfirmed, true),
|
|
txcount: wallet.txdb.state.tx,
|
|
keypoololdest: 0,
|
|
keypoolsize: 0,
|
|
unlocked_until: wallet.master.until,
|
|
paytxfee: this.feeRate != null
|
|
? Amount.btc(this.feeRate, true)
|
|
: 0
|
|
};
|
|
});
|
|
|
|
RPC.prototype.importprivkey = co(function* importprivkey(args, help) {
|
|
var wallet = this.wallet;
|
|
var secret, label, rescan, key;
|
|
|
|
if (help || args.length < 1 || args.length > 3)
|
|
throw new RPCError('importprivkey "bitcoinprivkey" ( "label" rescan )');
|
|
|
|
secret = toString(args[0]);
|
|
|
|
if (args.length > 1)
|
|
label = toString(args[1]);
|
|
|
|
if (args.length > 2)
|
|
rescan = toBool(args[2]);
|
|
|
|
if (rescan && this.chain.options.prune)
|
|
throw new RPCError('Cannot rescan when pruned.');
|
|
|
|
key = KeyRing.fromSecret(secret, this.network);
|
|
|
|
yield wallet.importKey(0, key);
|
|
|
|
if (rescan)
|
|
yield this.walletdb.rescan(0);
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.importwallet = co(function* importwallet(args, help) {
|
|
var wallet = this.wallet;
|
|
var file, keys, lines, line, parts;
|
|
var i, secret, time, label, addr;
|
|
var data, key, rescan;
|
|
|
|
if (help || args.length !== 1)
|
|
throw new RPCError('importwallet "filename" ( rescan )');
|
|
|
|
if (fs.unsupported)
|
|
throw new RPCError('FS not available.');
|
|
|
|
file = toString(args[0]);
|
|
|
|
if (args.length > 1)
|
|
rescan = toBool(args[1]);
|
|
|
|
if (rescan && this.chain.options.prune)
|
|
throw new RPCError('Cannot rescan when pruned.');
|
|
|
|
data = yield fs.readFile(file, 'utf8');
|
|
|
|
lines = data.split(/\n+/);
|
|
keys = [];
|
|
|
|
for (i = 0; i < lines.length; i++) {
|
|
line = lines[i].trim();
|
|
|
|
if (line.length === 0)
|
|
continue;
|
|
|
|
if (/^\s*#/.test(line))
|
|
continue;
|
|
|
|
parts = line.split(/\s+/);
|
|
|
|
if (parts.length < 4)
|
|
throw new RPCError('Malformed wallet.');
|
|
|
|
secret = KeyRing.fromSecret(parts[0], this.network);
|
|
|
|
time = +parts[1];
|
|
label = parts[2];
|
|
addr = parts[3];
|
|
|
|
keys.push(secret);
|
|
}
|
|
|
|
for (i = 0; i < keys.length; i++) {
|
|
key = keys[i];
|
|
yield wallet.importKey(0, key);
|
|
}
|
|
|
|
if (rescan)
|
|
yield this.walletdb.rescan(0);
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.importaddress = co(function* importaddress(args, help) {
|
|
var wallet = this.wallet;
|
|
var addr, label, rescan, p2sh;
|
|
|
|
if (help || args.length < 1 || args.length > 4)
|
|
throw new RPCError('importaddress "address" ( "label" rescan p2sh )');
|
|
|
|
addr = toString(args[0]);
|
|
|
|
if (args.length > 1)
|
|
label = toString(args[1]);
|
|
|
|
if (args.length > 2)
|
|
rescan = toBool(args[2]);
|
|
|
|
if (args.length > 3)
|
|
p2sh = toBool(args[3]);
|
|
|
|
if (rescan && this.chain.options.prune)
|
|
throw new RPCError('Cannot rescan when pruned.');
|
|
|
|
addr = Address.fromBase58(addr, this.network);
|
|
|
|
yield wallet.importAddress(0, addr);
|
|
|
|
if (rescan)
|
|
yield this.walletdb.rescan(0);
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.importpubkey = co(function* importpubkey(args, help) {
|
|
var wallet = this.wallet;
|
|
var pubkey, label, rescan, key;
|
|
|
|
if (help || args.length < 1 || args.length > 4)
|
|
throw new RPCError('importpubkey "pubkey" ( "label" rescan )');
|
|
|
|
pubkey = toString(args[0]);
|
|
|
|
if (!util.isHex(pubkey))
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
if (args.length > 1)
|
|
label = toString(args[1]);
|
|
|
|
if (args.length > 2)
|
|
rescan = toBool(args[2]);
|
|
|
|
if (rescan && this.chain.options.prune)
|
|
throw new RPCError('Cannot rescan when pruned.');
|
|
|
|
pubkey = new Buffer(pubkey, 'hex');
|
|
|
|
key = KeyRing.fromPublic(pubkey, this.network);
|
|
|
|
yield wallet.importKey(0, key);
|
|
|
|
if (rescan)
|
|
yield this.walletdb.rescan(0);
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.keypoolrefill = co(function* keypoolrefill(args, help) {
|
|
if (help || args.length > 1)
|
|
throw new RPCError('keypoolrefill ( newsize )');
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.listaccounts = co(function* listaccounts(args, help) {
|
|
var wallet = this.wallet;
|
|
var i, map, accounts, account, balance;
|
|
|
|
if (help || args.length > 2)
|
|
throw new RPCError('listaccounts ( minconf includeWatchonly)');
|
|
|
|
map = {};
|
|
accounts = yield wallet.getAccounts();
|
|
|
|
for (i = 0; i < accounts.length; i++) {
|
|
account = accounts[i];
|
|
balance = yield wallet.getBalance(account);
|
|
map[account] = Amount.btc(balance.unconfirmed, true);
|
|
}
|
|
|
|
return map;
|
|
});
|
|
|
|
RPC.prototype.listaddressgroupings = co(function* listaddressgroupings(args, help) {
|
|
if (help)
|
|
throw new RPCError('listaddressgroupings');
|
|
throw new Error('Not implemented.');
|
|
});
|
|
|
|
RPC.prototype.listlockunspent = co(function* listlockunspent(args, help) {
|
|
var wallet = this.wallet;
|
|
var i, outpoints, outpoint, out;
|
|
|
|
if (help || args.length > 0)
|
|
throw new RPCError('listlockunspent');
|
|
|
|
outpoints = wallet.getLocked();
|
|
out = [];
|
|
|
|
for (i = 0; i < outpoints.length; i++) {
|
|
outpoint = outpoints[i];
|
|
out.push({
|
|
txid: outpoint.txid(),
|
|
vout: outpoint.index
|
|
});
|
|
}
|
|
|
|
return out;
|
|
});
|
|
|
|
RPC.prototype.listreceivedbyaccount = co(function* listreceivedbyaccount(args, help) {
|
|
var minconf = 0;
|
|
var includeEmpty = false;
|
|
|
|
if (help || args.length > 3) {
|
|
throw new RPCError('listreceivedbyaccount'
|
|
+ ' ( minconf includeempty includeWatchonly )');
|
|
}
|
|
|
|
if (args.length > 0)
|
|
minconf = toNumber(args[0], 0);
|
|
|
|
if (args.length > 1)
|
|
includeEmpty = toBool(args[1], false);
|
|
|
|
return yield this._listReceived(minconf, includeEmpty, true);
|
|
});
|
|
|
|
RPC.prototype.listreceivedbyaddress = co(function* listreceivedbyaddress(args, help) {
|
|
var minconf = 0;
|
|
var includeEmpty = false;
|
|
|
|
if (help || args.length > 3) {
|
|
throw new RPCError('listreceivedbyaddress'
|
|
+ ' ( minconf includeempty includeWatchonly )');
|
|
}
|
|
|
|
if (args.length > 0)
|
|
minconf = toNumber(args[0], 0);
|
|
|
|
if (args.length > 1)
|
|
includeEmpty = toBool(args[1], false);
|
|
|
|
return yield this._listReceived(minconf, includeEmpty, false);
|
|
});
|
|
|
|
RPC.prototype._listReceived = co(function* _listReceived(minconf, empty, account) {
|
|
var wallet = this.wallet;
|
|
var out = [];
|
|
var result = [];
|
|
var map = {};
|
|
var paths = yield wallet.getPaths();
|
|
var i, j, path, wtx, output, conf, hash;
|
|
var entry, address, keys, key, item, txs;
|
|
|
|
for (i = 0; i < paths.length; i++) {
|
|
path = paths[i];
|
|
address = path.toAddress();
|
|
map[path.hash] = {
|
|
involvesWatchonly: wallet.watchOnly,
|
|
address: address.toBase58(this.network),
|
|
account: path.name,
|
|
amount: 0,
|
|
confirmations: -1,
|
|
label: '',
|
|
};
|
|
}
|
|
|
|
txs = yield wallet.getHistory();
|
|
|
|
for (i = 0; i < txs.length; i++) {
|
|
wtx = txs[i];
|
|
|
|
conf = wtx.getDepth(this.chain.height);
|
|
|
|
if (conf < minconf)
|
|
continue;
|
|
|
|
for (j = 0; j < wtx.tx.outputs.length; j++) {
|
|
output = wtx.tx.outputs[j];
|
|
address = output.getAddress();
|
|
|
|
if (!address)
|
|
continue;
|
|
|
|
hash = address.getHash('hex');
|
|
entry = map[hash];
|
|
|
|
if (entry) {
|
|
if (entry.confirmations === -1 || conf < entry.confirmations)
|
|
entry.confirmations = conf;
|
|
entry.address = address.toBase58(this.network);
|
|
entry.amount += output.value;
|
|
}
|
|
}
|
|
}
|
|
|
|
keys = Object.keys(map);
|
|
|
|
for (i = 0; i < keys.length; i++) {
|
|
key = keys[i];
|
|
entry = map[key];
|
|
out.push(entry);
|
|
}
|
|
|
|
if (account) {
|
|
map = {};
|
|
|
|
for (i = 0; i < out.length; i++) {
|
|
entry = out[i];
|
|
item = map[entry.account];
|
|
if (!item) {
|
|
map[entry.account] = entry;
|
|
entry.address = undefined;
|
|
continue;
|
|
}
|
|
item.amount += entry.amount;
|
|
}
|
|
|
|
out = [];
|
|
keys = Object.keys(map);
|
|
|
|
for (i = 0; i < keys.length; i++) {
|
|
key = keys[i];
|
|
entry = map[key];
|
|
out.push(entry);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < out.length; i++) {
|
|
entry = out[i];
|
|
|
|
if (!empty && entry.amount === 0)
|
|
continue;
|
|
|
|
if (entry.confirmations === -1)
|
|
entry.confirmations = 0;
|
|
|
|
entry.amount = Amount.btc(entry.amount, true);
|
|
result.push(entry);
|
|
}
|
|
|
|
return result;
|
|
});
|
|
|
|
RPC.prototype.listsinceblock = co(function* listsinceblock(args, help) {
|
|
var wallet = this.wallet;
|
|
var minconf = 0;
|
|
var out = [];
|
|
var i, block, highest, height;
|
|
var txs, wtx, json;
|
|
|
|
if (help) {
|
|
throw new RPCError('listsinceblock'
|
|
+ ' ( "blockhash" target-confirmations includeWatchonly)');
|
|
}
|
|
|
|
if (args.length > 0) {
|
|
block = toHash(args[0]);
|
|
if (!block)
|
|
throw new RPCError('Invalid parameter.');
|
|
}
|
|
|
|
if (args.length > 1)
|
|
minconf = toNumber(args[1], 0);
|
|
|
|
height = yield this.chain.db.getHeight(block);
|
|
|
|
if (height === -1)
|
|
height = this.chain.height;
|
|
|
|
txs = yield wallet.getHistory();
|
|
|
|
for (i = 0; i < txs.length; i++) {
|
|
wtx = txs[i];
|
|
|
|
if (wtx.height < height)
|
|
continue;
|
|
|
|
if (wtx.getDepth(this.chain.height) < minconf)
|
|
continue;
|
|
|
|
if (!highest || wtx.height > highest)
|
|
highest = wtx;
|
|
|
|
json = yield this._toListTX(wtx);
|
|
|
|
out.push(json);
|
|
}
|
|
|
|
return {
|
|
transactions: out,
|
|
lastblock: highest && highest.block
|
|
? util.revHex(highest.block)
|
|
: encoding.NULL_HASH
|
|
};
|
|
});
|
|
|
|
RPC.prototype._toListTX = co(function* _toListTX(wtx) {
|
|
var wallet = this.wallet;
|
|
var sent = 0;
|
|
var received = 0;
|
|
var receive = true;
|
|
var sendMember, recMember, sendIndex, recIndex;
|
|
var i, member, index;
|
|
var details = yield wallet.toDetails(wtx);
|
|
|
|
if (!details)
|
|
throw new RPCError('TX not found.');
|
|
|
|
for (i = 0; i < details.inputs.length; i++) {
|
|
member = details.inputs[i];
|
|
if (member.path) {
|
|
receive = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < details.outputs.length; i++) {
|
|
member = details.outputs[i];
|
|
|
|
if (member.path) {
|
|
if (member.path.branch === 1)
|
|
continue;
|
|
received += member.value;
|
|
recMember = member;
|
|
recIndex = i;
|
|
continue;
|
|
}
|
|
|
|
sent += member.value;
|
|
sendMember = member;
|
|
sendIndex = i;
|
|
}
|
|
|
|
if (receive) {
|
|
member = recMember;
|
|
index = recIndex;
|
|
} else {
|
|
member = sendMember;
|
|
index = sendIndex;
|
|
}
|
|
|
|
// In the odd case where we send to ourselves.
|
|
if (!member) {
|
|
assert(!receive);
|
|
member = recMember;
|
|
index = recIndex;
|
|
}
|
|
|
|
return {
|
|
account: member.path ? member.path.name : '',
|
|
address: member.address
|
|
? member.address.toBase58(this.network)
|
|
: null,
|
|
category: receive ? 'receive' : 'send',
|
|
amount: Amount.btc(receive ? received : -sent, true),
|
|
label: member.path ? member.path.name : undefined,
|
|
vout: index,
|
|
confirmations: details.getDepth(),
|
|
blockhash: details.block ? util.revHex(details.block) : null,
|
|
blockindex: details.index,
|
|
blocktime: details.ts,
|
|
txid: util.revHex(details.hash),
|
|
walletconflicts: [],
|
|
time: details.ps,
|
|
timereceived: details.ps,
|
|
'bip125-replaceable': 'no'
|
|
};
|
|
});
|
|
|
|
RPC.prototype.listtransactions = co(function* listtransactions(args, help) {
|
|
var wallet = this.wallet;
|
|
var account = null;
|
|
var count = 10;
|
|
var i, txs, wtx, json;
|
|
|
|
if (help || args.length > 4) {
|
|
throw new RPCError(
|
|
'listtransactions ( "account" count from includeWatchonly)');
|
|
}
|
|
|
|
if (args.length > 0) {
|
|
account = toString(args[0]);
|
|
if (!account)
|
|
account = 'default';
|
|
}
|
|
|
|
if (args.length > 1) {
|
|
count = toNumber(args[1], 10);
|
|
if (count < 0)
|
|
count = 10;
|
|
}
|
|
|
|
txs = yield wallet.getHistory();
|
|
|
|
sortTX(txs);
|
|
|
|
for (i = 0; i < txs.length; i++) {
|
|
wtx = txs[i];
|
|
json = yield this._toListTX(wtx);
|
|
txs[i] = json;
|
|
}
|
|
|
|
return txs;
|
|
});
|
|
|
|
RPC.prototype.listunspent = co(function* listunspent(args, help) {
|
|
var wallet = this.wallet;
|
|
var minDepth = 1;
|
|
var maxDepth = 9999999;
|
|
var out = [];
|
|
var i, addresses, addrs, depth, address, hash, coins, coin, ring;
|
|
|
|
if (help || args.length > 3) {
|
|
throw new RPCError('listunspent'
|
|
+ ' ( minconf maxconf ["address",...] )');
|
|
}
|
|
|
|
if (args.length > 0)
|
|
minDepth = toNumber(args[0], 1);
|
|
|
|
if (args.length > 1)
|
|
maxDepth = toNumber(args[1], maxDepth);
|
|
|
|
if (args.length > 2)
|
|
addrs = toArray(args[2]);
|
|
|
|
if (addrs) {
|
|
addresses = {};
|
|
for (i = 0; i < addrs.length; i++) {
|
|
address = toString(addrs[i]);
|
|
hash = Address.getHash(address, 'hex');
|
|
|
|
if (!hash)
|
|
throw new RPCError('Invalid address.');
|
|
|
|
if (addresses[hash])
|
|
throw new RPCError('Duplicate address.');
|
|
|
|
addresses[hash] = true;
|
|
}
|
|
}
|
|
|
|
coins = yield wallet.getCoins();
|
|
|
|
sortCoins(coins);
|
|
|
|
for (i = 0; i < coins.length; i++ ) {
|
|
coin = coins[i];
|
|
depth = coin.getDepth(this.chain.height);
|
|
|
|
if (!(depth >= minDepth && depth <= maxDepth))
|
|
continue;
|
|
|
|
address = coin.getAddress();
|
|
|
|
if (!address)
|
|
continue;
|
|
|
|
hash = coin.getHash('hex');
|
|
|
|
if (addresses) {
|
|
if (!hash || !addresses[hash])
|
|
continue;
|
|
}
|
|
|
|
ring = yield wallet.getKey(hash);
|
|
|
|
out.push({
|
|
txid: coin.txid(),
|
|
vout: coin.index,
|
|
address: address ? address.toBase58(this.network) : null,
|
|
account: ring ? ring.name : undefined,
|
|
redeemScript: ring && ring.script
|
|
? ring.script.toJSON()
|
|
: undefined,
|
|
scriptPubKey: coin.script.toJSON(),
|
|
amount: Amount.btc(coin.value, true),
|
|
confirmations: depth,
|
|
spendable: !wallet.isLocked(coin),
|
|
solvable: true
|
|
});
|
|
}
|
|
|
|
return out;
|
|
});
|
|
|
|
RPC.prototype.lockunspent = co(function* lockunspent(args, help) {
|
|
var wallet = this.wallet;
|
|
var i, unlock, outputs, output, outpoint;
|
|
|
|
if (help || args.length < 1 || args.length > 2) {
|
|
throw new RPCError('lockunspent'
|
|
+ ' unlock ([{"txid":"txid","vout":n},...])');
|
|
}
|
|
|
|
unlock = toBool(args[0]);
|
|
|
|
if (args.length === 1) {
|
|
if (unlock)
|
|
wallet.unlockCoins();
|
|
return true;
|
|
}
|
|
|
|
outputs = toArray(args[1]);
|
|
|
|
if (!outputs)
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
for (i = 0; i < outputs.length; i++) {
|
|
output = outputs[i];
|
|
|
|
if (!output || typeof output !== 'object')
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
outpoint = new Outpoint();
|
|
outpoint.hash = toHash(output.txid);
|
|
outpoint.index = toNumber(output.vout);
|
|
|
|
if (!outpoint.hash)
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
if (outpoint.index < 0)
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
if (unlock) {
|
|
wallet.unlockCoin(outpoint);
|
|
continue;
|
|
}
|
|
|
|
wallet.lockCoin(outpoint);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
RPC.prototype.move = co(function* move(args, help) {
|
|
// Not implementing: stupid and deprecated.
|
|
throw new Error('Not implemented.');
|
|
});
|
|
|
|
RPC.prototype._send = co(function* _send(account, address, amount, subtractFee) {
|
|
var wallet = this.wallet;
|
|
var tx, options;
|
|
|
|
options = {
|
|
account: account,
|
|
subtractFee: subtractFee,
|
|
rate: this.feeRate,
|
|
outputs: [{
|
|
address: address,
|
|
value: amount
|
|
}]
|
|
};
|
|
|
|
tx = yield wallet.send(options);
|
|
|
|
return tx.txid();
|
|
});
|
|
|
|
RPC.prototype.sendfrom = co(function* sendfrom(args, help) {
|
|
var account, address, amount;
|
|
|
|
if (help || args.length < 3 || args.length > 6) {
|
|
throw new RPCError('sendfrom'
|
|
+ ' "fromaccount" "tobitcoinaddress"'
|
|
+ ' amount ( minconf "comment" "comment-to" )');
|
|
}
|
|
|
|
account = toString(args[0]);
|
|
address = Address.fromBase58(toString(args[1]), this.network);
|
|
amount = toSatoshi(args[2]);
|
|
|
|
if (!account)
|
|
account = 'default';
|
|
|
|
return yield this._send(account, address, amount, false);
|
|
});
|
|
|
|
RPC.prototype.sendmany = co(function* sendmany(args, help) {
|
|
var wallet = this.wallet;
|
|
var minconf = 1;
|
|
var outputs = [];
|
|
var uniq = {};
|
|
var account, sendTo, comment, subtractFee;
|
|
var i, keys, tx, key, value, address;
|
|
var hash, output, options;
|
|
|
|
if (help || args.length < 2 || args.length > 5) {
|
|
throw new RPCError('sendmany'
|
|
+ ' "fromaccount" {"address":amount,...}'
|
|
+ ' ( minconf "comment" ["address",...] )');
|
|
}
|
|
|
|
account = toString(args[0]);
|
|
sendTo = toObject(args[1]);
|
|
|
|
if (!account)
|
|
account = 'default';
|
|
|
|
if (!sendTo)
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
if (args.length > 2)
|
|
minconf = toNumber(args[2], 1);
|
|
|
|
if (args.length > 3)
|
|
comment = toString(args[3]);
|
|
|
|
if (args.length > 4) {
|
|
subtractFee = args[4];
|
|
if (typeof subtractFee !== 'boolean') {
|
|
if (!util.isNumber(subtractFee))
|
|
throw new RPCError('Invalid parameter.');
|
|
}
|
|
}
|
|
|
|
keys = Object.keys(sendTo);
|
|
|
|
for (i = 0; i < keys.length; i++) {
|
|
key = keys[i];
|
|
value = toSatoshi(sendTo[key]);
|
|
address = Address.fromBase58(key, this.network);
|
|
hash = address.getHash('hex');
|
|
|
|
if (uniq[hash])
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
uniq[hash] = true;
|
|
|
|
output = new Output();
|
|
output.value = value;
|
|
output.script.fromAddress(address);
|
|
outputs.push(output);
|
|
}
|
|
|
|
options = {
|
|
outputs: outputs,
|
|
subtractFee: subtractFee,
|
|
account: account,
|
|
depth: minconf
|
|
};
|
|
|
|
tx = yield wallet.send(options);
|
|
|
|
return tx.txid();
|
|
});
|
|
|
|
RPC.prototype.sendtoaddress = co(function* sendtoaddress(args, help) {
|
|
var address, amount, subtractFee;
|
|
|
|
if (help || args.length < 2 || args.length > 5) {
|
|
throw new RPCError('sendtoaddress'
|
|
+ ' "bitcoinaddress" amount'
|
|
+ ' ( "comment" "comment-to"'
|
|
+ ' subtractfeefromamount )');
|
|
}
|
|
|
|
address = Address.fromBase58(toString(args[0]), this.network);
|
|
amount = toSatoshi(args[1]);
|
|
subtractFee = toBool(args[4]);
|
|
|
|
return yield this._send(null, address, amount, subtractFee);
|
|
});
|
|
|
|
RPC.prototype.setaccount = co(function* setaccount(args, help) {
|
|
if (help || args.length < 1 || args.length > 2)
|
|
throw new RPCError('setaccount "bitcoinaddress" "account"');
|
|
|
|
// Impossible to implement in bcoin:
|
|
throw new Error('Not implemented.');
|
|
});
|
|
|
|
RPC.prototype.settxfee = co(function* settxfee(args, help) {
|
|
if (help || args.length < 1 || args.length > 1)
|
|
throw new RPCError('settxfee amount');
|
|
|
|
this.feeRate = toSatoshi(args[0]);
|
|
|
|
return true;
|
|
});
|
|
|
|
RPC.prototype.signmessage = co(function* signmessage(args, help) {
|
|
var wallet = this.wallet;
|
|
var address, msg, sig, ring;
|
|
|
|
if (help || args.length !== 2)
|
|
throw new RPCError('signmessage "bitcoinaddress" "message"');
|
|
|
|
address = toString(args[0]);
|
|
msg = toString(args[1]);
|
|
|
|
address = Address.getHash(address, 'hex');
|
|
|
|
if (!address)
|
|
throw new RPCError('Invalid address.');
|
|
|
|
ring = yield wallet.getKey(address);
|
|
|
|
if (!ring)
|
|
throw new RPCError('Address not found.');
|
|
|
|
if (!wallet.master.key)
|
|
throw new RPCError('Wallet is locked.');
|
|
|
|
msg = new Buffer(RPC.magic + msg, 'utf8');
|
|
msg = crypto.hash256(msg);
|
|
|
|
sig = ring.sign(msg);
|
|
|
|
return sig.toString('base64');
|
|
});
|
|
|
|
RPC.prototype.walletlock = co(function* walletlock(args, help) {
|
|
var wallet = this.wallet;
|
|
|
|
if (help || (wallet.master.encrypted && args.length !== 0))
|
|
throw new RPCError('walletlock');
|
|
|
|
if (!wallet.master.encrypted)
|
|
throw new RPCError('Wallet is not encrypted.');
|
|
|
|
yield wallet.lock();
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.walletpassphrasechange = co(function* walletpassphrasechange(args, help) {
|
|
var wallet = this.wallet;
|
|
var old, new_;
|
|
|
|
if (help || (wallet.master.encrypted && args.length !== 2)) {
|
|
throw new RPCError('walletpassphrasechange'
|
|
+ ' "oldpassphrase" "newpassphrase"');
|
|
}
|
|
|
|
if (!wallet.master.encrypted)
|
|
throw new RPCError('Wallet is not encrypted.');
|
|
|
|
old = toString(args[0]);
|
|
new_ = toString(args[1]);
|
|
|
|
if (old.length < 1 || new_.length < 1)
|
|
throw new RPCError('Invalid parameter');
|
|
|
|
yield wallet.setPassphrase(old, new_);
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.walletpassphrase = co(function* walletpassphrase(args, help) {
|
|
var wallet = this.wallet;
|
|
var passphrase, timeout;
|
|
|
|
if (help || (wallet.master.encrypted && args.length !== 2))
|
|
throw new RPCError('walletpassphrase "passphrase" timeout');
|
|
|
|
if (!wallet.master.encrypted)
|
|
throw new RPCError('Wallet is not encrypted.');
|
|
|
|
passphrase = toString(args[0]);
|
|
timeout = toNumber(args[1]);
|
|
|
|
if (passphrase.length < 1)
|
|
throw new RPCError('Invalid parameter');
|
|
|
|
if (timeout < 0)
|
|
throw new RPCError('Invalid parameter');
|
|
|
|
yield wallet.unlock(passphrase, timeout);
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.importprunedfunds = co(function* importprunedfunds(args, help) {
|
|
var tx, block, hash, label, height;
|
|
|
|
if (help || args.length < 2 || args.length > 3) {
|
|
throw new RPCError('importprunedfunds'
|
|
+ ' "rawtransaction" "txoutproof" ( "label" )');
|
|
}
|
|
|
|
tx = args[0];
|
|
block = args[1];
|
|
|
|
if (!util.isHex(tx) || !util.isHex(block))
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
tx = TX.fromRaw(tx, 'hex');
|
|
block = MerkleBlock.fromRaw(block, 'hex');
|
|
hash = block.hash('hex');
|
|
|
|
if (args.length === 3)
|
|
label = toString(args[2]);
|
|
|
|
if (!block.verify())
|
|
throw new RPCError('Invalid proof.');
|
|
|
|
if (!block.hasTX(tx.hash('hex')))
|
|
throw new RPCError('Invalid proof.');
|
|
|
|
height = yield this.chain.db.getHeight(hash);
|
|
|
|
if (height === -1)
|
|
throw new RPCError('Invalid proof.');
|
|
|
|
block = {
|
|
hash: hash,
|
|
ts: block.ts,
|
|
height: height
|
|
};
|
|
|
|
if (!(yield this.walletdb.addTX(tx, block)))
|
|
throw new RPCError('No tracked address for TX.');
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.removeprunedfunds = co(function* removeprunedfunds(args, help) {
|
|
var wallet = this.wallet;
|
|
var hash;
|
|
|
|
if (help || args.length !== 1)
|
|
throw new RPCError('removeprunedfunds "txid"');
|
|
|
|
hash = toHash(args[0]);
|
|
|
|
if (!hash)
|
|
throw new RPCError('Invalid parameter.');
|
|
|
|
if (!(yield wallet.remove(hash)))
|
|
throw new RPCError('Transaction not in wallet.');
|
|
|
|
return null;
|
|
});
|
|
|
|
RPC.prototype.selectwallet = co(function* selectwallet(args, help) {
|
|
var id, wallet;
|
|
|
|
if (help || args.length !== 1)
|
|
throw new RPCError('selectwallet "id"');
|
|
|
|
id = toString(args[0]);
|
|
wallet = yield this.walletdb.get(id);
|
|
|
|
if (!wallet)
|
|
throw new RPCError('Wallet not found.');
|
|
|
|
this.wallet = wallet;
|
|
|
|
return null;
|
|
});
|
|
|
|
/*
|
|
* Helpers
|
|
*/
|
|
|
|
function RPCError(msg) {
|
|
Error.call(this);
|
|
|
|
if (Error.captureStackTrace)
|
|
Error.captureStackTrace(this, RPCError);
|
|
|
|
this.type = 'RPCError';
|
|
this.message = msg;
|
|
}
|
|
|
|
util.inherits(RPCError, Error);
|
|
|
|
function toBool(obj, def) {
|
|
if (typeof obj === 'boolean' || typeof obj === 'number')
|
|
return !!obj;
|
|
return def || false;
|
|
}
|
|
|
|
function toNumber(obj, def) {
|
|
if (util.isNumber(obj))
|
|
return obj;
|
|
return def != null ? def : -1;
|
|
}
|
|
|
|
function toString(obj, def) {
|
|
if (typeof obj === 'string')
|
|
return obj;
|
|
return def != null ? def : '';
|
|
}
|
|
|
|
function toArray(obj, def) {
|
|
if (Array.isArray(obj))
|
|
return obj;
|
|
return def != null ? def : null;
|
|
}
|
|
|
|
function toObject(obj, def) {
|
|
if (obj && typeof obj === 'object')
|
|
return obj;
|
|
return def != null ? def : null;
|
|
}
|
|
|
|
function toHash(obj) {
|
|
if (!isHash(obj))
|
|
return null;
|
|
return util.revHex(obj);
|
|
}
|
|
|
|
function isHash(obj) {
|
|
return util.isHex(obj) && obj.length === 64;
|
|
}
|
|
|
|
function toSatoshi(obj) {
|
|
if (typeof obj !== 'number')
|
|
throw new RPCError('Bad BTC amount.');
|
|
return Amount.value(obj, true);
|
|
}
|
|
|
|
function sortTX(txs) {
|
|
return txs.sort(function(a, b) {
|
|
return a.ps - b.ps;
|
|
});
|
|
}
|
|
|
|
function sortCoins(coins) {
|
|
return coins.sort(function(a, b) {
|
|
a = a.height === -1 ? 0x7fffffff : a.height;
|
|
b = b.height === -1 ? 0x7fffffff : b.height;
|
|
return a - b;
|
|
});
|
|
}
|
|
|
|
/*
|
|
* Expose
|
|
*/
|
|
|
|
module.exports = RPC;
|