Source: wallet/rpc.js

  1. /*!
  2.  * rpc.js - bitcoind-compatible json rpc for bcoin.
  3.  * Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
  4.  * https://github.com/bcoin-org/bcoin
  5.  */
  7. 'use strict';
  9. const assert = require('bsert');
  10. const {format} = require('util');
  11. const bweb = require('bweb');
  12. const {Lock} = require('bmutex');
  13. const fs = require('bfile');
  14. const Validator = require('bval');
  15. const {BufferMap, BufferSet} = require('buffer-map');
  16. const util = require('../utils/util');
  17. const messageUtil = require('../utils/message');
  18. const Amount = require('../btc/amount');
  19. const Script = require('../script/script');
  20. const Address = require('../primitives/address');
  21. const KeyRing = require('../primitives/keyring');
  22. const MerkleBlock = require('../primitives/merkleblock');
  23. const MTX = require('../primitives/mtx');
  24. const Outpoint = require('../primitives/outpoint');
  25. const Output = require('../primitives/output');
  26. const TX = require('../primitives/tx');
  27. const consensus = require('../protocol/consensus');
  28. const pkg = require('../pkg');
  29. const common = require('./common');
  30. const {BlockMeta} = require('./records');
  31. const RPCBase = bweb.RPC;
  32. const RPCError = bweb.RPCError;
  34. /*
  35.  * Constants
  36.  */
  38. const errs = {
  39.   // Standard JSON-RPC 2.0 errors
  40.   INVALID_REQUEST: bweb.errors.INVALID_REQUEST,
  41.   METHOD_NOT_FOUND: bweb.errors.METHOD_NOT_FOUND,
  42.   INVALID_PARAMS: bweb.errors.INVALID_PARAMS,
  43.   INTERNAL_ERROR: bweb.errors.INTERNAL_ERROR,
  44.   PARSE_ERROR: bweb.errors.PARSE_ERROR,
  46.   // General application defined errors
  47.   MISC_ERROR: -1,
  48.   FORBIDDEN_BY_SAFE_MODE: -2,
  49.   TYPE_ERROR: -3,
  50.   INVALID_ADDRESS_OR_KEY: -5,
  51.   OUT_OF_MEMORY: -7,
  52.   INVALID_PARAMETER: -8,
  53.   DATABASE_ERROR: -20,
  54.   DESERIALIZATION_ERROR: -22,
  55.   VERIFY_ERROR: -25,
  56.   VERIFY_REJECTED: -26,
  57.   VERIFY_ALREADY_IN_CHAIN: -27,
  58.   IN_WARMUP: -28,
  60.   // Wallet errors
  61.   WALLET_ERROR: -4,
  62.   WALLET_INSUFFICIENT_FUNDS: -6,
  63.   WALLET_INVALID_ACCOUNT_NAME: -11,
  64.   WALLET_KEYPOOL_RAN_OUT: -12,
  65.   WALLET_UNLOCK_NEEDED: -13,
  66.   WALLET_PASSPHRASE_INCORRECT: -14,
  67.   WALLET_WRONG_ENC_STATE: -15,
  68.   WALLET_ENCRYPTION_FAILED: -16,
  69.   WALLET_ALREADY_UNLOCKED: -17
  70. };
  72. /**
  73.  * Wallet RPC
  74.  * @alias module:wallet.RPC
  75.  * @extends bweb.RPC
  76.  */
  78. class RPC extends RPCBase {
  79.   /**
  80.    * Create an RPC.
  81.    * @param {WalletDB} wdb
  82.    */
  84.   constructor(node) {
  85.     super();
  87.     assert(node, 'RPC requires a WalletDB.');
  89.     this.wdb = node.wdb;
  90.     this.network = node.network;
  91.     this.logger = node.logger.context('wallet-rpc');
  92.     this.client = node.client;
  93.     this.locker = new Lock();
  95.     this.wallet = null;
  97.     this.init();
  98.   }
  100.   getCode(err) {
  101.     switch (err.type) {
  102.       case 'RPCError':
  103.         return err.code;
  104.       case 'ValidationError':
  105.         return errs.TYPE_ERROR;
  106.       case 'EncodingError':
  107.         return errs.DESERIALIZATION_ERROR;
  108.       case 'FundingError':
  109.         return errs.WALLET_INSUFFICIENT_FUNDS;
  110.       default:
  111.         return errs.INTERNAL_ERROR;
  112.     }
  113.   }
  115.   handleCall(cmd, query) {
  116.     this.logger.debug('Handling RPC call: %s.', cmd.method);
  117.   }
  119.   init() {
  120.     this.add('help', this.help);
  121.     this.add('stop', this.stop);
  122.     this.add('fundrawtransaction', this.fundRawTransaction);
  123.     this.add('resendwallettransactions', this.resendWalletTransactions);
  124.     this.add('abandontransaction', this.abandonTransaction);
  125.     this.add('addmultisigaddress', this.addMultisigAddress);
  126.     this.add('addwitnessaddress', this.addWitnessAddress);
  127.     this.add('backupwallet', this.backupWallet);
  128.     this.add('dumpprivkey', this.dumpPrivKey);
  129.     this.add('dumpwallet', this.dumpWallet);
  130.     this.add('encryptwallet', this.encryptWallet);
  131.     this.add('getaddressinfo', this.getAddressInfo);
  132.     this.add('getaccountaddress', this.getAccountAddress);
  133.     this.add('getaccount', this.getAccount);
  134.     this.add('getaddressesbyaccount', this.getAddressesByAccount);
  135.     this.add('getbalance', this.getBalance);
  136.     this.add('getnewaddress', this.getNewAddress);
  137.     this.add('getrawchangeaddress', this.getRawChangeAddress);
  138.     this.add('getreceivedbyaccount', this.getReceivedByAccount);
  139.     this.add('getreceivedbyaddress', this.getReceivedByAddress);
  140.     this.add('gettransaction', this.getTransaction);
  141.     this.add('getunconfirmedbalance', this.getUnconfirmedBalance);
  142.     this.add('getwalletinfo', this.getWalletInfo);
  143.     this.add('importprivkey', this.importPrivKey);
  144.     this.add('importwallet', this.importWallet);
  145.     this.add('importaddress', this.importAddress);
  146.     this.add('importprunedfunds', this.importPrunedFunds);
  147.     this.add('importpubkey', this.importPubkey);
  148.     this.add('keypoolrefill', this.keyPoolRefill);
  149.     this.add('listaccounts', this.listAccounts);
  150.     this.add('listaddressgroupings', this.listAddressGroupings);
  151.     this.add('listlockunspent', this.listLockUnspent);
  152.     this.add('listreceivedbyaccount', this.listReceivedByAccount);
  153.     this.add('listreceivedbyaddress', this.listReceivedByAddress);
  154.     this.add('listsinceblock', this.listSinceBlock);
  155.     this.add('listtransactions', this.listTransactions);
  156.     this.add('listunspent', this.listUnspent);
  157.     this.add('lockunspent', this.lockUnspent);
  158.     this.add('move', this.move);
  159.     this.add('sendfrom', this.sendFrom);
  160.     this.add('sendmany', this.sendMany);
  161.     this.add('sendtoaddress', this.sendToAddress);
  162.     this.add('setaccount', this.setAccount);
  163.     this.add('settxfee', this.setTXFee);
  164.     this.add('signmessage', this.signMessage);
  165.     this.add('walletlock', this.walletLock);
  166.     this.add('walletpassphrasechange', this.walletPassphraseChange);
  167.     this.add('walletpassphrase', this.walletPassphrase);
  168.     this.add('removeprunedfunds', this.removePrunedFunds);
  169.     this.add('selectwallet', this.selectWallet);
  170.     this.add('getmemoryinfo', this.getMemoryInfo);
  171.     this.add('setloglevel', this.setLogLevel);
  172.   }
  174.   async help(args, _help) {
  175.     if (args.length === 0)
  176.       return `Select a command:\n${Object.keys(this.calls).join('\n')}`;
  178.     const json = {
  179.       method: args[0],
  180.       params: []
  181.     };
  183.     return await this.execute(json, true);
  184.   }
  186.   async stop(args, help) {
  187.     if (help || args.length !== 0)
  188.       throw new RPCError(errs.MISC_ERROR, 'stop');
  190.     this.wdb.close();
  192.     return 'Stopping.';
  193.   }
  195.   async fundRawTransaction(args, help) {
  196.     if (help || args.length < 1 || args.length > 2) {
  197.       throw new RPCError(errs.MISC_ERROR,
  198.         'fundrawtransaction "hexstring" ( options )');
  199.     }
  201.     const wallet = this.wallet;
  202.     const valid = new Validator(args);
  203.     const data = valid.buf(0);
  204.     const options = valid.obj(1);
  206.     if (!data)
  207.       throw new RPCError(errs.TYPE_ERROR, 'Invalid hex string.');
  209.     const tx = MTX.fromRaw(data);
  211.     if (tx.outputs.length === 0) {
  212.       throw new RPCError(errs.INVALID_PARAMETER,
  213.         'TX must have at least one output.');
  214.     }
  216.     let rate = null;
  217.     let change = null;
  219.     if (options) {
  220.       const valid = new Validator(options);
  222.       rate = valid.ufixed('feeRate', 8);
  223.       change = valid.str('changeAddress');
  225.       if (change)
  226.         change = parseAddress(change, this.network);
  227.     }
  229.     await wallet.fund(tx, {
  230.       rate: rate,
  231.       changeAddress: change
  232.     });
  234.     return {
  235.       hex: tx.toRaw().toString('hex'),
  236.       changepos: tx.changeIndex,
  237.       fee: Amount.btc(tx.getFee(), true)
  238.     };
  239.   }
  241.   /*
  242.    * Wallet
  243.    */
  245.   async resendWalletTransactions(args, help) {
  246.     if (help || args.length !== 0)
  247.       throw new RPCError(errs.MISC_ERROR, 'resendwallettransactions');
  249.     const wallet = this.wallet;
  250.     const txs = await wallet.resend();
  251.     const hashes = [];
  253.     for (const tx of txs)
  254.       hashes.push(tx.txid());
  256.     return hashes;
  257.   }
  259.   async addMultisigAddress(args, help) {
  260.     // Impossible to implement in bcoin (no address book).
  261.     throw new Error('Not implemented.');
  262.   }
  264.   async addWitnessAddress(args, help) {
  265.     // Unlikely to be implemented.
  266.     throw new Error('Not implemented.');
  267.   }
  269.   async backupWallet(args, help) {
  270.     const valid = new Validator(args);
  271.     const dest = valid.str(0);
  273.     if (help || args.length !== 1 || !dest)
  274.       throw new RPCError(errs.MISC_ERROR, 'backupwallet "destination"');
  276.     await this.wdb.backup(dest);
  278.     return null;
  279.   }
  281.   async dumpPrivKey(args, help) {
  282.     if (help || args.length !== 1)
  283.       throw new RPCError(errs.MISC_ERROR, 'dumpprivkey "bitcoinaddress"');
  285.     const wallet = this.wallet;
  286.     const valid = new Validator(args);
  287.     const addr = valid.str(0, '');
  289.     const hash = parseHash(addr, this.network);
  290.     const ring = await wallet.getPrivateKey(hash);
  292.     if (!ring)
  293.       throw new RPCError(errs.MISC_ERROR, 'Key not found.');
  295.     return ring.toSecret(this.network);
  296.   }
  298.   async dumpWallet(args, help) {
  299.     if (help || args.length !== 1)
  300.       throw new RPCError(errs.MISC_ERROR, 'dumpwallet "filename"');
  302.     const wallet = this.wallet;
  303.     const valid = new Validator(args);
  304.     const file = valid.str(0);
  306.     if (!file)
  307.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter.');
  309.     const tip = await this.wdb.getTip();
  310.     const time = util.date();
  312.     const out = [
  313.       format('# Wallet Dump created by Bcoin %s', pkg.version),
  314.       format('# * Created on %s', time),
  315.       format('# * Best block at time of backup was %d (%s).',
  316.         tip.height, util.revHex(tip.hash)),
  317.       format('# * File: %s', file),
  318.       ''
  319.     ];
  321.     const hashes = await wallet.getAddressHashes();
  323.     for (const hash of hashes) {
  324.       const ring = await wallet.getPrivateKey(hash);
  326.       if (!ring)
  327.         continue;
  329.       const addr = ring.getAddress('string', this.network);
  331.       let fmt = '%s %s label= addr=%s';
  333.       if (ring.branch === 1)
  334.         fmt = '%s %s change=1 addr=%s';
  336.       const str = format(fmt, ring.toSecret(this.network), time, addr);
  338.       out.push(str);
  339.     }
  341.     out.push('');
  342.     out.push('# End of dump');
  343.     out.push('');
  345.     const dump = out.join('\n');
  347.     if (fs.unsupported)
  348.       return dump;
  350.     await fs.writeFile(file, dump, 'utf8');
  352.     return null;
  353.   }
  355.   async encryptWallet(args, help) {
  356.     const wallet = this.wallet;
  358.     if (!wallet.master.encrypted && (help || args.length !== 1))
  359.       throw new RPCError(errs.MISC_ERROR, 'encryptwallet "passphrase"');
  361.     const valid = new Validator(args);
  362.     const passphrase = valid.str(0, '');
  364.     if (wallet.master.encrypted) {
  365.       throw new RPCError(errs.WALLET_WRONG_ENC_STATE,
  366.         'Already running with an encrypted wallet.');
  367.     }
  369.     if (passphrase.length < 1)
  370.       throw new RPCError(errs.MISC_ERROR, 'encryptwallet "passphrase"');
  372.     try {
  373.       await wallet.encrypt(passphrase);
  374.     } catch (e) {
  375.       throw new RPCError(errs.WALLET_ENCRYPTION_FAILED, 'Encryption failed.');
  376.     }
  378.     return 'wallet encrypted; we do not need to stop!';
  379.   }
  381.   async getAccountAddress(args, help) {
  382.     if (help || args.length !== 1)
  383.       throw new RPCError(errs.MISC_ERROR, 'getaccountaddress "account"');
  385.     const wallet = this.wallet;
  386.     const valid = new Validator(args);
  387.     let name = valid.str(0, '');
  389.     if (!name)
  390.       name = 'default';
  392.     const addr = await wallet.receiveAddress(name);
  394.     if (!addr)
  395.       return '';
  397.     return addr.toString(this.network);
  398.   }
  400.   async getAccount(args, help) {
  401.     if (help || args.length !== 1)
  402.       throw new RPCError(errs.MISC_ERROR, 'getaccount "bitcoinaddress"');
  404.     const wallet = this.wallet;
  405.     const valid = new Validator(args);
  406.     const addr = valid.str(0, '');
  408.     const hash = parseHash(addr, this.network);
  409.     const path = await wallet.getPath(hash);
  411.     if (!path)
  412.       return '';
  414.     return path.name;
  415.   }
  417.   async getAddressesByAccount(args, help) {
  418.     if (help || args.length !== 1)
  419.       throw new RPCError(errs.MISC_ERROR, 'getaddressesbyaccount "account"');
  421.     const wallet = this.wallet;
  422.     const valid = new Validator(args);
  423.     let name = valid.str(0, '');
  424.     const addrs = [];
  426.     if (name === '')
  427.       name = 'default';
  429.     let paths;
  430.     try {
  431.       paths = await wallet.getPaths(name);
  432.     } catch (e) {
  433.       if (e.message === 'Account not found.')
  434.         return [];
  435.       throw e;
  436.     }
  438.     for (const path of paths) {
  439.       const addr = path.toAddress();
  440.       addrs.push(addr.toString(this.network));
  441.     }
  443.     return addrs;
  444.   }
  446.   async getAddressInfo(args, help) {
  447.     if (help || args.length !== 1)
  448.       throw new RPCError(errs.MISC_ERROR, 'getaddressinfo "address"');
  450.     const valid = new Validator(args);
  451.     const addr = valid.str(0, '');
  453.     const address = parseAddress(addr, this.network);
  454.     const script = Script.fromAddress(address);
  455.     const wallet = this.wallet.toJSON();
  457.     const path = await this.wallet.getPath(address);
  459.     const isScript = script.isScripthash() || script.isWitnessScripthash();
  460.     const isWitness = address.isProgram();
  462.     const result = {
  463.       address: address.toString(this.network),
  464.       scriptPubKey: script ? script.toJSON() : undefined,
  465.       ismine: path != null,
  466.       ischange: path ? path.branch === 1 : false,
  467.       iswatchonly: wallet.watchOnly,
  468.       isscript: isScript,
  469.       iswitness: isWitness
  470.     };
  472.     if (isWitness) {
  473.       result.witness_version = address.version;
  474.       result.witness_program = address.hash.toString('hex');
  475.     }
  477.     return result;
  478.   }
  480.   async getBalance(args, help) {
  481.     if (help || args.length > 3) {
  482.       throw new RPCError(errs.MISC_ERROR,
  483.         'getbalance ( "account" minconf includeWatchonly )');
  484.     }
  486.     const wallet = this.wallet;
  487.     const valid = new Validator(args);
  488.     let name = valid.str(0);
  489.     const minconf = valid.u32(1, 1);
  490.     const watchOnly = valid.bool(2, false);
  492.     if (name === '')
  493.       name = 'default';
  495.     if (name === '*')
  496.       name = null;
  498.     if (wallet.watchOnly !== watchOnly)
  499.       return 0;
  501.     const balance = await wallet.getBalance(name);
  503.     let value;
  504.     if (minconf > 0)
  505.       value = balance.confirmed;
  506.     else
  507.       value = balance.unconfirmed;
  509.     return Amount.btc(value, true);
  510.   }
  512.   async getNewAddress(args, help) {
  513.     if (help || args.length > 1)
  514.       throw new RPCError(errs.MISC_ERROR, 'getnewaddress ( "account" )');
  516.     const wallet = this.wallet;
  517.     const valid = new Validator(args);
  518.     let name = valid.str(0);
  520.     if (name === '' || args.length === 0)
  521.       name = 'default';
  523.     const addr = await wallet.createReceive(name);
  525.     return addr.getAddress('string', this.network);
  526.   }
  528.   async getRawChangeAddress(args, help) {
  529.     if (help || args.length !== 0)
  530.       throw new RPCError(errs.MISC_ERROR, 'getrawchangeaddress');
  532.     const wallet = this.wallet;
  533.     const addr = await wallet.createChange();
  535.     return addr.getAddress('string', this.network);
  536.   }
  538.   async getReceivedByAccount(args, help) {
  539.     if (help || args.length < 1 || args.length > 2) {
  540.       throw new RPCError(errs.MISC_ERROR,
  541.         'getreceivedbyaccount "account" ( minconf )');
  542.     }
  544.     const wallet = this.wallet;
  545.     const valid = new Validator(args);
  546.     let name = valid.str(0);
  547.     const minconf = valid.u32(1, 0);
  548.     const height = this.wdb.state.height;
  550.     if (name === '')
  551.       name = 'default';
  553.     const paths = await wallet.getPaths(name);
  554.     const filter = new BufferSet();
  556.     for (const path of paths)
  557.       filter.add(path.hash);
  559.     const txs = await wallet.getHistory(name);
  561.     let total = 0;
  562.     let lastConf = -1;
  564.     for (const wtx of txs) {
  565.       const conf = wtx.getDepth(height);
  567.       if (conf < minconf)
  568.         continue;
  570.       if (lastConf === -1 || conf < lastConf)
  571.         lastConf = conf;
  573.       for (const output of wtx.tx.outputs) {
  574.         const hash = output.getHash();
  575.         if (hash && filter.has(hash))
  576.           total += output.value;
  577.       }
  578.     }
  580.     return Amount.btc(total, true);
  581.   }
  583.   async getReceivedByAddress(args, help) {
  584.     if (help || args.length < 1 || args.length > 2) {
  585.       throw new RPCError(errs.MISC_ERROR,
  586.         'getreceivedbyaddress "bitcoinaddress" ( minconf )');
  587.     }
  589.     const wallet = this.wallet;
  590.     const valid = new Validator(args);
  591.     const addr = valid.str(0, '');
  592.     const minconf = valid.u32(1, 0);
  593.     const height = this.wdb.state.height;
  595.     const hash = parseHash(addr, this.network);
  596.     const txs = await wallet.getHistory();
  598.     let total = 0;
  600.     for (const wtx of txs) {
  601.       if (wtx.getDepth(height) < minconf)
  602.         continue;
  604.       for (const output of wtx.tx.outputs) {
  605.         if (output.getHash().equals(hash))
  606.           total += output.value;
  607.       }
  608.     }
  610.     return Amount.btc(total, true);
  611.   }
  613.   async _toWalletTX(wtx) {
  614.     const wallet = this.wallet;
  615.     const details = await wallet.toDetails(wtx);
  617.     if (!details)
  618.       throw new RPCError(errs.WALLET_ERROR, 'TX not found.');
  620.     let receive = true;
  621.     for (const member of details.inputs) {
  622.       if (member.path) {
  623.         receive = false;
  624.         break;
  625.       }
  626.     }
  628.     const det = [];
  629.     let sent = 0;
  630.     let received = 0;
  632.     for (let i = 0; i < details.outputs.length; i++) {
  633.       const member = details.outputs[i];
  635.       if (member.path) {
  636.         if (member.path.branch === 1)
  637.           continue;
  639.         det.push({
  640.           account: member.path.name,
  641.           address: member.address.toString(this.network),
  642.           category: 'receive',
  643.           amount: Amount.btc(member.value, true),
  644.           label: member.path.name,
  645.           vout: i
  646.         });
  648.         received += member.value;
  650.         continue;
  651.       }
  653.       if (receive)
  654.         continue;
  656.       det.push({
  657.         account: '',
  658.         address: member.address
  659.           ? member.address.toString(this.network)
  660.           : null,
  661.         category: 'send',
  662.         amount: -(Amount.btc(member.value, true)),
  663.         fee: -(Amount.btc(details.fee, true)),
  664.         vout: i
  665.       });
  667.       sent += member.value;
  668.     }
  670.     return {
  671.       amount: Amount.btc(receive ? received : -sent, true),
  672.       confirmations: details.confirmations,
  673.       blockhash: details.block ? util.revHex(details.block) : null,
  674.       blockindex: details.index,
  675.       blocktime: details.time,
  676.       txid: util.revHex(details.hash),
  677.       walletconflicts: [],
  678.       time: details.mtime,
  679.       timereceived: details.mtime,
  680.       'bip125-replaceable': 'no',
  681.       details: det,
  682.       hex: details.tx.toRaw().toString('hex')
  683.     };
  684.   }
  686.   async getTransaction(args, help) {
  687.     if (help || args.length < 1 || args.length > 2) {
  688.       throw new RPCError(errs.MISC_ERROR,
  689.         'gettransaction "txid" ( includeWatchonly )');
  690.     }
  692.     const wallet = this.wallet;
  693.     const valid = new Validator(args);
  694.     const hash = valid.brhash(0);
  695.     const watchOnly = valid.bool(1, false);
  697.     if (!hash)
  698.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter');
  700.     const wtx = await wallet.getTX(hash);
  702.     if (!wtx)
  703.       throw new RPCError(errs.WALLET_ERROR, 'TX not found.');
  705.     return await this._toWalletTX(wtx, watchOnly);
  706.   }
  708.   async abandonTransaction(args, help) {
  709.     if (help || args.length !== 1)
  710.       throw new RPCError(errs.MISC_ERROR, 'abandontransaction "txid"');
  712.     const wallet = this.wallet;
  713.     const valid = new Validator(args);
  714.     const hash = valid.brhash(0);
  716.     if (!hash)
  717.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter.');
  719.     const result = await wallet.abandon(hash);
  721.     if (!result)
  722.       throw new RPCError(errs.WALLET_ERROR, 'Transaction not in wallet.');
  724.     return null;
  725.   }
  727.   async getUnconfirmedBalance(args, help) {
  728.     if (help || args.length > 0)
  729.       throw new RPCError(errs.MISC_ERROR, 'getunconfirmedbalance');
  731.     const wallet = this.wallet;
  732.     const balance = await wallet.getBalance();
  734.     return Amount.btc(balance.unconfirmed, true);
  735.   }
  737.   async getWalletInfo(args, help) {
  738.     if (help || args.length !== 0)
  739.       throw new RPCError(errs.MISC_ERROR, 'getwalletinfo');
  741.     const wallet = this.wallet;
  742.     const balance = await wallet.getBalance();
  744.     return {
  745.       walletid: wallet.id,
  746.       walletversion: 6,
  747.       balance: Amount.btc(balance.unconfirmed, true),
  748.       unconfirmed_balance: Amount.btc(balance.unconfirmed, true),
  749.       txcount: balance.tx,
  750.       keypoololdest: 0,
  751.       keypoolsize: 0,
  752.       unlocked_until: wallet.master.until,
  753.       paytxfee: Amount.btc(this.wdb.feeRate, true)
  754.     };
  755.   }
  757.   async importPrivKey(args, help) {
  758.     if (help || args.length < 1 || args.length > 3) {
  759.       throw new RPCError(errs.MISC_ERROR,
  760.         'importprivkey "bitcoinprivkey" ( "label" rescan )');
  761.     }
  763.     const wallet = this.wallet;
  764.     const valid = new Validator(args);
  765.     const secret = valid.str(0);
  766.     const rescan = valid.bool(2, false);
  768.     const key = parseSecret(secret, this.network);
  770.     await wallet.importKey(0, key);
  772.     if (rescan)
  773.       await this.wdb.rescan(0);
  775.     return null;
  776.   }
  778.   async importWallet(args, help) {
  779.     if (help || args.length < 1 || args.length > 2)
  780.       throw new RPCError(errs.MISC_ERROR, 'importwallet "filename" ( rescan )');
  782.     const wallet = this.wallet;
  783.     const valid = new Validator(args);
  784.     const file = valid.str(0);
  785.     const rescan = valid.bool(1, false);
  787.     if (fs.unsupported)
  788.       throw new RPCError(errs.INTERNAL_ERROR, 'FS not available.');
  790.     let data;
  791.     try {
  792.       data = await fs.readFile(file, 'utf8');
  793.     } catch (e) {
  794.       throw new RPCError(errs.INTERNAL_ERROR, e.code || '');
  795.     }
  797.     const lines = data.split(/\n+/);
  798.     const keys = [];
  800.     for (let line of lines) {
  801.       line = line.trim();
  803.       if (line.length === 0)
  804.         continue;
  806.       if (/^\s*#/.test(line))
  807.         continue;
  809.       const parts = line.split(/\s+/);
  811.       if (parts.length < 4)
  812.         throw new RPCError(errs.DESERIALIZATION_ERROR, 'Malformed wallet.');
  814.       const secret = parseSecret(parts[0], this.network);
  816.       keys.push(secret);
  817.     }
  819.     for (const key of keys)
  820.       await wallet.importKey(0, key);
  822.     if (rescan)
  823.       await this.wdb.rescan(0);
  825.     return null;
  826.   }
  828.   async importAddress(args, help) {
  829.     if (help || args.length < 1 || args.length > 4) {
  830.       throw new RPCError(errs.MISC_ERROR,
  831.         'importaddress "address" ( "label" rescan p2sh )');
  832.     }
  834.     const wallet = this.wallet;
  835.     const valid = new Validator(args);
  836.     let addr = valid.str(0, '');
  837.     const rescan = valid.bool(2, false);
  838.     const p2sh = valid.bool(3, false);
  840.     if (p2sh) {
  841.       let script = valid.buf(0);
  843.       if (!script)
  844.         throw new RPCError(errs.TYPE_ERROR, 'Invalid parameters.');
  846.       script = Script.fromRaw(script);
  847.       script = Script.fromScripthash(script.hash160());
  849.       addr = script.getAddress();
  850.     } else {
  851.       addr = parseAddress(addr, this.network);
  852.     }
  854.     try {
  855.       await wallet.importAddress(0, addr);
  856.     } catch (e) {
  857.       if (e.message !== 'Address already exists.')
  858.         throw e;
  859.     }
  861.     if (rescan)
  862.       await this.wdb.rescan(0);
  864.     return null;
  865.   }
  867.   async importPubkey(args, help) {
  868.     if (help || args.length < 1 || args.length > 3) {
  869.       throw new RPCError(errs.MISC_ERROR,
  870.         'importpubkey "pubkey" ( "label" rescan )');
  871.     }
  873.     const wallet = this.wallet;
  874.     const valid = new Validator(args);
  875.     const data = valid.buf(0);
  876.     const rescan = valid.bool(2, false);
  878.     if (!data)
  879.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter.');
  881.     const key = KeyRing.fromPublic(data, this.network);
  883.     await wallet.importKey(0, key);
  885.     if (rescan)
  886.       await this.wdb.rescan(0);
  888.     return null;
  889.   }
  891.   async keyPoolRefill(args, help) {
  892.     if (help || args.length > 1)
  893.       throw new RPCError(errs.MISC_ERROR, 'keypoolrefill ( newsize )');
  894.     return null;
  895.   }
  897.   async listAccounts(args, help) {
  898.     if (help || args.length > 2) {
  899.       throw new RPCError(errs.MISC_ERROR,
  900.         'listaccounts ( minconf includeWatchonly)');
  901.     }
  903.     const wallet = this.wallet;
  904.     const valid = new Validator(args);
  905.     const minconf = valid.u32(0, 0);
  906.     const watchOnly = valid.bool(1, false);
  908.     const accounts = await wallet.getAccounts();
  909.     const map = {};
  911.     for (const account of accounts) {
  912.       const balance = await wallet.getBalance(account);
  913.       let value = balance.unconfirmed;
  915.       if (minconf > 0)
  916.         value = balance.confirmed;
  918.       if (wallet.watchOnly !== watchOnly)
  919.         value = 0;
  921.       map[account] = Amount.btc(value, true);
  922.     }
  924.     return map;
  925.   }
  927.   async listAddressGroupings(args, help) {
  928.     throw new Error('Not implemented.');
  929.   }
  931.   async listLockUnspent(args, help) {
  932.     if (help || args.length > 0)
  933.       throw new RPCError(errs.MISC_ERROR, 'listlockunspent');
  935.     const wallet = this.wallet;
  936.     const outpoints = wallet.getLocked();
  937.     const out = [];
  939.     for (const outpoint of outpoints) {
  940.       out.push({
  941.         txid: outpoint.txid(),
  942.         vout: outpoint.index
  943.       });
  944.     }
  946.     return out;
  947.   }
  949.   async listReceivedByAccount(args, help) {
  950.     if (help || args.length > 3) {
  951.       throw new RPCError(errs.MISC_ERROR,
  952.         'listreceivedbyaccount ( minconf includeempty includeWatchonly )');
  953.     }
  955.     const valid = new Validator(args);
  956.     const minconf = valid.u32(0, 0);
  957.     const includeEmpty = valid.bool(1, false);
  958.     const watchOnly = valid.bool(2, false);
  960.     return await this._listReceived(minconf, includeEmpty, watchOnly, true);
  961.   }
  963.   async listReceivedByAddress(args, help) {
  964.     if (help || args.length > 3) {
  965.       throw new RPCError(errs.MISC_ERROR,
  966.         'listreceivedbyaddress ( minconf includeempty includeWatchonly )');
  967.     }
  969.     const valid = new Validator(args);
  970.     const minconf = valid.u32(0, 0);
  971.     const includeEmpty = valid.bool(1, false);
  972.     const watchOnly = valid.bool(2, false);
  974.     return await this._listReceived(minconf, includeEmpty, watchOnly, false);
  975.   }
  977.   async _listReceived(minconf, empty, watchOnly, account) {
  978.     const wallet = this.wallet;
  979.     const paths = await wallet.getPaths();
  980.     const height = this.wdb.state.height;
  982.     const map = new BufferMap();
  983.     for (const path of paths) {
  984.       const addr = path.toAddress();
  985.       map.set(path.hash, {
  986.         involvesWatchonly: wallet.watchOnly,
  987.         address: addr.toString(this.network),
  988.         account: path.name,
  989.         amount: 0,
  990.         confirmations: -1,
  991.         label: ''
  992.       });
  993.     }
  995.     const txs = await wallet.getHistory();
  997.     for (const wtx of txs) {
  998.       const conf = wtx.getDepth(height);
  1000.       if (conf < minconf)
  1001.         continue;
  1003.       for (const output of wtx.tx.outputs) {
  1004.         const addr = output.getAddress();
  1006.         if (!addr)
  1007.           continue;
  1009.         const hash = addr.getHash();
  1010.         const entry = map.get(hash);
  1012.         if (entry) {
  1013.           if (entry.confirmations === -1 || conf < entry.confirmations)
  1014.             entry.confirmations = conf;
  1015.           entry.address = addr.toString(this.network);
  1016.           entry.amount += output.value;
  1017.         }
  1018.       }
  1019.     }
  1021.     let out = [];
  1022.     for (const entry of map.values())
  1023.       out.push(entry);
  1025.     if (account) {
  1026.       const map = new Map();
  1028.       for (const entry of out) {
  1029.         const item = map.get(entry.account);
  1030.         if (!item) {
  1031.           map.set(entry.account, entry);
  1032.           entry.address = undefined;
  1033.           continue;
  1034.         }
  1035.         item.amount += entry.amount;
  1036.       }
  1038.       out = [];
  1040.       for (const entry of map.values())
  1041.         out.push(entry);
  1042.     }
  1044.     const result = [];
  1045.     for (const entry of out) {
  1046.       if (!empty && entry.amount === 0)
  1047.         continue;
  1049.       if (entry.confirmations === -1)
  1050.         entry.confirmations = 0;
  1052.       entry.amount = Amount.btc(entry.amount, true);
  1053.       result.push(entry);
  1054.     }
  1056.     return result;
  1057.   }
  1059.   async listSinceBlock(args, help) {
  1060.     if (help || args.length > 3) {
  1061.       throw new RPCError(errs.MISC_ERROR,
  1062.         'listsinceblock ( "blockhash" target-confirmations includeWatchonly)');
  1063.     }
  1065.     const wallet = this.wallet;
  1066.     const chainHeight = this.wdb.state.height;
  1067.     const valid = new Validator(args);
  1068.     const block = valid.brhash(0);
  1069.     const minconf = valid.u32(1, 0);
  1070.     const watchOnly = valid.bool(2, false);
  1072.     if (wallet.watchOnly !== watchOnly)
  1073.       return [];
  1075.     let height = -1;
  1077.     if (block) {
  1078.       const entry = await this.client.getEntry(block);
  1079.       if (entry)
  1080.         height = entry.height;
  1081.       else
  1082.         throw new RPCError(errs.MISC_ERROR, 'Block not found.');
  1083.     }
  1085.     if (height === -1)
  1086.       height = chainHeight;
  1088.     const txs = await wallet.getHistory();
  1089.     const out = [];
  1091.     let highest = null;
  1093.     for (const wtx of txs) {
  1094.       if (wtx.height < height)
  1095.         continue;
  1097.       if (wtx.getDepth(chainHeight) < minconf)
  1098.         continue;
  1100.       if (!highest || wtx.height > highest)
  1101.         highest = wtx;
  1103.       const json = await this._toListTX(wtx);
  1105.       out.push(json);
  1106.     }
  1108.     return {
  1109.       transactions: out,
  1110.       lastblock: highest && highest.block
  1111.         ? util.revHex(highest.block)
  1112.         : util.revHex(consensus.ZERO_HASH)
  1113.     };
  1114.   }
  1116.   async _toListTX(wtx) {
  1117.     const wallet = this.wallet;
  1118.     const details = await wallet.toDetails(wtx);
  1120.     if (!details)
  1121.       throw new RPCError(errs.WALLET_ERROR, 'TX not found.');
  1123.     let receive = true;
  1124.     for (const member of details.inputs) {
  1125.       if (member.path) {
  1126.         receive = false;
  1127.         break;
  1128.       }
  1129.     }
  1131.     let sent = 0;
  1132.     let received = 0;
  1133.     let sendMember = null;
  1134.     let recMember = null;
  1135.     let sendIndex = -1;
  1136.     let recIndex = -1;
  1138.     for (let i = 0; i < details.outputs.length; i++) {
  1139.       const member = details.outputs[i];
  1141.       if (member.path) {
  1142.         if (member.path.branch === 1)
  1143.           continue;
  1144.         received += member.value;
  1145.         recMember = member;
  1146.         recIndex = i;
  1147.         continue;
  1148.       }
  1150.       sent += member.value;
  1151.       sendMember = member;
  1152.       sendIndex = i;
  1153.     }
  1155.     let member = null;
  1156.     let index = -1;
  1158.     if (receive) {
  1159.       assert(recMember);
  1160.       member = recMember;
  1161.       index = recIndex;
  1162.     } else {
  1163.       if (sendMember) {
  1164.         member = sendMember;
  1165.         index = sendIndex;
  1166.       } else {
  1167.         // In the odd case where we send to ourselves.
  1168.         receive = true;
  1169.         received = 0;
  1170.         member = recMember;
  1171.         index = recIndex;
  1172.       }
  1173.     }
  1175.     let rbf = false;
  1177.     if (wtx.height === -1 && wtx.tx.isRBF())
  1178.       rbf = true;
  1180.     return {
  1181.       account: member.path ? member.path.name : '',
  1182.       address: member.address
  1183.         ? member.address.toString(this.network)
  1184.         : null,
  1185.       category: receive ? 'receive' : 'send',
  1186.       amount: Amount.btc(receive ? received : -sent, true),
  1187.       label: member.path ? member.path.name : undefined,
  1188.       vout: index,
  1189.       confirmations: details.getDepth(this.wdb.height),
  1190.       blockhash: details.block ? util.revHex(details.block) : null,
  1191.       blockindex: -1,
  1192.       blocktime: details.time,
  1193.       blockheight: details.height,
  1194.       txid: util.revHex(details.hash),
  1195.       walletconflicts: [],
  1196.       time: details.mtime,
  1197.       timereceived: details.mtime,
  1198.       'bip125-replaceable': rbf ? 'yes' : 'no'
  1199.     };
  1200.   }
  1202.   async listTransactions(args, help) {
  1203.     if (help || args.length > 4) {
  1204.       throw new RPCError(errs.MISC_ERROR,
  1205.         'listtransactions ( "account" count from includeWatchonly)');
  1206.     }
  1208.     const wallet = this.wallet;
  1209.     const valid = new Validator(args);
  1210.     let name = valid.str(0);
  1211.     const count = valid.u32(1, 10);
  1212.     const from = valid.u32(2, 0);
  1213.     const watchOnly = valid.bool(3, false);
  1215.     if (wallet.watchOnly !== watchOnly)
  1216.       return [];
  1218.     if (name === '')
  1219.       name = 'default';
  1221.     const txs = await wallet.getHistory(name);
  1223.     common.sortTX(txs);
  1225.     const end = from + count;
  1226.     const to = Math.min(end, txs.length);
  1227.     const out = [];
  1229.     for (let i = from; i < to; i++) {
  1230.       const wtx = txs[i];
  1231.       const json = await this._toListTX(wtx);
  1232.       out.push(json);
  1233.     }
  1235.     return out;
  1236.   }
  1238.   async listUnspent(args, help) {
  1239.     if (help || args.length > 3) {
  1240.       throw new RPCError(errs.MISC_ERROR,
  1241.         'listunspent ( minconf maxconf  ["address",...] )');
  1242.     }
  1244.     const wallet = this.wallet;
  1245.     const valid = new Validator(args);
  1246.     const minDepth = valid.u32(0, 1);
  1247.     const maxDepth = valid.u32(1, 9999999);
  1248.     const addrs = valid.array(2);
  1249.     const height = this.wdb.state.height;
  1251.     const map = new BufferSet();
  1253.     if (addrs) {
  1254.       const valid = new Validator(addrs);
  1255.       for (let i = 0; i < addrs.length; i++) {
  1256.         const addr = valid.str(i, '');
  1257.         const hash = parseHash(addr, this.network);
  1259.         if (map.has(hash))
  1260.           throw new RPCError(errs.INVALID_PARAMETER, 'Duplicate address.');
  1262.         map.add(hash);
  1263.       }
  1264.     }
  1266.     const coins = await wallet.getCoins();
  1268.     common.sortCoins(coins);
  1270.     const out = [];
  1272.     for (const coin of coins) {
  1273.       const depth = coin.getDepth(height);
  1275.       if (depth < minDepth || depth > maxDepth)
  1276.         continue;
  1278.       const addr = coin.getAddress();
  1280.       if (!addr)
  1281.         continue;
  1283.       const hash = coin.getHash();
  1285.       if (addrs) {
  1286.         if (!hash || !map.has(hash))
  1287.           continue;
  1288.       }
  1290.       const ring = await wallet.getKey(hash);
  1292.       out.push({
  1293.         txid: coin.txid(),
  1294.         vout: coin.index,
  1295.         address: addr ? addr.toString(this.network) : null,
  1296.         account: ring ? ring.name : undefined,
  1297.         redeemScript: ring && ring.script
  1298.           ? ring.script.toJSON()
  1299.           : undefined,
  1300.         scriptPubKey: coin.script.toJSON(),
  1301.         amount: Amount.btc(coin.value, true),
  1302.         confirmations: depth,
  1303.         spendable: !wallet.isLocked(coin),
  1304.         solvable: true
  1305.       });
  1306.     }
  1308.     return out;
  1309.   }
  1311.   async lockUnspent(args, help) {
  1312.     if (help || args.length < 1 || args.length > 2) {
  1313.       throw new RPCError(errs.MISC_ERROR,
  1314.         'lockunspent unlock ([{"txid":"txid","vout":n},...])');
  1315.     }
  1317.     const wallet = this.wallet;
  1318.     const valid = new Validator(args);
  1319.     const unlock = valid.bool(0, false);
  1320.     const outputs = valid.array(1);
  1322.     if (args.length === 1) {
  1323.       if (unlock)
  1324.         wallet.unlockCoins();
  1325.       return true;
  1326.     }
  1328.     if (!outputs)
  1329.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter.');
  1331.     for (const output of outputs) {
  1332.       const valid = new Validator(output);
  1333.       const hash = valid.brhash('txid');
  1334.       const index = valid.u32('vout');
  1336.       if (hash == null || index == null)
  1337.         throw new RPCError(errs.INVALID_PARAMETER, 'Invalid parameter.');
  1339.       const outpoint = new Outpoint(hash, index);
  1341.       if (unlock) {
  1342.         wallet.unlockCoin(outpoint);
  1343.         continue;
  1344.       }
  1346.       wallet.lockCoin(outpoint);
  1347.     }
  1349.     return true;
  1350.   }
  1352.   async move(args, help) {
  1353.     // Not implementing: stupid and deprecated.
  1354.     throw new Error('Not implemented.');
  1355.   }
  1357.   async sendFrom(args, help) {
  1358.     if (help || args.length < 3 || args.length > 6) {
  1359.       throw new RPCError(errs.MISC_ERROR,
  1360.         'sendfrom "fromaccount" "tobitcoinaddress"'
  1361.         + ' amount ( minconf "comment" "comment-to" )');
  1362.     }
  1364.     const wallet = this.wallet;
  1365.     const valid = new Validator(args);
  1366.     let name = valid.str(0);
  1367.     const str = valid.str(1);
  1368.     const value = valid.ufixed(2, 8);
  1369.     const minconf = valid.u32(3, 0);
  1371.     const addr = parseAddress(str, this.network);
  1373.     if (!addr || value == null)
  1374.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter.');
  1376.     if (name === '')
  1377.       name = 'default';
  1379.     const options = {
  1380.       account: name,
  1381.       depth: minconf,
  1382.       outputs: [{
  1383.         address: addr,
  1384.         value: value
  1385.       }]
  1386.     };
  1388.     const tx = await wallet.send(options);
  1390.     return tx.txid();
  1391.   }
  1393.   async sendMany(args, help) {
  1394.     if (help || args.length < 2 || args.length > 5) {
  1395.       throw new RPCError(errs.MISC_ERROR,
  1396.         'sendmany "fromaccount" {"address":amount,...}'
  1397.         + ' ( minconf "comment" subtractfee )');
  1398.     }
  1400.     const wallet = this.wallet;
  1401.     const valid = new Validator(args);
  1402.     let name = valid.str(0);
  1403.     const sendTo = valid.obj(1);
  1404.     const minconf = valid.u32(2, 1);
  1405.     const subtract = valid.bool(4, false);
  1407.     if (name === '')
  1408.       name = 'default';
  1410.     if (!sendTo)
  1411.       throw new RPCError(errs.TYPE_ERROR, 'Invalid send-to address.');
  1413.     const to = new Validator(sendTo);
  1414.     const uniq = new BufferSet();
  1415.     const outputs = [];
  1417.     for (const key of Object.keys(sendTo)) {
  1418.       const value = to.ufixed(key, 8);
  1419.       const addr = parseAddress(key, this.network);
  1420.       const hash = addr.getHash();
  1422.       if (value == null)
  1423.         throw new RPCError(errs.INVALID_PARAMETER, 'Invalid amount.');
  1425.       if (uniq.has(hash))
  1426.         throw new RPCError(errs.INVALID_PARAMETER,
  1427.           'Each send-to address must be unique.');
  1429.       uniq.add(hash);
  1431.       const output = new Output();
  1432.       output.value = value;
  1433.       output.script.fromAddress(addr);
  1434.       outputs.push(output);
  1435.     }
  1437.     const options = {
  1438.       outputs: outputs,
  1439.       subtractFee: subtract,
  1440.       account: name,
  1441.       depth: minconf
  1442.     };
  1444.     const tx = await wallet.send(options);
  1446.     return tx.txid();
  1447.   }
  1449.   async sendToAddress(args, help) {
  1450.     if (help || args.length < 2 || args.length > 5) {
  1451.       throw new RPCError(errs.MISC_ERROR,
  1452.         'sendtoaddress "bitcoinaddress" amount'
  1453.         + ' ( "comment" "comment-to" subtractfeefromamount )');
  1454.     }
  1456.     const wallet = this.wallet;
  1457.     const valid = new Validator(args);
  1458.     const str = valid.str(0);
  1459.     const value = valid.ufixed(1, 8);
  1460.     const subtract = valid.bool(4, false);
  1462.     const addr = parseAddress(str, this.network);
  1464.     if (!addr || value == null)
  1465.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter.');
  1467.     const options = {
  1468.       subtractFee: subtract,
  1469.       outputs: [{
  1470.         address: addr,
  1471.         value: value
  1472.       }]
  1473.     };
  1475.     const tx = await wallet.send(options);
  1477.     return tx.txid();
  1478.   }
  1480.   async setAccount(args, help) {
  1481.     // Impossible to implement in bcoin:
  1482.     throw new Error('Not implemented.');
  1483.   }
  1485.   async setTXFee(args, help) {
  1486.     const valid = new Validator(args);
  1487.     const rate = valid.ufixed(0, 8);
  1489.     if (help || args.length < 1 || args.length > 1)
  1490.       throw new RPCError(errs.MISC_ERROR, 'settxfee amount');
  1492.     if (rate == null)
  1493.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter.');
  1495.     this.wdb.feeRate = rate;
  1497.     return true;
  1498.   }
  1500.   async signMessage(args, help) {
  1501.     if (help || args.length !== 2) {
  1502.       throw new RPCError(errs.MISC_ERROR,
  1503.         'signmessage "bitcoinaddress" "message"');
  1504.     }
  1506.     const wallet = this.wallet;
  1507.     const valid = new Validator(args);
  1508.     const b58 = valid.str(0, '');
  1509.     const str = valid.str(1, '');
  1511.     const addr = parseHash(b58, this.network);
  1513.     const ring = await wallet.getKey(addr);
  1515.     if (!ring)
  1516.       throw new RPCError(errs.WALLET_ERROR, 'Address not found.');
  1518.     if (!wallet.master.key)
  1519.       throw new RPCError(errs.WALLET_UNLOCK_NEEDED, 'Wallet is locked.');
  1521.     const sig = messageUtil.sign(str, ring);
  1523.     return sig.toString('base64');
  1524.   }
  1526.   async walletLock(args, help) {
  1527.     const wallet = this.wallet;
  1529.     if (help || (wallet.master.encrypted && args.length !== 0))
  1530.       throw new RPCError(errs.MISC_ERROR, 'walletlock');
  1532.     if (!wallet.master.encrypted) {
  1533.       throw new RPCError(
  1534.         errs.WALLET_WRONG_ENC_STATE,
  1535.         'Wallet is not encrypted.');
  1536.     }
  1538.     await wallet.lock();
  1540.     return null;
  1541.   }
  1543.   async walletPassphraseChange(args, help) {
  1544.     const wallet = this.wallet;
  1546.     if (help || (wallet.master.encrypted && args.length !== 2)) {
  1547.       throw new RPCError(errs.MISC_ERROR, 'walletpassphrasechange'
  1548.         + ' "oldpassphrase" "newpassphrase"');
  1549.     }
  1551.     const valid = new Validator(args);
  1552.     const old = valid.str(0, '');
  1553.     const passphrase = valid.str(1, '');
  1555.     if (!wallet.master.encrypted) {
  1556.       throw new RPCError(
  1557.         errs.WALLET_WRONG_ENC_STATE,
  1558.         'Wallet is not encrypted.');
  1559.     }
  1561.     if (old.length < 1 || passphrase.length < 1)
  1562.       throw new RPCError(errs.INVALID_PARAMETER, 'Invalid parameter');
  1564.     await wallet.setPassphrase(passphrase, old);
  1566.     return null;
  1567.   }
  1569.   async walletPassphrase(args, help) {
  1570.     const wallet = this.wallet;
  1571.     const valid = new Validator(args);
  1572.     const passphrase = valid.str(0, '');
  1573.     const timeout = valid.u32(1);
  1575.     if (help || (wallet.master.encrypted && args.length !== 2)) {
  1576.       throw new RPCError(errs.MISC_ERROR,
  1577.         'walletpassphrase "passphrase" timeout');
  1578.     }
  1580.     if (!wallet.master.encrypted) {
  1581.       throw new RPCError(
  1582.         errs.WALLET_WRONG_ENC_STATE,
  1583.         'Wallet is not encrypted.');
  1584.     }
  1586.     if (passphrase.length < 1)
  1587.       throw new RPCError(errs.INVALID_PARAMETER, 'Invalid parameter');
  1589.     if (timeout == null)
  1590.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter');
  1592.     await wallet.unlock(passphrase, timeout);
  1594.     return null;
  1595.   }
  1597.   async importPrunedFunds(args, help) {
  1598.     if (help || args.length !== 2) {
  1599.       throw new RPCError(errs.MISC_ERROR,
  1600.         'importprunedfunds "rawtransaction" "txoutproof"');
  1601.     }
  1603.     const valid = new Validator(args);
  1604.     const txRaw = valid.buf(0);
  1605.     const blockRaw = valid.buf(1);
  1607.     if (!txRaw || !blockRaw)
  1608.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter.');
  1610.     const tx = TX.fromRaw(txRaw);
  1611.     const block = MerkleBlock.fromRaw(blockRaw);
  1612.     const hash = block.hash();
  1614.     if (!block.verify())
  1615.       throw new RPCError(errs.VERIFY_ERROR, 'Invalid proof.');
  1617.     if (!block.hasTX(tx.hash()))
  1618.       throw new RPCError(errs.VERIFY_ERROR, 'Invalid proof.');
  1620.     const entry = await this.client.getEntry(hash);
  1622.     if (!entry)
  1623.       throw new RPCError(errs.VERIFY_ERROR, 'Invalid proof.');
  1625.     const meta = BlockMeta.fromEntry(entry);
  1627.     if (!await this.wdb.addTX(tx, meta))
  1628.       throw new RPCError(errs.WALLET_ERROR,
  1629.         'Address for TX not in wallet, or TX already in wallet');
  1631.     return null;
  1632.   }
  1634.   async removePrunedFunds(args, help) {
  1635.     if (help || args.length !== 1)
  1636.       throw new RPCError(errs.MISC_ERROR, 'removeprunedfunds "txid"');
  1638.     const wallet = this.wallet;
  1639.     const valid = new Validator(args);
  1640.     const hash = valid.brhash(0);
  1642.     if (!hash)
  1643.       throw new RPCError(errs.TYPE_ERROR, 'Invalid parameter.');
  1645.     if (!await wallet.remove(hash))
  1646.       throw new RPCError(errs.WALLET_ERROR, 'Transaction not in wallet.');
  1648.     return null;
  1649.   }
  1651.   async selectWallet(args, help) {
  1652.     const valid = new Validator(args);
  1653.     const id = valid.str(0);
  1655.     if (help || args.length !== 1)
  1656.       throw new RPCError(errs.MISC_ERROR, 'selectwallet "id"');
  1658.     const wallet = await this.wdb.get(id);
  1660.     if (!wallet)
  1661.       throw new RPCError(errs.WALLET_ERROR, 'Wallet not found.');
  1663.     this.wallet = wallet;
  1665.     return null;
  1666.   }
  1668.   async getMemoryInfo(args, help) {
  1669.     if (help || args.length !== 0)
  1670.       throw new RPCError(errs.MISC_ERROR, 'getmemoryinfo');
  1672.     return this.logger.memoryUsage();
  1673.   }
  1675.   async setLogLevel(args, help) {
  1676.     if (help || args.length !== 1)
  1677.       throw new RPCError(errs.MISC_ERROR, 'setloglevel "level"');
  1679.     const valid = new Validator(args);
  1680.     const level = valid.str(0, '');
  1682.     this.logger.setLevel(level);
  1684.     return null;
  1685.   }
  1686. }
  1688. /*
  1689.  * Helpers
  1690.  */
  1692. function parseHash(raw, network) {
  1693.   const addr = parseAddress(raw, network);
  1694.   return addr.getHash();
  1695. }
  1697. function parseAddress(raw, network) {
  1698.   try {
  1699.     return Address.fromString(raw, network);
  1700.   } catch (e) {
  1701.     throw new RPCError(errs.INVALID_ADDRESS_OR_KEY, 'Invalid address.');
  1702.   }
  1703. }
  1705. function parseSecret(raw, network) {
  1706.   try {
  1707.     return KeyRing.fromSecret(raw, network);
  1708.   } catch (e) {
  1709.     throw new RPCError(errs.INVALID_ADDRESS_OR_KEY, 'Invalid key.');
  1710.   }
  1711. }
  1713. /*
  1714.  * Expose
  1715.  */
  1717. module.exports = RPC;