11895505322

Committed 18 Nov 2024 03:21PM UTC coverage: 71.265% (+1.2%) from 70.033%

Build # 11895505322

Build Type

Pull #888

github

Committed by

web-flow

Commit Message

Merge a914b01ee into 1b331eedb

Pull Request Pull Request #888: Wallet TX Count and time indexing

Run Details

8052 of 13150 branches covered (61.23%)

Branch coverage included in aggregate %.

826 of 885 new or added lines in 16 files covered. (93.33%)

2063 existing lines in 60 files now uncovered.

25720 of 34239 relevant lines covered (75.12%)

34512.26 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.08

/lib/wallet/txdb.js

/*!
 * txdb.js - persistent transaction pool
 * Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
 * https://github.com/handshake-org/hsd
 */

'use strict';

const assert = require('bsert');
const bio = require('bufio');
const {BufferSet} = require('buffer-map');
const util = require('../utils/util');
const Amount = require('../ui/amount');
const CoinView = require('../coins/coinview');
const Coin = require('../primitives/coin');
const Outpoint = require('../primitives/outpoint');
const layouts = require('./layout');
const layout = layouts.txdb;
const consensus = require('../protocol/consensus');
const policy = require('../protocol/policy');
const rules = require('../covenants/rules');
const NameState = require('../covenants/namestate');
const NameUndo = require('../covenants/undo');
const {TXRecord} = require('./records');
const {types} = rules;

/** @typedef {import('./records').BlockMeta} BlockMeta */
/** @typedef {import('./walletdb')} WalletDB */

/**
 * @typedef {Object} BlockExtraInfo
 * @property {Number} medianTime
 * @property {Number} txIndex
 */

/*
 * Constants
 */

const EMPTY = Buffer.alloc(0);
const UNCONFIRMED_HEIGHT = 0xffffffff;

/**
 * TXDB
 * @alias module:wallet.TXDB
 */

class TXDB {
  /** @type {WalletDB} */
  wdb;

  /**
   * Create a TXDB.
   * @constructor
   * @param {WalletDB} wdb
   */

  constructor(wdb, wid) {
    this.wdb = wdb;
    this.db = wdb.db;
    this.logger = wdb.logger;
    this.nowFn = wdb.options.nowFn || util.now;
    this.maxTXs = wdb.options.maxHistoryTXs || 100;

    this.wid = wid || 0;
    this.bucket = null;
    this.wallet = null;
    this.locked = new BufferSet();
  }

  /**
   * Open TXDB.
   * @returns {Promise}
   */

  async open(wallet) {
    const prefix = layout.prefix.encode(wallet.wid);

    this.wid = wallet.wid;
    this.bucket = this.db.bucket(prefix);
    this.wallet = wallet;
  }

  /**
   * Emit transaction event.
   * @private
   * @param {String} event
   * @param {Object} data
   * @param {Details} details
   */

  emit(event, data, details) {
    this.wdb.emit(event, this.wallet, data, details);
    this.wallet.emit(event, data, details);
  }

  /**
   * Get wallet path for output.
   * @param {Output} output
   * @returns {Promise<Path?>}
   */

  getPath(output) {
    const hash = output.getHash();

    if (!hash)
      return null;

    return this.wdb.getPath(this.wid, hash);
  }

  /**
   * Test whether path exists for output.
   * @param {Output} output
   * @returns {Promise<Boolean>}
   */

  hasPath(output) {
    const hash = output.getHash();

    if (!hash)
      return false;

    return this.wdb.hasPath(this.wid, hash);
  }

  /**
   * Save credit.
   * @param {Credit} credit
   * @param {Path} path
   */

  async saveCredit(b, credit, path) {
    const {coin} = credit;

    b.put(layout.c.encode(coin.hash, coin.index), credit.encode());
    b.put(layout.C.encode(path.account, coin.hash, coin.index), null);

    return this.addOutpointMap(b, coin.hash, coin.index);
  }

  /**
   * Remove credit.
   * @param {Credit} credit
   * @param {Path} path
   */

  async removeCredit(b, credit, path) {
    const {coin} = credit;

    b.del(layout.c.encode(coin.hash, coin.index));
    b.del(layout.C.encode(path.account, coin.hash, coin.index));

    return this.removeOutpointMap(b, coin.hash, coin.index);
  }

  /**
   * Spend credit.
   * @param {Credit} credit
   * @param {TX} tx
   * @param {Number} index
   */

  spendCredit(b, credit, tx, index) {
    const prevout = tx.inputs[index].prevout;
    const spender = Outpoint.fromTX(tx, index);
    b.put(layout.s.encode(prevout.hash, prevout.index), spender.encode());
    b.put(layout.d.encode(spender.hash, spender.index), credit.coin.encode());
  }

  /**
   * Unspend credit.
   * @param {TX} tx
   * @param {Number} index
   */

  unspendCredit(b, tx, index) {
    const prevout = tx.inputs[index].prevout;
    const spender = Outpoint.fromTX(tx, index);
    b.del(layout.s.encode(prevout.hash, prevout.index));
    b.del(layout.d.encode(spender.hash, spender.index));
  }

  /**
   * Spend credit by spender/input record.
   * Add undo coin to the input record.
   * @param {Credit} credit
   * @param {Outpoint} spender
   */

  addUndoToInput(b, credit, spender) {
    b.put(layout.d.encode(spender.hash, spender.index), credit.coin.encode());
  }

  /**
   * Write input record.
   * @param {TX} tx
   * @param {Number} index
   */

  async writeInput(b, tx, index) {
    const prevout = tx.inputs[index].prevout;
    const spender = Outpoint.fromTX(tx, index);
    b.put(layout.s.encode(prevout.hash, prevout.index), spender.encode());
    return this.addOutpointMap(b, prevout.hash, prevout.index);
  }

  /**
   * Remove input record.
   * @param {TX} tx
   * @param {Number} index
   */

  async removeInput(b, tx, index) {
    const prevout = tx.inputs[index].prevout;
    b.del(layout.s.encode(prevout.hash, prevout.index));
    return this.removeOutpointMap(b, prevout.hash, prevout.index);
  }

  /**
   * Update wallet balance.
   * @param {BalanceDelta} state
   */

  async updateBalance(b, state) {
    const balance = await this.getWalletBalance();
    state.applyTo(balance);
    b.put(layout.R.encode(), balance.encode());
    return balance;
  }

  /**
   * Update account balance.
   * @param {Batch} b
   * @param {Number} acct
   * @param {BalanceDelta} delta
   */

  async updateAccountBalance(b, acct, delta) {
    const balance = await this.getAccountBalance(acct);
    delta.applyTo(balance);
    b.put(layout.r.encode(acct), balance.encode());
    return balance;
  }

  /**
   * Test a whether a coin has been spent.
   * @param {Hash} hash
   * @param {Number} index
   * @returns {Promise<Outpoint?>}
   */

  async getSpent(hash, index) {
    const data = await this.bucket.get(layout.s.encode(hash, index));

    if (!data)
      return null;

    return Outpoint.decode(data);
  }

  /**
   * Test a whether a coin has been spent.
   * @param {Hash} hash
   * @param {Number} index
   * @returns {Promise<Boolean>}
   */

  isSpent(hash, index) {
    return this.bucket.has(layout.s.encode(hash, index));
  }

  /**
   * Append to global map.
   * @param {Number} height
   * @returns {Promise}
   */

  addBlockMap(b, height) {
    return this.wdb.addBlockMap(b.root(), height, this.wid);
  }

  /**
   * Remove from global map.
   * @param {Number} height
   * @returns {Promise}
   */

  removeBlockMap(b, height) {
    return this.wdb.removeBlockMap(b.root(), height, this.wid);
  }

  /**
   * Append to global map.
   * @param {Hash} hash
   * @returns {Promise}
   */

  addTXMap(b, hash) {
    return this.wdb.addTXMap(b.root(), hash, this.wid);
  }

  /**
   * Remove from global map.
   * @param {Hash} hash
   * @returns {Promise}
   */

  removeTXMap(b, hash) {
    return this.wdb.removeTXMap(b.root(), hash, this.wid);
  }

  /**
   * Append to global map.
   * @param {Hash} hash
   * @param {Number} index
   * @returns {Promise}
   */

  addOutpointMap(b, hash, index) {
    return this.wdb.addOutpointMap(b.root(), hash, index, this.wid);
  }

  /**
   * Remove from global map.
   * @param {Hash} hash
   * @param {Number} index
   * @returns {Promise}
   */

  removeOutpointMap(b, hash, index) {
    return this.wdb.removeOutpointMap(b.root(), hash, index, this.wid);
  }

  /**
   * Append to global map.
   * @param {Hash} hash
   * @param {Number} index
   * @returns {Promise}
   */

  addNameMap(b, nameHash) {
    return this.wdb.addNameMap(b.root(), nameHash, this.wid);
  }

  /**
   * Remove from global map.
   * @param {Hash} hash
   * @param {Number} index
   * @returns {Promise}
   */

  removeNameMap(b, nameHash) {
    return this.wdb.removeNameMap(b.root(), nameHash, this.wid);
  }

  /**
   * List block records.
   * @returns {Promise<BlockRecord[]>}
   */

  getBlocks() {
    return this.bucket.keys({
      gte: layout.b.min(),
      lte: layout.b.max(),
      parse: key => layout.b.decode(key)[0]
    });
  }

  /**
   * Get block record.
   * @param {Number} height
   * @returns {Promise<BlockRecord?>}
   */

  async getBlock(height) {
    const data = await this.bucket.get(layout.b.encode(height));

    if (!data)
      return null;

    return BlockRecord.decode(data);
  }

  /**
   * Get block hashes size.
   * @param {Number} height
   * @returns {Promise<Number>}
   */

  async getBlockTXsSize(height) {
    const data = await this.bucket.get(layout.b.encode(height));

    if (!data)
      return 0;

    return data.readUInt32LE(40, true);
  }

  /**
   * Append to the global block record.
   * @param {Batch} b
   * @param {Hash} hash - transaction hash.
   * @param {BlockMeta} block
   * @returns {Promise}
   */

  async addBlock(b, hash, block) {
    const key = layout.b.encode(block.height);
    const data = await this.bucket.get(key);

    if (!data) {
      const blk = BlockRecord.fromMeta(block);
      blk.add(hash);
      b.put(key, blk.encode());
      return;
    }

    const raw = Buffer.allocUnsafe(data.length + 32);
    data.copy(raw, 0);

    const size = raw.readUInt32LE(40, true);
    raw.writeUInt32LE(size + 1, 40, true);
    hash.copy(raw, data.length);

    b.put(key, raw);
  }

  /**
   * Remove from the global block record.
   * @param {Hash} hash
   * @param {Number} height
   * @returns {Promise}
   */

  async removeBlock(b, hash, height) {
    const key = layout.b.encode(height);
    const data = await this.bucket.get(key);

    if (!data)
      return;

    const size = data.readUInt32LE(40, true);

    assert(size > 0);
    assert(data.slice(-32).equals(hash));

    if (size === 1) {
      b.del(key);
      return;
    }

    const raw = data.slice(0, -32);
    raw.writeUInt32LE(size - 1, 40, true);

    b.put(key, raw);
  }

  /**
   * Remove from the global block record.
   * @param {Hash} hash
   * @param {Number} height
   * @returns {Promise}
   */

  async spliceBlock(b, hash, height) {
    const block = await this.getBlock(height);

    if (!block)
      return;

    if (!block.remove(hash))
      return;

    if (block.hashes.size === 0) {
      b.del(layout.b.encode(height));
      return;
    }

    b.put(layout.b.encode(height), block.encode());
  }

  /**
   * Test whether we have a name.
   * @param {Buffer} nameHash
   * @returns {Promise<Boolean>}
   */

  async hasNameState(nameHash) {
    return this.bucket.has(layout.A.encode(nameHash));
  }

  /**
   * Get a name state if present.
   * @param {Buffer} nameHash
   * @returns {Promise<NameState?>}
   */

  async getNameState(nameHash) {
    const raw = await this.bucket.get(layout.A.encode(nameHash));

    if (!raw)
      return null;

    const ns = NameState.decode(raw);
    ns.nameHash = nameHash;

    return ns;
  }

  /**
   * Get all names.
   * @returns {Promise<NameState[]>}
   */

  async getNames() {
    const iter = this.bucket.iterator({
      gte: layout.A.min(),
      lte: layout.A.max(),
      values: true
    });

    const names = [];

    await iter.each((key, raw) => {
      const [nameHash] = layout.A.decode(key);
      const ns = NameState.decode(raw);
      ns.nameHash = nameHash;
      names.push(ns);
    });

    return names;
  }

  /**
   * Test whether we have a bid.
   * @param {Buffer} nameHash
   * @param {Outpoint} outpoint
   * @returns {Promise<Boolean>}
   */

  async hasBid(nameHash, outpoint) {
    const {hash, index} = outpoint;
    return this.bucket.has(layout.i.encode(nameHash, hash, index));
  }

  /**
   * Get a bid if present.
   * @param {Buffer} nameHash
   * @param {Outpoint} outpoint
   * @returns {Promise<BlindBid?>}
   */

  async getBid(nameHash, outpoint) {
    const {hash, index} = outpoint;
    const raw = await this.bucket.get(layout.i.encode(nameHash, hash, index));

    if (!raw)
      return null;

    const bb = BlindBid.decode(raw);
    bb.nameHash = nameHash;
    bb.prevout = outpoint;

    return bb;
  }

  /**
   * Write a bid.
   * @param {Object} b
   * @param {Buffer} nameHash
   * @param {Outpoint} outpoint
   * @param {Object} options
   */

  putBid(b, nameHash, outpoint, options) {
    const {hash, index} = outpoint;
    const bb = new BlindBid();
    bb.nameHash = nameHash;
    bb.name = options.name;
    bb.lockup = options.lockup;
    bb.blind = options.blind;
    bb.own = options.own;
    bb.height = options.height;
    b.put(layout.i.encode(nameHash, hash, index), bb.encode());
  }

  /**
   * Delete a bid.
   * @param {Object} b
   * @param {Buffer} nameHash
   * @param {Outpoint} outpoint
   */

  removeBid(b, nameHash, outpoint) {
    const {hash, index} = outpoint;
    b.del(layout.i.encode(nameHash, hash, index));
  }

  /**
   * Get all bids for name.
   * @param {Buffer} nameHash
   * @returns {Promise<BlindBid[]>}
   */

  async getBids(nameHash) {
    const iter = this.bucket.iterator({
      gte: nameHash ? layout.i.min(nameHash) : layout.i.min(),
      lte: nameHash ? layout.i.max(nameHash) : layout.i.max(),
      values: true
    });

    const bids = [];

    await iter.each(async (key, raw) => {
      const [nameHash, hash, index] = layout.i.decode(key);
      const bb = BlindBid.decode(raw);

      bb.nameHash = nameHash;
      bb.prevout = new Outpoint(hash, index);

      const bv = await this.getBlind(bb.blind);

      if (bv)
        bb.value = bv.value;

      bids.push(bb);
    });

    return bids;
  }

  /**
   * Remove all bids for name.
   * @param {Buffer} nameHash
   * @returns {Promise}
   */

  async removeBids(b, nameHash) {
    const iter = this.bucket.iterator({
      gte: layout.i.min(nameHash),
      lte: layout.i.max(nameHash)
    });

    await iter.each(k => b.del(k));
  }

  /**
   * Test whether we have a reveal.
   * @param {Buffer} nameHash
   * @param {Outpoint} outpoint
   * @returns {Promise<Boolean>}
   */

  async hasReveal(nameHash, outpoint) {
    const {hash, index} = outpoint;
    return this.bucket.has(layout.B.encode(nameHash, hash, index));
  }

  /**
   * Get a reveal if present.
   * @param {Buffer} nameHash
   * @param {Outpoint} outpoint
   * @returns {Promise<BidReveal?>}
   */

  async getReveal(nameHash, outpoint) {
    const {hash, index} = outpoint;
    const raw = await this.bucket.get(layout.B.encode(nameHash, hash, index));

    if (!raw)
      return null;

    const brv = BidReveal.decode(raw);
    brv.nameHash = nameHash;
    brv.prevout = outpoint;

    return brv;
  }

  /**
   * Get reveal by bid outpoint.
   * @param {Buffer} nameHash
   * @param {Outpoint} bidOut
   * @returns {Promise<BidReveal?>}
   */

  async getRevealByBid(nameHash, bidOut) {
    const rawOutpoint = await this.bucket.get(
      layout.E.encode(nameHash, bidOut.hash, bidOut.index));

    if (!rawOutpoint)
      return null;

    const outpoint = Outpoint.decode(rawOutpoint);
    return this.getReveal(nameHash, outpoint);
  }

  /**
   * Get bid by reveal outpoint.
   * @param {Buffer} nameHash
   * @param {Outpoint} revealOut
   * @returns {Promise<BlindBid?>}
   */

  async getBidByReveal(nameHash, revealOut) {
    const reveal = await this.getReveal(nameHash, revealOut);

    if (!reveal)
      return null;

    return this.getBid(nameHash, reveal.bidPrevout);
  }

  /**
   * Write a reveal.
   * @param {Object} b
   * @param {Buffer} nameHash
   * @param {Outpoint} outpoint
   * @param {Object} options
   * @param {String} options.name
   * @param {Amount} options.value
   * @param {Number} options.height
   * @param {Boolean} options.own
   * @param {Outpoint} options.bidPrevout
   * @returns {void}
   */

  putReveal(b, nameHash, outpoint, options) {
    const {hash, index} = outpoint;
    const {bidPrevout} = options;
    const brv = new BidReveal();
    brv.nameHash = nameHash;
    brv.name = options.name;
    brv.value = options.value;
    brv.height = options.height;
    brv.own = options.own;
    brv.bidPrevout = bidPrevout;
    b.put(layout.B.encode(nameHash, hash, index), brv.encode());
    b.put(layout.E.encode(nameHash, bidPrevout.hash, bidPrevout.index),
      outpoint.encode());
  }

  /**
   * Delete a reveal.
   * @param {Object} b
   * @param {Buffer} nameHash
   * @param {Outpoint} outpoint
   * @param {Outpoint} bidPrevout
   */

  removeReveal(b, nameHash, outpoint, bidPrevout) {
    const {hash, index} = outpoint;
    b.del(layout.B.encode(nameHash, hash, index));
    b.del(layout.E.encode(nameHash, bidPrevout.hash, bidPrevout.index));
  }

  /**
   * Get all reveals by name.
   * @param {Buffer} nameHash
   * @returns {Promise<BidReveal[]>}
   */

  async getReveals(nameHash) {
    const iter = this.bucket.iterator({
      gte: nameHash ? layout.B.min(nameHash) : layout.B.min(),
      lte: nameHash ? layout.B.max(nameHash) : layout.B.max(),
      values: true
    });

    const reveals = [];

    await iter.each(async (key, raw) => {
      const [nameHash, hash, index] = layout.B.decode(key);
      const brv = BidReveal.decode(raw);
      brv.nameHash = nameHash;
      brv.prevout = new Outpoint(hash, index);
      reveals.push(brv);
    });

    return reveals;
  }

  /**
   * Remove all reveals by name.
   * @param {Object} b
   * @param {Buffer} nameHash
   * @returns {Promise}
   */

  async removeReveals(b, nameHash) {
    const iter = this.bucket.iterator({
      gte: layout.B.min(nameHash),
      lte: layout.B.max(nameHash)
    });

    await iter.each(k => b.del(k));
  }

  /**
   * Test whether a blind value is present.
   * @param {Buffer} blind - Blind hash.
   * @returns {Promise<Boolean>}
   */

  async hasBlind(blind) {
    return this.bucket.has(layout.v.encode(blind));
  }

  /**
   * Get a blind value if present.
   * @param {Buffer} blind - Blind hash.
   * @returns {Promise<BlindValue?>}
   */

  async getBlind(blind) {
    const raw = await this.bucket.get(layout.v.encode(blind));

    if (!raw)
      return null;

    return BlindValue.decode(raw);
  }

  /**
   * Write a blind value.
   * @param {Object} b
   * @param {Buffer} blind
   * @param {Object} options
   */

  putBlind(b, blind, options) {
    const {value, nonce} = options;
    const bv = new BlindValue();
    bv.value = value;
    bv.nonce = nonce;
    b.put(layout.v.encode(blind), bv.encode());
  }

  /**
   * Save blind value.
   * @param {Buffer} blind
   * @param {Object} options
   * @returns {Promise}
   */

  async saveBlind(blind, options) {
    const b = this.bucket.batch();
    this.putBlind(b, blind, options);
    await b.write();
  }

  /**
   * Delete a blind value.
   * @param {Object} b
   * @param {Buffer} blind
   */

  removeBlind(b, blind) {
    b.del(layout.v.encode(blind));
  }

  /**
   * Add transaction without a batch.
   * @param {TX} tx
   * @param {BlockMeta} [block]
   * @param {BlockExtraInfo} [extra]
   * @returns {Promise<Details?>}
   */

  async add(tx, block, extra) {
    const hash = tx.hash();
    const existing = await this.getTX(hash);

    assert(!tx.mutable, 'Cannot add mutable TX to wallet.');

    if (existing) {
      // Existing tx is already confirmed. Ignore.
      if (existing.height !== -1)
        return null;

      // The incoming tx won't confirm the
      // existing one anyway. Ignore.
      if (!block)
        return null;

      // Get txIndex of the wallet.
      extra.txIndex = await this.getBlockTXsSize(block.height);

      // Confirm transaction.
      return this.confirm(existing, block, extra);
    }

    const now = this.nowFn();
    const wtx = TXRecord.fromTX(tx, block, now);

    if (!block) {
      // Potentially remove double-spenders.
      // Only remove if they're not confirmed.
      if (!await this.removeConflicts(tx, true))
        return null;
      if (await this.isDoubleOpen(tx))
        return null;
    } else {
      // Potentially remove double-spenders.
      await this.removeConflicts(tx, false);
      await this.removeDoubleOpen(tx);
    }

    if (block)
      extra.txIndex = await this.getBlockTXsSize(block.height);

    // Finally we can do a regular insertion.
    return this.insert(wtx, block, extra);
  }

  /**
   * Test whether the transaction
   * has a duplicate open.
   * @param {TX}
   * @returns {Promise<Boolean>}
   */

  async isDoubleOpen(tx) {
    for (const {covenant} of tx.outputs) {
      if (!covenant.isOpen())
        continue;

      const nameHash = covenant.getHash(0);
      const key = layout.o.encode(nameHash);
      const hash = await this.bucket.get(key);

      // Allow a double open if previous auction period has expired
      // this is not a complete check for name availability or status!
      if (hash) {
        const names = this.wdb.network.names;
        const period = names.biddingPeriod + names.revealPeriod;
        const oldTX = await this.getTX(hash);
        if (oldTX.height !== -1 && oldTX.height + period < this.wdb.height)
          return false;

        return true;
      }
    }

    return false;
  }

  /**
   * Remove duplicate opens.
   * @private
   * @param {TX} tx
   * @returns {Promise}
   */

  async removeDoubleOpen(tx) {
    for (const {covenant} of tx.outputs) {
      if (!covenant.isOpen())
        continue;

      const nameHash = covenant.getHash(0);
      const key = layout.o.encode(nameHash);
      const hash = await this.bucket.get(key);

      if (!hash)
        continue;

      const wtx = await this.getTX(hash);

      if (wtx.height !== -1)
        return;

      await this.remove(hash);
    }
  }

  /**
   * Index open covenants.
   * @private
   * @param {Batch} b
   * @param {TX} tx
   */

  indexOpens(b, tx) {
    for (const {covenant} of tx.outputs) {
      if (!covenant.isOpen())
        continue;

      const nameHash = covenant.getHash(0);
      const key = layout.o.encode(nameHash);

      b.put(key, tx.hash());
    }
  }

  /**
   * Unindex open covenants.
   * @private
   * @param {Batch} b
   * @param {TX} tx
   */

  unindexOpens(b, tx) {
    for (const {covenant} of tx.outputs) {
      if (!covenant.isOpen())
        continue;

      const nameHash = covenant.getHash(0);
      const key = layout.o.encode(nameHash);

      b.del(key);
    }
  }

  /**
   * Insert transaction.
   * @private
   * @param {TXRecord} wtx
   * @param {BlockMeta} [block]
   * @param {BlockExtraInfo} [extra]
   * @returns {Promise<Details>}
   */

  async insert(wtx, block, extra) {
    const b = this.bucket.batch();
    const {tx, hash} = wtx;
    const height = block ? block.height : -1;
    const details = new Details(wtx, block);
    const state = new BalanceDelta();
    const view = new CoinView();

    let own = false;

    if (!tx.isCoinbase()) {
      // We need to potentially spend some coins here.
      for (let i = 0; i < tx.inputs.length; i++) {
        const input = tx.inputs[i];
        const {hash, index} = input.prevout;
        const credit = await this.getCredit(hash, index);

        if (!credit) {
          // Watch all inputs for incoming txs.
          // This allows us to check for double spends.
          if (!block)
            await this.writeInput(b, tx, i);
          continue;
        }

        const coin = credit.coin;
        const path = await this.getPath(coin);
        assert(path);

        // Build the tx details object
        // as we go, for speed.
        details.setInput(i, path, coin);

        // Write an undo coin for the credit
        // and add it to the stxo set.
        this.spendCredit(b, credit, tx, i);

        // Unconfirmed balance should always
        // be updated as it reflects the on-chain
        // balance _and_ mempool balance assuming
        // everything in the mempool were to confirm.
        state.tx(path, 1);
        state.coin(path, -1);
        state.unconfirmed(path, -coin.value);
        this.unlockBalances(state, credit, path, -1);

        if (!block) {
          // If the tx is not mined, we do not
          // disconnect the coin, we simply mark
          // a `spent` flag on the credit. This
          // effectively prevents the mempool
          // from altering our utxo state
          // permanently. It also makes it
          // possible to compare the on-chain
          // state vs. the mempool state.
          credit.spent = true;
          await this.saveCredit(b, credit, path);
        } else {
          // If the tx is mined, we can safely
          // remove the coin being spent. This
          // coin will be indexed as an undo
          // coin so it can be reconnected
          // later during a reorg.
          state.confirmed(path, -coin.value);
          this.unlockBalances(state, credit, path, height);

          await this.removeCredit(b, credit, path);

          view.addCoin(coin);
        }

        own = true;
      }
    }

    // Potentially add coins to the utxo set.
    for (let i = 0; i < tx.outputs.length; i++) {
      const output = tx.outputs[i];
      const path = await this.getPath(output);

      if (!path)
        continue;

      details.setOutput(i, path);

      const credit = Credit.fromTX(tx, i, height);
      credit.own = own;

      state.tx(path, 1);
      state.coin(path, 1);
      state.unconfirmed(path, output.value);
      this.lockBalances(state, credit, path, -1);

      if (block) {
        state.confirmed(path, output.value);
        this.lockBalances(state, credit, path, height);
      }

      const spender = await this.getSpent(hash, i);

      if (spender) {
        credit.spent = true;
        this.addUndoToInput(b, credit, spender);

        // TODO: emit 'missed credit'
        state.coin(path, -1);
        state.unconfirmed(path, -output.value);
        this.unlockBalances(state, credit, path, -1);
      }

      await this.saveCredit(b, credit, path);
      await this.watchOpensEarly(b, output);
    }

    // Handle names.
    if (block && !await this.bucket.has(layout.U.encode(hash))) {
      const updated = await this.connectNames(b, tx, view, height);

      if (updated && !state.updated()) {
        // Always save namestate transitions,
        // even if they don't affect wallet balance
        await this.addBlockMap(b, height);
        await this.addBlock(b, tx.hash(), block);
        await b.write();
      }
    }

    // If this didn't update any coins,
    // it's not our transaction.
    if (!state.updated())
      return null;

    // Index open covenants.
    if (!block)
      this.indexOpens(b, tx);

    // Save and index the transaction record.
    b.put(layout.t.encode(hash), wtx.encode());

    if (!block)
      b.put(layout.p.encode(hash), null);
    else
      b.put(layout.h.encode(height, hash), null);

    // Do some secondary indexing for account-based
    // queries. This saves us a lot of time for
    // queries later.
    for (const [acct, delta] of state.accounts) {
      await this.updateAccountBalance(b, acct, delta);

      b.put(layout.T.encode(acct, hash), null);

      if (!block)
        b.put(layout.P.encode(acct, hash), null);
      else
        b.put(layout.H.encode(acct, height, hash), null);
    }

    // Update block records.
    if (block) {
      // If confirmed in a block (e.g. coinbase tx) and not
      // being updated or previously seen, we need to add
      // the monotonic time and count index for the transaction
      await this.addCountAndTimeIndex(b, {
        accounts: state.accounts,
        hash,
        height: block.height,
        blockextra: extra
      });

      // In the event that this transaction becomes unconfirmed
      // during a reorganization, this transaction will need an
      // unconfirmed time and unconfirmed index, however since this
      // transaction was not previously seen previous to the block,
      // we need to add that information.
      // TODO: This can be skipped if TX is coinbase, but even now
      // it will be properly cleaned up on erase.
      await this.addCountAndTimeIndexUnconfirmedUndo(b, hash, wtx.mtime);

      await this.addBlockMap(b, height);
      await this.addBlock(b, tx.hash(), block);
    } else {
      // Add indexing for unconfirmed transactions.
      await this.addCountAndTimeIndexUnconfirmed(b, state.accounts, hash,
        wtx.mtime);

      await this.addTXMap(b, hash);
    }

    // Commit the new state.
    const balance = await this.updateBalance(b, state);

    await b.write();

    // This transaction may unlock some
    // coins now that we've seen it.
    this.unlockTX(tx);

    // Emit events for potential local and
    // websocket listeners. Note that these
    // will only be emitted if the batch is
    // successfully written to disk.
    this.emit('tx', tx, details);
    this.emit('balance', balance);

    return details;
  }

  /**
   * Attempt to confirm a transaction.
   * @private
   * @param {TXRecord} wtx
   * @param {BlockMeta} block
   * @param {BlockExtraInfo} extra
   * @returns {Promise<Details>}
   */

  async confirm(wtx, block, extra) {
    const b = this.bucket.batch();
    const {tx, hash} = wtx;
    const height = block.height;
    const details = new Details(wtx, block);
    const state = new BalanceDelta();
    const view = new CoinView();
    let own = false;

    assert(block && extra);
    wtx.setBlock(block);

    if (!tx.isCoinbase()) {
      const credits = await this.getSpentCredits(tx);

      // Potentially spend coins. Now that the tx
      // is mined, we can actually _remove_ coins
      // from the utxo state.
      for (let i = 0; i < tx.inputs.length; i++) {
        const input = tx.inputs[i];
        const {hash, index} = input.prevout;

        let resolved = false;

        // There may be new credits available
        // that we haven't seen yet.
        if (!credits[i]) {
          await this.removeInput(b, tx, i);

          // NOTE: This check has been moved to the outputs
          // processing in insert(pending), insert(block) and confirm.
          // But will still be here just in case.
          const credit = await this.getCredit(hash, index);

          if (!credit)
            continue;

          // Add a spend record and undo coin
          // for the coin we now know is ours.
          // We don't need to remove the coin
          // since it was never added in the
          // first place.
          this.spendCredit(b, credit, tx, i);

          credits[i] = credit;
          resolved = true;
        }

        const credit = credits[i];
        const coin = credit.coin;

        assert(coin.height !== -1);

        const path = await this.getPath(coin);
        assert(path);
        own = true;

        details.setInput(i, path, coin);

        if (resolved) {
          state.coin(path, -1);
          state.unconfirmed(path, -coin.value);
          this.unlockBalances(state, credit, path, -1);
        }

        state.confirmed(path, -coin.value);
        this.unlockBalances(state, credit, path, height);

        // We can now safely remove the credit
        // entirely, now that we know it's also
        // been removed on-chain.
        await this.removeCredit(b, credit, path);

        view.addCoin(coin);
      }
    }

    // Update credit heights, including undo coins.
    for (let i = 0; i < tx.outputs.length; i++) {
      const output = tx.outputs[i];
      const path = await this.getPath(output);

      if (!path)
        continue;

      details.setOutput(i, path);

      let credit = await this.getCredit(hash, i);

      if (!credit) {
        // TODO: Emit 'missed credit' event.

        // This credit didn't belong to us the first time we
        // saw the transaction (before confirmation or rescan).
        // Create new credit for database.
        credit = Credit.fromTX(tx, i, height);

        // If this tx spent any of our own coins, we "own" this output,
        // meaning if it becomes unconfirmed, we can still confidently spend it.
        credit.own = own;

        const spender = await this.getSpent(hash, i);

        if (spender) {
          credit.spent = true;
          this.addUndoToInput(b, credit, spender);
        } else {
          // Add coin to "unconfirmed" balance (which includes confirmed coins)
          state.coin(path, 1);
          state.unconfirmed(path, credit.coin.value);
          this.lockBalances(state, credit, path, -1);
        }
      }

      // Credits spent in the mempool add an
      // undo coin for ease. If this credit is
      // spent in the mempool, we need to
      // update the undo coin's height.
      if (credit.spent)
        await this.updateSpentCoin(b, tx, i, height);

      // Update coin height and confirmed
      // balance. Save once again.
      state.confirmed(path, output.value);
      this.lockBalances(state, credit, path, height);

      credit.coin.height = height;

      await this.saveCredit(b, credit, path);
    }

    // Handle names.
    await this.connectNames(b, tx, view, height);

    // Disconnect unconfirmed time index for the transaction.
    // This must go before adding the the indexes, as the
    // unconfirmed count needs to be copied first.
    await this.disconnectCountAndTimeIndexUnconfirmed(b, state.accounts, hash);

    // Add monotonic and count time index for transactions
    // that already exist in the database and are now
    // being confirmed.
    await this.addCountAndTimeIndex(b, {
      accounts: state.accounts,
      hash,
      height: block.height,
      blockextra: extra
    });

    // Save the new serialized transaction as
    // the block-related properties have been
    // updated. Also reindex for height.
    b.put(layout.t.encode(hash), wtx.encode());
    b.del(layout.p.encode(hash));
    b.put(layout.h.encode(height, hash), null);

    // Secondary indexing also needs to change.
    for (const [acct, delta] of state.accounts) {
      await this.updateAccountBalance(b, acct, delta);
      b.del(layout.P.encode(acct, hash));
      b.put(layout.H.encode(acct, height, hash), null);
    }

    await this.removeTXMap(b, hash);
    await this.addBlockMap(b, height);
    await this.addBlock(b, tx.hash(), block);

    // Commit the new state. The balance has updated.
    const balance = await this.updateBalance(b, state);

    this.unindexOpens(b, tx);

    await b.write();

    this.unlockTX(tx);

    this.emit('confirmed', tx, details);
    this.emit('balance', balance);

    return details;
  }

  /**
   * Recursively remove a transaction
   * from the database.
   * @param {Hash} hash
   * @returns {Promise<Details?>}
   */

  async remove(hash) {
    const wtx = await this.getTX(hash);

    if (!wtx)
      return null;

    return this.removeRecursive(wtx);
  }

  /**
   * Remove a transaction from the
   * database. Disconnect inputs.
   * @private
   * @param {TXRecord} wtx
   * @param {BlockMeta} [block]
   * @param {Number} [medianTime]
   * @returns {Promise<Details>}
   */

  async erase(wtx, block, medianTime) {
    const b = this.bucket.batch();
    const {tx, hash} = wtx;
    const height = block ? block.height : -1;
    const details = new Details(wtx, block);
    const state = new BalanceDelta();

    if (!tx.isCoinbase()) {
      // We need to undo every part of the
      // state this transaction ever touched.
      // Start by getting the undo coins.
      const credits = await this.getSpentCredits(tx);

      for (let i = 0; i < tx.inputs.length; i++) {
        const credit = credits[i];

        if (!credit) {
          if (!block)
            await this.removeInput(b, tx, i);
          continue;
        }

        const coin = credit.coin;
        const path = await this.getPath(coin);
        assert(path);

        details.setInput(i, path, coin);

        // Recalculate the balance, remove
        // from stxo set, remove the undo
        // coin, and resave the credit.
        state.tx(path, -1);
        state.coin(path, 1);
        state.unconfirmed(path, coin.value);
        this.lockBalances(state, credit, path, -1);

        if (block) {
          state.confirmed(path, coin.value);
          this.lockBalances(state, credit, path, height);
        }

        this.unspendCredit(b, tx, i);

        credit.spent = false;
        await this.saveCredit(b, credit, path);
      }
    }

    // We need to remove all credits
    // this transaction created.
    for (let i = 0; i < tx.outputs.length; i++) {
      const output = tx.outputs[i];
      const path = await this.getPath(output);

      if (!path)
        continue;

      const credit = await this.getCredit(hash, i);

      // If we don't have credit for the output, then we don't need
      // to do anything, because they were getting erased anyway.
      if (!credit)
        continue;

      details.setOutput(i, path);

      state.tx(path, -1);
      state.coin(path, -1);
      state.unconfirmed(path, -output.value);
      this.unlockBalances(state, credit, path, -1);

      if (block) {
        state.confirmed(path, -output.value);
        this.unlockBalances(state, credit, path, height);
      }

      await this.removeCredit(b, credit, path);
    }

    // Undo name state.
    await this.undoNameState(b, tx);

    if (!block)
      this.unindexOpens(b, tx);

    // Remove the transaction data
    // itself as well as unindex.
    b.del(layout.t.encode(hash));

    if (!block)
      b.del(layout.p.encode(hash));
    else
      b.del(layout.h.encode(height, hash));

    // Remove all secondary indexing.
    for (const [acct, delta] of state.accounts) {
      await this.updateAccountBalance(b, acct, delta);

      b.del(layout.T.encode(acct, hash));

      if (!block)
        b.del(layout.P.encode(acct, hash));
      else
        b.del(layout.H.encode(acct, height, hash));
    }

    // Update block records.
    if (block) {
      // Remove tx count and time indexing.
      await this.removeCountAndTimeIndex(b, {
        hash,
        medianTime,
        accounts: state.accounts
      });

      // We also need to clean up unconfirmed undos.
      b.del(layout.Oe.encode(hash));

      await this.removeBlockMap(b, height);
      await this.spliceBlock(b, hash, height);
    } else {
      await this.removeTXMap(b, hash);
      // Remove count and time indexes.
      await this.removeCountAndTimeIndexUnconfirmed(b, state.accounts, hash);
    }

    // Update the transaction counter
    // and commit new state due to
    // balance change.
    const balance = await this.updateBalance(b, state);

    await b.write();

    this.emit('remove tx', tx, details);
    this.emit('balance', balance);

    return details;
  }

  /**
   * Remove a transaction and recursively
   * remove all of its spenders.
   * @private
   * @param {TXRecord} wtx
   * @param {Number} medianTime
   * @returns {Promise<Details?>}
   */

  async removeRecursive(wtx) {
    const {tx, hash} = wtx;

    if (!await this.hasTX(hash))
      return null;

    for (let i = 0; i < tx.outputs.length; i++) {
      const spent = await this.getSpent(hash, i);

      if (!spent)
        continue;

      // Remove all of the spender's spenders first.
      const stx = await this.getTX(spent.hash);

      assert(stx);

      await this.removeRecursive(stx);
    }

    const block = wtx.getBlock();
    let medianTime;

    if (block)
      medianTime = await this.wdb.getMedianTime(block.height);

    // Remove the spender.
    return this.erase(wtx, block, medianTime);
  }

  /**
   * Revert a block.
   * @param {Number} height
   * @returns {Promise<Number>} - number of txs removed.
   */

  async revert(height) {
    const block = await this.getBlock(height);

    if (!block)
      return 0;

    const hashes = block.toArray();
    const mtp = await this.wdb.getMedianTime(height);
    assert(mtp);

    for (let i = hashes.length - 1; i >= 0; i--) {
      const hash = hashes[i];
      /** @type {BlockExtraInfo} */
      const extra = {
        medianTime: mtp,
        // txIndex is not used in revert.
        txIndex: i
      };

      await this.unconfirm(hash, height, extra);
    }

    return hashes.length;
  }

  /**
   * Unconfirm a transaction without a batch.
   * @private
   * @param {Hash} hash
   * @param {Number} height
   * @param {BlockExtraInfo} extra
   * @returns {Promise<Details?>}
   */

  async unconfirm(hash, height, extra) {
    const wtx = await this.getTX(hash);

    if (!wtx) {
      this.logger.spam(
        'Reverting namestate without transaction: %x',
        hash
      );

      const b = this.bucket.batch();

      if (await this.applyNameUndo(b, hash)) {
        await this.removeBlockMap(b, height);
        await this.removeBlock(b, hash, height);

        return b.write();
      }

      return null;
    }

    if (wtx.height === -1)
      return null;

    const tx = wtx.tx;

    if (tx.isCoinbase())
      return this.removeRecursive(wtx);

    // On unconfirm, if we already have OPEN txs in the pending list we
    // remove transaction and it's descendants instead of storing them in
    // the pending list. This follows the mempool behaviour where the first
    // entries in the mempool will be the ones left, instead of txs coming
    // from the block. This ensures consistency with the double open rules.
    if (await this.isDoubleOpen(tx))
      return this.removeRecursive(wtx);

    return this.disconnect(wtx, wtx.getBlock(), extra);
  }

  /**
   * Unconfirm a transaction. Necessary after a reorg.
   * @param {TXRecord} wtx
   * @param {BlockMeta} block
   * @param {BlockExtraInfo} extra
   * @returns {Promise<Details>}
   */

  async disconnect(wtx, block, extra) {
    const b = this.bucket.batch();
    const {tx, hash, height} = wtx;
    const details = new Details(wtx, block);
    const state = new BalanceDelta();
    let own = false;

    assert(block && extra);

    wtx.unsetBlock();

    if (!tx.isCoinbase()) {
      // We need to reconnect the coins. Start
      // by getting all of the undo coins we know
      // about.
      const credits = await this.getSpentCredits(tx);

      for (let i = 0; i < tx.inputs.length; i++) {
        const credit = credits[i];

        if (!credit) {
          await this.writeInput(b, tx, i);
          continue;
        }

        const coin = credit.coin;

        assert(coin.height !== -1);

        const path = await this.getPath(coin);
        assert(path);

        details.setInput(i, path, coin);

        state.confirmed(path, coin.value);
        this.lockBalances(state, credit, path, height);

        // Resave the credit and mark it
        // as spent in the mempool instead.
        credit.spent = true;
        own = true;
        await this.saveCredit(b, credit, path);
      }
    }

    // We need to remove heights on
    // the credits and undo coins.
    for (let i = 0; i < tx.outputs.length; i++) {
      const output = tx.outputs[i];
      const path = await this.getPath(output);

      if (!path)
        continue;

      let credit = await this.getCredit(hash, i);
      let resolved = false;

      // Potentially update undo coin height.
      if (!credit) {
        // TODO: Emit 'missed credit' event.

        // This credit didn't belong to us the first time we
        // saw the transaction (after confirmation).
        // Create new credit for database.
        credit = Credit.fromTX(tx, i, height);

        // If this tx spent any of our own coins, we "own" this output,
        // meaning if it becomes unconfirmed, we can still confidently spend it.
        credit.own = own;
        resolved = true;

        const spender = await this.getSpent(hash, i);

        if (spender) {
          credit.spent = true;
          this.addUndoToInput(b, credit, spender);
        } else {
          // If the newly discovered Coin is not spent,
          // we need to add these to the balance.
          state.coin(path, 1);
          state.unconfirmed(path, credit.coin.value);
          this.lockBalances(state, credit, path, -1);
        }
      } else if (credit.spent) {
        // The coin height of this output becomes -1
        // as it is being unconfirmed.
        await this.updateSpentCoin(b, tx, i, -1);
      }

      details.setOutput(i, path);

      // Update coin height and confirmed
      // balance. Save once again.
      credit.coin.height = -1;

      // If the coin was not discovered now, it means
      // we need to subtract the values as they were part of
      // the balance.
      // If the credit is new, confirmed balances did not account for it.
      if (!resolved) {
        state.confirmed(path, -output.value);
        this.unlockBalances(state, credit, path, height);
      }

      await this.saveCredit(b, credit, path);
    }

    // Unconfirm will also index OPENs as the transaction is now part of the
    // wallet pending transactions.
    this.indexOpens(b, tx);

    // Undo name state.
    await this.undoNameState(b, tx);

    await this.addTXMap(b, hash);
    await this.removeBlockMap(b, height);
    await this.removeBlock(b, tx.hash(), height);

    // We need to update the now-removed
    // block properties and reindex due
    // to the height change.
    b.put(layout.t.encode(hash), wtx.encode());
    b.put(layout.p.encode(hash), null);
    b.del(layout.h.encode(height, hash));

    // Secondary indexing also needs to change.
    for (const [acct, delta] of state.accounts) {
      await this.updateAccountBalance(b, acct, delta);
      b.put(layout.P.encode(acct, hash), null);
      b.del(layout.H.encode(acct, height, hash));
    }

    // Remove tx count and time indexing. This must
    // go before restoring the unconfirmed count.
    await this.removeCountAndTimeIndex(b, {
      hash,
      medianTime: extra.medianTime,
      accounts: state.accounts
    });

    // Restore count indexing for unconfirmed txs.
    await this.restoreCountAndTimeIndexUnconfirmed(b, state.accounts, hash);

    // Commit state due to unconfirmed
    // vs. confirmed balance change.
    const balance = await this.updateBalance(b, state);

    await b.write();

    this.emit('unconfirmed', tx, details);
    this.emit('balance', balance);

    return details;
  }

  /*
   * Count and time index.
   */

  /**
   * Get the latest unconfirmed TX count from the database. This number
   * does not represent the count of current unconfirmed transactions,
   * but the count of all unconfirmed transactions. As transactions are
   * confirmed the value is deleted, however proceeding values are not
   * decremented as to not have a large number of database updates at once.
   * @returns {Promise<TXCount>}
   */

  async getLatestUnconfirmedTXCount() {
    const raw = await this.bucket.get(layout.Ol.encode());
    let index = 0;

    if (raw)
      index = raw.readUInt32LE(0, true);

    return new TXCount(UNCONFIRMED_HEIGHT, index);
  }

  /**
   * Increment latest unconfirmed index.
   * @private
   * @param {Batch} b
   * @param {Number} count
   */

  incrementLatestUnconfirmedTXCount(b, count) {
    assert(count + 1 <= 0xffffffff, 'Number exceeds 32-bits.');
    b.put(layout.Ol.encode(), fromU32(count + 1));
  }

  /**
   * Get the count of a transaction.
   * @param {Hash} hash - Transaction hash.
   * @returns {Promise<TXCount?>}
   */

  async getCountForTX(hash) {
    assert(Buffer.isBuffer(hash));

    const raw = await this.bucket.get(layout.Oc.encode(hash));

    if (!raw)
      return null;

    return TXCount.decode(raw);
  }

  /**
   * Get the undo count of a transaction.
   * @param {Hash} hash - Transaction hash.
   * @returns {Promise<TXCount?>}
   */

  async getUndoCountForTX(hash) {
    assert(Buffer.isBuffer(hash));

    const raw = await this.bucket.get(layout.Ou.encode(hash));

    if (!raw)
      return null;

    return TXCount.decode(raw);
  }

  /**
   * Add undo unconfirmed time and unconfirmed index to restore unconfirmed
   * time during reorganizations.
   * @private
   * @param {Batch} b
   * @param {Hash} hash - Transaction hash.
   * @param {Number} time - Transaction time.
   * @returns {Promise}
   */

  async addCountAndTimeIndexUnconfirmedUndo(b, hash, time) {
    const count = await this.getLatestUnconfirmedTXCount();

    b.put(layout.Oe.encode(hash), fromU32(time));
    b.put(layout.Ou.encode(hash), count.encode());

    this.incrementLatestUnconfirmedTXCount(b, count.index);
  }

  /**
   * Add unconfirmed time indexing to support querying
   * unconfirmed transaction history in subsets by time.
   * @private
   * @param {Hash} hash - Transaction hash.
   * @returns {Promise<Number>}
   */

  async getUnconfirmedTimeForTX(hash) {
    const raw = await this.bucket.get(layout.Oe.encode(hash));

    if (!raw)
      throw new Error('Unconfirmed time not found.');

    return raw.readUInt32LE(0, true);
  }

  /**
   * Add count and time based indexing to support querying
   * unconfirmed transaction history in subsets by time
   * and by count.
   * This is called when we see a new transaction that is
   * unconfirmed. insert() w/o block.
   * @private
   * @param {Batch} b
   * @param {Map<Number, Balance>} accounts
   * @param {Hash} hash - Transaction hash.
   * @param {Number} time - Transaction time.
   * @returns {Promise}
   */

  async addCountAndTimeIndexUnconfirmed(b, accounts, hash, time) {
    const count = await this.getLatestUnconfirmedTXCount();

    b.put(layout.Ot.encode(count.height, count.index), hash);
    b.put(layout.Oc.encode(hash), count.encode());

    b.put(layout.Oe.encode(hash), fromU32(time));
    b.put(layout.Om.encode(time, count.index, hash));

    for (const [acct] of accounts) {
      b.put(layout.OT.encode(acct, count.height, count.index), hash);
      b.put(layout.OM.encode(acct, time, count.index, hash));
    }

    this.incrementLatestUnconfirmedTXCount(b, count.index);
  }

  /**
   * Remove unconfirmed count and time based indexing. This will
   * however leave some of the information around so that it's
   * possible to restore the index should it be necessary during a
   * reorg. This will remove indexing into the subsets of confirmed
   * results, it will keep the count in the database that can be
   * queried by hash, should there be a reorg and the transaction
   * becomes pending again.
   * @private
   * @param {Batch} b
   * @param {Map<Number, Balance>} accounts
   * @param {Hash} hash - Transaction hash.
   */

  async disconnectCountAndTimeIndexUnconfirmed(b, accounts, hash) {
    const count = await this.getCountForTX(hash);

    if (!count)
      throw new Error('Transaction count not found.');

    if (count.height !== UNCONFIRMED_HEIGHT)
      throw new Error('Transaction is confirmed.');

    // Add undo information to later restore the
    // unconfirmed count, and remove the count.
    b.put(layout.Ou.encode(hash), count.encode());

    const {height, index} = count;
    b.del(layout.Ot.encode(height, index));
    b.del(layout.Oc.encode(hash));

    const time = await this.getUnconfirmedTimeForTX(hash);
    b.del(layout.Om.encode(time, index, hash));

    for (const [acct] of accounts) {
      b.del(layout.OT.encode(acct, height, index));
      b.del(layout.OM.encode(acct, time, index, hash));
    }
  }

  /**
   * This will restore the count and time indexing for
   * unconfirmed transactions during reorganizations. This is
   * possible because we leave the pre-existing count in
   * the database.
   * @private
   * @param {Batch} b
   * @param {Map<Number, Balance>} accounts
   * @param {Hash} hash - Transaction hash.
   */

  async restoreCountAndTimeIndexUnconfirmed(b, accounts, hash) {
    const count = await this.getUndoCountForTX(hash);

    if (!count)
      throw new Error('Transaction count not found.');

    b.put(layout.Oc.encode(hash), count.encode());
    b.put(layout.Ot.encode(count.height, count.index), hash);

    // We no longer need undo count as it becomes the count.
    b.del(layout.Ou.encode(hash));

    const time = await this.getUnconfirmedTimeForTX(hash);
    b.put(layout.Om.encode(time, count.index, hash));

    for (const [acct] of accounts) {
      b.put(layout.OT.encode(acct, count.height, count.index), hash);
      b.put(layout.OM.encode(acct, time, count.index, hash));
    }
  }

  /**
   * Remove all unconfirmed count and time based indexing.
   * @private
   * @param {Batch} b
   * @param {Map<Number, Balance>} accounts
   * @param {Hash} hash - Transaction hash.
   * @returns {Promise}
   */

  async removeCountAndTimeIndexUnconfirmed(b, accounts, hash) {
    const count = await this.getCountForTX(hash);

    if (!count)
      throw new Error('Transaction count not found.');

    if (count.height !== UNCONFIRMED_HEIGHT)
      throw new Error('Transaction is confirmed.');

    b.del(layout.Ot.encode(count.height, count.index));
    b.del(layout.Oc.encode(hash));

    const time = await this.getUnconfirmedTimeForTX(hash);
    b.del(layout.Om.encode(time, count.index, hash));
    b.del(layout.Oe.encode(hash));

    for (const [acct] of accounts) {
      b.del(layout.OT.encode(acct, count.height, count.index));
      b.del(layout.OM.encode(acct, time, count.index, hash));
    }
  }

  /**
   * Add monotonic time and count based indexing to support
   * querying transaction history in subsets and by time.
   * @private
   * @param {Batch} b
   * @param {Object} options
   * @param {Map<Number, Balance>} options.accounts
   * @param {Hash} options.hash - Transaction hash.
   * @param {Number} options.height
   * @param {BlockExtraInfo} options.blockextra
   * @returns {Promise}
   */

  async addCountAndTimeIndex(b, options) {
    const {
      accounts,
      hash,
      height,
      blockextra
    } = options;

    const index = blockextra.txIndex;
    const count = new TXCount(height, index);

    b.put(layout.Ot.encode(height, index), hash);
    b.put(layout.Oc.encode(hash), count.encode());

    const time = blockextra.medianTime;
    b.put(layout.Oi.encode(time, height, index, hash));

    for (const [acct] of accounts) {
      b.put(layout.OT.encode(acct, height, index), hash);
      b.put(layout.OI.encode(acct, time, height, index, hash));
    }
  }

  /**
   * Remove monotonic time and count based indexing.
   * @private
   * @param {Batch} b
   * @param {Object} options
   * @param {Hash} options.hash - Transaction hash.
   * @param {Number} options.medianTime - Block median time.
   * @param {Map<Number, Balance>} options.accounts
   * @returns {Promise}
   */

  async removeCountAndTimeIndex(b, options) {
    const {
      accounts,
      hash,
      medianTime
    } = options;

    const count = await this.getCountForTX(hash);

    if (!count)
      throw new Error('Transaction count not found.');

    b.del(layout.Ot.encode(count.height, count.index));
    b.del(layout.Oc.encode(hash));

    const time = medianTime;
    b.del(layout.Oi.encode(time, count.height,
                          count.index, options.hash));

    for (const [acct] of accounts) {
      b.del(layout.OT.encode(acct, count.height, count.index));

      b.del(layout.OI.encode(acct, time, count.height,
                            count.index, options.hash));
    }
  }

  /**
   * Get all transactions in ascending or decending order
   * limited at a configurable max transactions.
   * @param {Number} acct
   * @param {Object} options
   * @param {Number} options.limit
   * @param {Boolean} options.reverse
   * @returns {Promise<TXRecord[]>}
   */

  async listHistory(acct, options) {
    assert(typeof acct === 'number');
    assert(options && typeof options === 'object');
    assert(typeof options.limit === 'number');
    assert(typeof options.reverse === 'boolean');

    if (options.limit > this.maxTXs)
      throw new Error(`Limit exceeds max of ${this.maxTXs}.`);

    let hashes = [];

    if (acct !== -1) {
      hashes = await this.bucket.values({
        gte: layout.OT.min(acct),
        lte: layout.OT.max(acct),
        limit: options.limit,
        reverse: options.reverse
      });
    } else {
      hashes = await this.bucket.values({
        gte: layout.Ot.min(),
        lte: layout.Ot.max(),
        limit: options.limit,
        reverse: options.reverse
      });
    }

    return Promise.all(hashes.map(async (hash) => {
      return await this.getTX(hash);
    }));
  }

  /**
   * Get all transactions in ascending or decending
   * order from a time (inclusive) and limited at a
   * configurable max of transactions.
   * @param {Number} acct
   * @param {Object} options
   * @param {Buffer} options.time
   * @param {Number} options.limit
   * @param {Boolean} options.reverse
   * @returns {Promise<TXRecord[]>}
   */

  async listHistoryByTime(acct, options) {
    assert(typeof acct === 'number');
    assert(options && typeof options === 'object');
    assert(typeof options.time === 'number');
    assert(typeof options.limit === 'number');
    assert(typeof options.reverse === 'boolean');

    if (options.limit > this.maxTXs)
      throw new Error(`Limit exceeds max of ${this.maxTXs}.`);

    let max = null;
    let min = null;
    let parse = null;

    if (acct !== -1) {
      if (options.reverse) {
        min = layout.OI.min();
        max = layout.OI.max(acct, options.time);
      } else {
        min = layout.OI.min(acct, options.time);
        max = layout.OI.max();
      }
      parse = (key) => {
        const [,,,,hash] = layout.OI.decode(key);
        return hash;
      };
    } else {
      if (options.reverse) {
        min = layout.Oi.min();
        max = layout.Oi.max(options.time);
      } else {
        min = layout.Oi.min(options.time);
        max = layout.Oi.max();
      }
      parse = (key) => {
        const [,,,hash] = layout.Oi.decode(key);
        return hash;
      };
    }

    const keys = await this.bucket.keys({
      gte: min,
      lte: max,
      limit: 1,
      reverse: options.reverse,
      parse: parse
    });

    const hash = keys.length > 0 ? keys[0] : null;

    if (!hash)
      return [];

    return this.listHistoryFrom(acct, {
      hash,
      limit: options.limit,
      reverse: options.reverse
    });
  }

  /**
   * Get all transactions in ascending or decending
   * order after a txid/hash (exclusive) and limited at a
   * configurable max of transactions.
   * @param {Number} acct
   * @param {Object} options
   * @param {Buffer} options.hash
   * @param {Number} options.limit
   * @param {Boolean} options.reverse
   * @returns {Promise<TXRecord[]>}
   */

  async listHistoryAfter(acct, options) {
    assert(typeof acct === 'number');
    assert(options && typeof options === 'object');
    return this._listHistory(acct, {
      hash: options.hash,
      limit: options.limit,
      reverse: options.reverse,
      inclusive: false
    });
  }

  /**
   * Get all transactions in ascending or decending
   * order after a txid/hash (inclusive) and limited at a
   * configurable max of transactions.
   * @param {Number} acct
   * @param {Object} options
   * @param {Buffer} options.hash
   * @param {Number} options.limit
   * @param {Boolean} options.reverse
   * @returns {Promise<TXRecord[]>}
   */

  async listHistoryFrom(acct, options) {
    assert(typeof acct === 'number');
    assert(options && typeof options === 'object');
    return this._listHistory(acct, {
      hash: options.hash,
      limit: options.limit,
      reverse: options.reverse,
      inclusive: true
    });
  }

  /**
   * Get all transactions in ascending or decending
   * order after or from a txid/hash, inclusive or exclusive
   * and limited at a configurable max of transactions.
   * @private
   * @param {Number} acct
   * @param {Number} options
   * @param {Buffer} options.hash
   * @param {Number} options.limit
   * @param {Boolean} options.reverse
   * @param {Boolean} options.inclusive
   * @returns {Promise<TXRecord[]>}
   */

  async _listHistory(acct, options) {
    assert(typeof acct === 'number');
    assert(options && typeof options === 'object');
    assert(Buffer.isBuffer(options.hash));
    assert(typeof options.limit === 'number');
    assert(typeof options.reverse === 'boolean');
    assert(typeof options.inclusive === 'boolean');

    if (options.limit > this.maxTXs)
      throw new Error(`Limit exceeds max of ${this.maxTXs}.`);

    const count = await this.getCountForTX(options.hash);

    if (!count)
      throw new Error('Transaction not found.');

    const zopts = {
      limit: options.limit,
      reverse: options.reverse
    };

    const lesser = options.inclusive ? 'lte' : 'lt';
    const greater = options.inclusive ? 'gte' : 'gt';

    if (acct !== -1) {
      if (zopts.reverse) {
        zopts['gte'] = layout.OT.min(acct);
        zopts[lesser] = layout.OT.encode(acct, count.height, count.index);
      } else {
        zopts[greater] = layout.OT.encode(acct, count.height, count.index);
        zopts['lte'] = layout.OT.max(acct);
      }
    } else {
      if (zopts.reverse) {
        zopts['gte'] = layout.Ot.min();
        zopts[lesser] = layout.Ot.encode(count.height, count.index);
      } else {
        zopts[greater] = layout.Ot.encode(count.height, count.index);
        zopts['lte'] = layout.Ot.max();
      }
    }

    const hashes = await this.bucket.values(zopts);

    return Promise.all(hashes.map(async (hash) => {
      return await this.getTX(hash);
    }));
  }

  /**
   * Get all unconfirmed transactions in ascending or
   * decending order limited at a configurable
   * max transactions.
   * @param {Number} acct
   * @param {Object} options
   * @param {Number} options.limit
   * @param {Boolean} options.reverse
   * @returns {Promise<TXRecord[]>}
   */

  async listUnconfirmed(acct, options) {
    assert(typeof acct === 'number');
    assert(options && typeof options === 'object');
    assert(typeof options.limit === 'number');
    assert(typeof options.reverse === 'boolean');

    if (options.limit > this.maxTXs)
      throw new Error(`Limit exceeds max of ${this.maxTXs}.`);

    const height = UNCONFIRMED_HEIGHT;

    let hashes = [];

    if (acct !== -1) {
      hashes = await this.bucket.values({
        gte: layout.OT.min(acct, height),
        lte: layout.OT.max(acct, height),
        limit: options.limit,
        reverse: options.reverse
      });
    } else {
      hashes = await this.bucket.values({
        gte: layout.Ot.min(height),
        lte: layout.Ot.max(height),
        limit: options.limit,
        reverse: options.reverse
      });
    }

    return Promise.all(hashes.map(async (hash) => {
      return await this.getTX(hash);
    }));
  }

  /**
   * Get all unconfirmed transactions in ascending or
   * decending order limited at a configurable
   * max transactions.
   * @param {Number} acct
   * @param {Object} options
   * @param {Number} options.limit
   * @param {Boolean} options.reverse
   * @returns {Promise<TXRecord[]>}
   */

  async listUnconfirmedByTime(acct, options) {
    assert(typeof acct === 'number');
    assert(options && typeof options === 'object');
    assert(typeof options.time === 'number');
    assert(typeof options.limit === 'number');
    assert(typeof options.reverse === 'boolean');

    if (options.limit > this.maxTXs)
      throw new Error(`Limit exceeds max of ${this.maxTXs}.`);

    let max = null;
    let min = null;
    let parse = null;

    if (acct !== -1) {
      if (options.reverse) {
        min = layout.OM.min();
        max = layout.OM.max(acct, options.time);
      } else {
        min = layout.OM.min(acct, options.time);
        max = layout.OM.max();
      }
      parse = (key) => {
        const [,,,hash] = layout.OM.decode(key);
        return hash;
      };
    } else {
      if (options.reverse) {
        min = layout.Om.min();
        max = layout.Om.max(options.time);
      } else {
        min = layout.Om.min(options.time);
        max = layout.Om.max();
      }
      parse = (key) => {
        const [,,hash] = layout.Om.decode(key);
        return hash;
      };
    }

    const keys = await this.bucket.keys({
      gte: min,
      lte: max,
      limit: 1,
      reverse: options.reverse,
      parse: parse
    });

    const hash = keys.length > 0 ? keys[0] : null;

    if (!hash)
      return [];

    return this.listUnconfirmedFrom(acct, {
      hash,
      limit: options.limit,
      reverse: options.reverse
    });
  }

  /**
   * Get all unconfirmed transactions in ascending or
   * decending order after a txid/hash (exclusive) and limited
   * at a max of 100 transactions.
   * @param {Number} acct
   * @param {Object} options
   * @param {Buffer} options.hash
   * @param {Number} options.limit
   * @param {Boolean} options.reverse
   * @returns {Promise<TXRecord[]>}
   */

  async listUnconfirmedAfter(acct, options) {
    assert(typeof acct === 'number');
    assert(options && typeof options === 'object');

    return this._listUnconfirmed(acct, {
      hash: options.hash,
      limit: options.limit,
      reverse: options.reverse,
      inclusive: false
    });
  }

  /**
   * Get all unconfirmed transactions in ascending or
   * decending order after a txid/hash (inclusive) and limited
   * at a max of 100 transactions.
   * @param {Number} acct
   * @param {Object} options
   * @param {Buffer} options.hash
   * @param {Number} options.limit
   * @param {Boolean} options.reverse
   * @returns {Promise<TXRecord[]>}
   */

  async listUnconfirmedFrom(acct, options) {
    assert(typeof acct === 'number');
    assert(options && typeof options === 'object');

    return this._listUnconfirmed(acct, {
      hash: options.hash,
      limit: options.limit,
      reverse: options.reverse,
      inclusive: true
    });
  }

  /**
   * Get all unconfirmed transactions in ascending or
   * decending order after or from a txid/hash, inclusive or
   * exclusive and limited at a configurable max
   * of transactions
   * @private
   * @param {Number} acct
   * @param {Number} options
   * @param {Buffer} options.hash
   * @param {Number} options.limit
   * @param {Boolean} options.reverse
   * @param {Boolean} options.inclusive
   * @returns {Promise<TXRecord[]>}
   */

  async _listUnconfirmed(acct, options) {
    assert(typeof acct === 'number');
    assert(options && typeof options === 'object');
    assert(Buffer.isBuffer(options.hash));
    assert(typeof options.limit === 'number');
    assert(typeof options.reverse === 'boolean');
    assert(typeof options.inclusive === 'boolean');

    if (options.limit > this.maxTXs)
      throw new Error(`Limit exceeds max of ${this.maxTXs}.`);

    const count = await this.getCountForTX(options.hash);

    if (!count)
      throw new Error('Transaction not found.');

    if (count.height !== UNCONFIRMED_HEIGHT)
      throw new Error('Transaction is confirmed.');

    const {height, index} = count;

    const uopts = {
      limit: options.limit,
      reverse: options.reverse
    };

    const lesser = options.inclusive ? 'lte' : 'lt';
    const greater = options.inclusive ? 'gte' : 'gt';

    if (acct !== -1) {
      if (uopts.reverse) {
        uopts['gte'] = layout.OT.min(acct, height);
        uopts[lesser] = layout.OT.encode(acct, height, index);
      } else {
        uopts[greater] = layout.OT.encode(acct, height, index);
        uopts['lte'] = layout.OT.max(acct, height);
      }
    } else {
      if (uopts.reverse) {
        uopts['gte'] = layout.Ot.min(height);
        uopts[lesser] = layout.Ot.encode(height, index);
      } else {
        uopts[greater] = layout.Ot.encode(height, index);
        uopts['lte'] = layout.Ot.max(height);
      }
    }

    const hashes = await this.bucket.values(uopts);

    return Promise.all(hashes.map(async (hash) => {
      return await this.getTX(hash);
    }));
  }

  /**
   * Remove spenders that have not been confirmed. We do this in the
   * odd case of stuck transactions or when a coin is double-spent
   * by a newer transaction. All previously-spending transactions
   * of that coin that are _not_ confirmed will be removed from
   * the database.
   * @private
   * @param {Hash} hash
   * @param {TX} ref - Reference tx, the tx that double-spent.
   * @returns {Promise<Details?>} - Returns Boolean.
   */

  async removeConflict(wtx) {
    const tx = wtx.tx;

    this.logger.warning('Handling conflicting tx: %x.', tx.hash());

    const details = await this.removeRecursive(wtx);

    if (!details)
      return null;

    this.logger.warning('Removed conflict: %x.', tx.hash());

    // Emit the _removed_ transaction.
    this.emit('conflict', tx, details);

    return details;
  }

  /**
   * Retrieve coins for own inputs, remove
   * double spenders, and verify inputs.
   * @private
   * @param {TX} tx
   * @param {Boolean} conf
   * @returns {Promise<Boolean>}
   */

  async removeConflicts(tx, conf) {
    if (tx.isCoinbase())
      return true;

    const txid = tx.hash();
    const spends = [];

    // Gather all spent records first.
    for (const {prevout} of tx.inputs) {
      const {hash, index} = prevout;

      // Is it already spent?
      const spent = await this.getSpent(hash, index);

      if (!spent)
        continue;

      // Did _we_ spend it?
      if (spent.hash.equals(txid))
        continue;

      const spender = await this.getTX(spent.hash);
      assert(spender);

      if (conf && spender.height !== -1)
        return false;

      spends.push(spender);
    }

    // Once we know we're not going to
    // screw things up, remove the double
    // spenders.
    for (const spender of spends) {
      // Remove the double spender.
      await this.removeConflict(spender);
    }

    return true;
  }

  /**
   * Lock balances according to covenant.
   * Inserting or confirming: TX outputs.
   * Removing or undoing: Coins spent by the wallet in tx inputs.
   * @param {State} state
   * @param {Credit} credit
   * @param {Path} path
   * @param {Number} height
   */

  lockBalances(state, credit, path, height) {
    const {value, covenant} = credit.coin;

    switch (covenant.type) {
      case types.CLAIM:    // output is locked until REGISTER
      case types.BID:      // output is locked until REVEAL
      case types.REVEAL:   // output is locked until REDEEM
      case types.REGISTER: // output is now locked or "burned"
      case types.UPDATE:   // output has been locked since REGISTER
      case types.RENEW:
      case types.TRANSFER:
      case types.FINALIZE:
      case types.REVOKE:
      {
        if (height === -1)
          state.ulocked(path, value);
        else
          state.clocked(path, value);
        break;
      }

      case types.REDEEM:   // noop: already unlocked by the BID in the input
        break;
    }
  }

  /**
   * Unlock balances according to covenants.
   * Inserting or confirming: Coins spent by the wallet in TX inputs.
   * Removing or undoing: TX outputs.
   * @param {State} state
   * @param {Credit} credit
   * @param {Path} path
   * @param {Number} height
   */

  unlockBalances(state, credit, path, height) {
    const {value, covenant} = credit.coin;

    switch (covenant.type) {
      case types.CLAIM:    // output is locked until REGISTER
      case types.BID:      // output is locked until REVEAL
      case types.REVEAL:   // output is locked until REDEEM
      case types.REGISTER: // output is now locked or "burned"
      case types.UPDATE:   // output has been locked since REGISTER
      case types.RENEW:
      case types.TRANSFER:
      case types.FINALIZE:
      case types.REVOKE:
      {
        if (height === -1)
          state.ulocked(path, -value);
        else
          state.clocked(path, -value);
        break;
      }
      case types.REDEEM:   // noop: already unlocked by the BID in the input
        break;
    }
  }

  /**
   * Start tracking OPENs right away.
   * This does not check if the name is owned by the wallet.
   * @private
   * @param {Batch} b
   * @param {Output} tx
   * @param {Path} path
   * @returns {Promise}
   */

  async watchOpensEarly(b, output) {
    const {covenant} = output;

    if (!covenant.isOpen())
      return;

    const nameHash = covenant.getHash(0);

    if (!await this.wdb.hasNameMap(nameHash, this.wid))
      await this.addNameMap(b, nameHash);
  }

  /**
   * Handle incoming covenant.
   * @param {Object} b
   * @param {TX} tx
   * @param {CoinView} view
   * @param {Number} height
   * @returns {Promise<Boolean>} updated
   */

  async connectNames(b, tx, view, height) {
    const hash = tx.hash();
    const network = this.wdb.network;

    assert(height !== -1);

    // If namestate has been updated we need to write to DB
    let updated = false;

    for (let i = 0; i < tx.outputs.length; i++) {
      const output = tx.outputs[i];
      const {covenant} = output;

      if (!covenant.isName())
        continue;

      const path = await this.getPath(output);
      const nameHash = covenant.getHash(0);
      const outpoint = tx.outpoint(i);
      const ns = await view.getNameState(this, nameHash);

      if (!ns.isNull())
        ns.maybeExpire(height, network);

      switch (covenant.type) {
        case types.CLAIM: {
          if (!path)
            break;

          const name = covenant.get(2);
          const flags = covenant.getU8(3);
          const claimed = covenant.getU32(5);

          if (ns.isNull()) {
            await this.addNameMap(b, nameHash);
            ns.set(name, height);
          }

          ns.setHeight(height);
          ns.setRenewal(height);
          ns.setClaimed(claimed);
          ns.setValue(0);
          ns.setOwner(outpoint);
          ns.setHighest(0);
          ns.setWeak((flags & 1) !== 0);

          updated = true;

          break;
        }

        case types.OPEN: {
          if (!path) {
            // Are we "watching" this name?
            if (!await this.wdb.hasNameMap(nameHash, this.wid))
              break;

            const name = covenant.get(2);
            ns.set(name, height);
            updated = true;
            break;
          }

          if (ns.isNull()) {
            const name = covenant.get(2);

            await this.addNameMap(b, nameHash);

            ns.set(name, height);

            updated = true;
          }

          break;
        }

        case types.BID: {
          const start = covenant.getU32(1);
          const name = covenant.get(2);
          const blind = covenant.getHash(3);
          const lockup = output.value;

          if (!path) {
            if (ns.isNull())
              break;

            this.putBid(b, nameHash, outpoint, {
              name,
              lockup,
              blind,
              height,
              own: false
            });

            updated = true;

            break;
          }

          if (ns.isNull())
            await this.addNameMap(b, nameHash);

          ns.set(name, start);

          this.putBid(b, nameHash, outpoint, {
            name,
            lockup,
            blind,
            height,
            own: true
          });

          updated = true;

          break;
        }

        case types.REVEAL: {
          if (ns.isNull())
            break;

          if (ns.owner.isNull() || output.value > ns.highest) {
            ns.setValue(ns.highest);
            ns.setOwner(outpoint);
            ns.setHighest(output.value);
          } else if (output.value > ns.value) {
            ns.setValue(output.value);
          }

          const {prevout} = tx.inputs[i];

          if (!path) {
            this.putReveal(b, nameHash, outpoint, {
              name: ns.name,
              value: output.value,
              height: height,
              own: false,
              bidPrevout: prevout
            });
            updated = true;
            break;
          }

          const coin = view.getOutput(prevout);

          if (coin) {
            const uc = coin.covenant;
            const blind = uc.getHash(3);
            const nonce = covenant.getHash(2);

            this.putBlind(b, blind, {
              value: output.value,
              nonce: nonce
            });
          }

          this.putReveal(b, nameHash, outpoint, {
            name: ns.name,
            value: output.value,
            height: height,
            own: true,
            bidPrevout: prevout
          });

          updated = true;

          break;
        }

        case types.REDEEM: {
          break;
        }

        case types.REGISTER: {
          if (ns.isNull())
            break;

          const data = covenant.get(2);

          ns.setRegistered(true);
          ns.setOwner(outpoint);

          if (data.length > 0)
            ns.setData(data);

          ns.setRenewal(height);

          updated = true;

          break;
        }

        case types.UPDATE: {
          if (ns.isNull())
            break;

          const data = covenant.get(2);

          ns.setOwner(outpoint);

          if (data.length > 0)
            ns.setData(data);

          ns.setTransfer(0);

          updated = true;

          break;
        }

        case types.RENEW: {
          if (ns.isNull())
            break;

          ns.setOwner(outpoint);
          ns.setTransfer(0);
          ns.setRenewal(height);
          ns.setRenewals(ns.renewals + 1);

          updated = true;

          break;
        }

        case types.TRANSFER: {
          if (ns.isNull())
            break;

          ns.setOwner(outpoint);

          assert(ns.transfer === 0);
          ns.setTransfer(height);

          updated = true;

          break;
        }

        case types.FINALIZE: {
          if (ns.isNull()) {
            if (!path)
              break;

            await this.addNameMap(b, nameHash);

            const start = covenant.getU32(1);
            const name = covenant.get(2);
            const flags = covenant.getU8(3);
            const weak = (flags & 1) !== 0;
            const claimed = covenant.getU32(4);
            const renewals = covenant.getU32(5);

            ns.set(name, start);
            ns.setRegistered(true);
            ns.setValue(output.value);
            ns.setWeak(weak);
            ns.setClaimed(claimed);
            ns.setRenewals(renewals);

            // Cannot get data or highest.
            ns.setHighest(output.value);
          } else {
            assert(ns.transfer !== 0);
            ns.setTransfer(0);
          }

          ns.setOwner(tx.outpoint(i));
          ns.setRenewal(height);
          ns.setRenewals(ns.renewals + 1);

          updated = true;

          break;
        }

        case types.REVOKE: {
          if (ns.isNull())
            break;

          assert(ns.revoked === 0);
          ns.setRevoked(height);
          ns.setTransfer(0);
          ns.setData(null);

          updated = true;

          break;
        }
      }
    }

    for (const ns of view.names.values()) {
      const {nameHash} = ns;

      if (ns.isNull()) {
        b.del(layout.A.encode(nameHash));
        continue;
      }

      b.put(layout.A.encode(nameHash), ns.encode());
    }

    if (updated) {
      const undo = view.toNameUndo();

      // Always write the undo record as it
      // serves as a marker to determine whether
      // we have a processed a transaction's
      // covenants before. This function is
      // probably better served by its own
      // special record, but that would require
      // a data migration.
      b.put(layout.U.encode(hash), undo.encode());
    }

    return updated;
  }

  /**
   * Handle reorg'd covenant.
   * @param {Object} b
   * @param {TX} tx
   * @param {Number} i
   * @param {Path} path
   * @param {Number} height
   * @returns {Promise<Boolean>} applied undo.
   */

  async undoNameState(b, tx) {
    const hash = tx.hash();

    for (let i = 0; i < tx.outputs.length; i++) {
      const output = tx.outputs[i];
      const {covenant} = output;

      if (!covenant.isName())
        continue;

      switch (covenant.type) {
        case types.BID: {
          const nameHash = covenant.getHash(0);
          this.removeBid(b, nameHash, tx.outpoint(i));
          break;
        }
        case types.REVEAL: {
          const input = tx.inputs[i];
          const nameHash = covenant.getHash(0);
          this.removeReveal(b, nameHash, tx.outpoint(i), input.prevout);
          break;
        }
      }
    }

    return this.applyNameUndo(b, hash);
  }

  /**
   * Apply namestate undo data by hash without transaction.
   * Should only be called directly to undo namestate transitions
   * that do not affect wallet balance like a TRANSFER for a name
   * that is in the nameMap but does not involve wallet addresses.
   * @param {Object} b
   * @param {Hash} hash
   * @returns {Promise<Boolean>} - applied undo.
   */

  async applyNameUndo(b, hash) {
    const raw = await this.bucket.get(layout.U.encode(hash));

    if (!raw)
      return false;

    const undo = NameUndo.decode(raw);
    const view = new CoinView();

    for (const [nameHash, delta] of undo.names) {
      const ns = await view.getNameState(this, nameHash);

      ns.applyState(delta);

      if (ns.isNull()) {
        // Even though we are removing the namestate from the database,
        // we are going to keep the name in the wallet's "watch list"
        // by NOT calling removeNameMap(). This will preserve names
        // added by rpc importname. The side effect will be potential db bloat,
        // but only in the edge case where an auction we are interested in
        // is re-org'ed completely out of existence. In that case,
        // we will still track the name even though the OPEN has vanished.
        b.del(layout.A.encode(nameHash));
      } else {
        b.put(layout.A.encode(nameHash), ns.encode());
      }
    }

    b.del(layout.U.encode(hash));

    return true;
  }

  /**
   * Recalculate wallet balances.
   * @returns {Promise}
   */

  async recalculateBalances() {
    const state = new BalanceDelta();

    const creditIter = this.bucket.iterator({
      gte: layout.c.min(),
      lte: layout.c.max(),
      values: true
    });

    await creditIter.each(async (key, raw) => {
      const credit = Credit.decode(raw);
      const coin = credit.coin;
      const value = coin.value;
      const path = await this.getPath(coin);

      assert(path);

      state.coin(path, 1);
      state.unconfirmed(path, value);
      this.lockBalances(state, credit, path, -1);

      // Unconfirmed coins
      if (coin.height !== -1) {
        state.confirmed(path, value);
        this.lockBalances(state, credit, path, coin.height);
      }

      if (credit.spent) {
        state.coin(path, -1);
        state.unconfirmed(path, -value);
        this.unlockBalances(state, credit, path, -1);
      }
    });

    const batch = this.bucket.batch();

    for (const [acct, delta] of state.accounts) {
      const oldAccountBalance = await this.getAccountBalance(acct);
      const finalAcctBalance = new Balance();
      finalAcctBalance.tx = oldAccountBalance.tx;

      delta.applyTo(finalAcctBalance);
      batch.put(layout.r.encode(acct), finalAcctBalance.encode());
    }

    const walletBalance = await this.getWalletBalance();
    const finalWalletBalance = new Balance();
    finalWalletBalance.tx = walletBalance.tx;
    state.applyTo(finalWalletBalance);
    batch.put(layout.R.encode(), finalWalletBalance.encode());

    await batch.write();
  }

  /**
   * Lock all coins in a transaction.
   * @param {TX} tx
   */

  lockTX(tx) {
    if (tx.isCoinbase())
      return;

    for (const input of tx.inputs)
      this.lockCoin(input.prevout);
  }

  /**
   * Unlock all coins in a transaction.
   * @param {TX} tx
   */

  unlockTX(tx) {
    if (tx.isCoinbase())
      return;

    for (const input of tx.inputs)
      this.unlockCoin(input.prevout);
  }

  /**
   * Lock a single coin.
   * @param {Coin|Outpoint} coin
   */

  lockCoin(coin) {
    const key = coin.toKey();
    this.locked.add(key);
  }

  /**
   * Unlock a single coin.
   * @param {Coin|Outpoint} coin
   * @returns {Boolean} - whether the coin was locked.
   */

  unlockCoin(coin) {
    const key = coin.toKey();
    return this.locked.delete(key);
  }

  /**
   * Unlock all locked coins.
   */

  unlockCoins() {
    for (const coin of this.getLocked())
      this.unlockCoin(coin);
  }

  /**
   * Test locked status of a single coin.
   * @param {Coin|Outpoint} coin
   * @returns {Boolean}
   */

  isLocked(coin) {
    const key = coin.toKey();
    return this.locked.has(key);
  }

  /**
   * Filter array of coins or outpoints
   * for only unlocked ones.
   * @param {Coin[]|Outpoint[]}
   * @returns {Coin[]|Outpoint[]}
   */

  filterLocked(coins) {
    const out = [];

    for (const coin of coins) {
      if (!this.isLocked(coin))
        out.push(coin);
    }

    return out;
  }

  /**
   * Return an array of all locked outpoints.
   * @returns {Outpoint[]}
   */

  getLocked() {
    const outpoints = [];

    for (const key of this.locked.keys())
      outpoints.push(Outpoint.fromKey(key));

    return outpoints;
  }

  /**
   * Test whether an account owns a coin.
   * @param {Number} acct
   * @param {Hash} hash
   * @param {Index} number
   * @returns {Promise<Boolean>}
   */

  hasCoinByAccount(acct, hash, index) {
    assert(typeof acct === 'number');

    return this.bucket.has(layout.C.encode(acct, hash, index));
  }

  /**
   * Get hashes of all unconfirmed transactions in the database.
   * @param {Number} acct
   * @returns {Promise<Hash[]>}
   */

  getAccountPendingHashes(acct) {
    assert(typeof acct === 'number');
    return this.bucket.keys({
      gte: layout.P.min(acct),
      lte: layout.P.max(acct),
      parse: (key) => {
        const [, hash] = layout.P.decode(key);
        return hash;
      }
    });
  }

  /**
   * Get hashes of all unconfirmed transactions in the database.
   * @param {Number} acct
   * @returns {Promise<Hash[]>}
   */

  getPendingHashes(acct) {
    assert(typeof acct === 'number');

    if (acct !== -1)
      return this.getAccountPendingHashes(acct);

    return this.bucket.keys({
      gte: layout.p.min(),
      lte: layout.p.max(),
      parse: key => layout.p.decode(key)[0]
    });
  }

  /**
   * Test whether the database has a pending transaction.
   * @param {Hash} hash
   * @returns {Promise<Boolean>}
   */

  async hasPending(hash) {
    return this.bucket.has(layout.p.encode(hash));
  }

  /**
   * Get all coin hashes in the database.
   * @param {Number} acct
   * @returns {Promise<Outpoint[]>}
   */

  getAccountOutpoints(acct) {
    assert(typeof acct === 'number');
    return this.bucket.keys({
      gte: layout.C.min(acct),
      lte: layout.C.max(acct),
      parse: (key) => {
        const [, hash, index] = layout.C.decode(key);
        return new Outpoint(hash, index);
      }
    });
  }

  /**
   * Get all coin hashes in the database.
   * @param {Number} acct
   * @returns {Promise<Outpoint[]>}
   */

  getOutpoints(acct) {
    assert(typeof acct === 'number');

    if (acct !== -1)
      return this.getAccountOutpoints(acct);

    return this.bucket.keys({
      gte: layout.c.min(),
      lte: layout.c.max(),
      parse: (key) => {
        const [hash, index] = layout.c.decode(key);
        return new Outpoint(hash, index);
      }
    });
  }

  /**
   * Get TX hashes by height range.
   * @param {Number} acct
   * @param {Object} options
   * @param {Number} options.start - Start height.
   * @param {Number} options.end - End height.
   * @param {Number?} options.limit - Max number of records.
   * @param {Boolean?} options.reverse - Reverse order.
   * @returns {Promise<Hash[]>}
   */

  getAccountHeightRangeHashes(acct, options) {
    assert(typeof acct === 'number');

    const start = options.start || 0;
    const end = options.end || 0xffffffff;

    return this.bucket.keys({
      gte: layout.H.min(acct, start),
      lte: layout.H.max(acct, end),
      limit: options.limit,
      reverse: options.reverse,
      parse: (key) => {
        const [,, hash] = layout.H.decode(key);
        return hash;
      }
    });
  }

  /**
   * Get TX hashes by height range.
   * @param {Number} acct
   * @param {Object} options
   * @param {Number} options.start - Start height.
   * @param {Number} options.end - End height.
   * @param {Number?} options.limit - Max number of records.
   * @param {Boolean?} options.reverse - Reverse order.
   * @returns {Promise<Hash[]>}
   */

  getHeightRangeHashes(acct, options) {
    assert(typeof acct === 'number');

    if (acct !== -1)
      return this.getAccountHeightRangeHashes(acct, options);

    const start = options.start || 0;
    const end = options.end || 0xffffffff;

    return this.bucket.keys({
      gte: layout.h.min(start),
      lte: layout.h.max(end),
      limit: options.limit,
      reverse: options.reverse,
      parse: (key) => {
        const [, hash] = layout.h.decode(key);
        return hash;
      }
    });
  }

  /**
   * Get TX hashes by height.
   * @param {Number} height
   * @returns {Promise<Hash[]>}
   */

  getHeightHashes(height) {
    return this.getHeightRangeHashes({ start: height, end: height });
  }

  /**
   * Get unconfirmed transactions.
   * @param {Number} acct
   * @returns {Promise<TX[]>}
   */

  async getPending(acct) {
    const hashes = await this.getPendingHashes(acct);
    const txs = [];

    for (const hash of hashes) {
      const tx = await this.getTX(hash);
      assert(tx);
      txs.push(tx);
    }

    return txs;
  }

  /**
   * Get coins.
   * @param {Number} acct
   * @returns {Promise<Credit[]>}
   */

  getCredits(acct) {
    assert(typeof acct === 'number');

    // Slow case
    if (acct !== -1)
      return this.getAccountCredits(acct);

    // Fast case
    return this.bucket.range({
      gte: layout.c.min(),
      lte: layout.c.max(),
      parse: (key, value) => {
        const [hash, index] = layout.c.decode(key);
        const credit = Credit.decode(value);
        credit.coin.hash = hash;
        credit.coin.index = index;
        return credit;
      }
    });
  }

  /**
   * Get coins by account.
   * @param {Number} acct
   * @returns {Promise<Credit[]>}
   */

  async getAccountCredits(acct) {
    const outpoints = await this.getOutpoints(acct);
    const credits = [];

    for (const {hash, index} of outpoints) {
      const credit = await this.getCredit(hash, index);
      assert(credit);
      credits.push(credit);
    }

    return credits;
  }

  /**
   * Fill a transaction with coins (all historical coins).
   * @param {TX} tx
   * @returns {Promise<Array<Credit|null>>}
   */

  async getSpentCredits(tx) {
    if (tx.isCoinbase())
      return [];

    const hash = tx.hash();
    const credits = [];

    for (let i = 0; i < tx.inputs.length; i++)
      credits.push(null);

    await this.bucket.range({
      gte: layout.d.min(hash),
      lte: layout.d.max(hash),
      parse: (key, value) => {
        const [, index] = layout.d.decode(key);
        const coin = Coin.decode(value);
        const input = tx.inputs[index];
        assert(input);
        coin.hash = input.prevout.hash;
        coin.index = input.prevout.index;
        credits[index] = new Credit(coin);
      }
    });

    return credits;
  }

  /**
   * Get coins.
   * @param {Number} acct
   * @returns {Promise<Credit[]>}
   */

  async getCoins(acct) {
    const credits = await this.getCredits(acct);
    const coins = [];

    for (const credit of credits) {
      if (credit.spent)
        continue;

      coins.push(credit.coin);
    }

    return coins;
  }

  /**
   * Get coins by account.
   * @param {Number} acct
   * @returns {Promise<Coin[]>}
   */

  async getAccountCoins(acct) {
    const credits = await this.getAccountCredits(acct);
    const coins = [];

    for (const credit of credits) {
      if (credit.spent)
        continue;

      coins.push(credit.coin);
    }

    return coins;
  }

  /**
   * Get historical coins for a transaction.
   * @param {TX} tx
   * @returns {Promise<Coin[]>}
   */

  async getSpentCoins(tx) {
    if (tx.isCoinbase())
      return [];

    const credits = await this.getSpentCredits(tx);
    const coins = [];

    for (const credit of credits) {
      if (!credit) {
        coins.push(null);
        continue;
      }

      coins.push(credit.coin);
    }

    return coins;
  }

  /**
   * Get a coin viewpoint.
   * @param {TX} tx
   * @returns {Promise<CoinView>}
   */

  async getCoinView(tx) {
    const view = new CoinView();

    if (tx.isCoinbase())
      return view;

    for (const {prevout} of tx.inputs) {
      const {hash, index} = prevout;
      const coin = await this.getCoin(hash, index);

      if (!coin)
        continue;

      view.addCoin(coin);
    }

    return view;
  }

  /**
   * Get historical coin viewpoint.
   * @param {TX} tx
   * @returns {Promise<CoinView>}
   */

  async getSpentView(tx) {
    const view = new CoinView();

    if (tx.isCoinbase())
      return view;

    const coins = await this.getSpentCoins(tx);

    for (const coin of coins) {
      if (!coin)
        continue;

      view.addCoin(coin);
    }

    return view;
  }

  /**
   * Get transaction.
   * @param {Hash} hash
   * @returns {Promise<TXRecord?>}
   */

  async getTX(hash) {
    const raw = await this.bucket.get(layout.t.encode(hash));

    if (!raw)
      return null;

    return TXRecord.decode(raw);
  }

  /**
   * Get transaction details.
   * @param {Hash} hash
   * @returns {Promise<Details?>}
   */

  async getDetails(hash) {
    const wtx = await this.getTX(hash);

    if (!wtx)
      return null;

    return this.toDetails(wtx);
  }

  /**
   * Convert transaction to transaction details.
   * @param {TXRecord[]|TXRecord} wtxs
   * @returns {Promise<Details[]|Details>}
   */

  async toDetails(wtxs) {
    const out = [];

    if (!Array.isArray(wtxs))
      return this._toDetails(wtxs);

    for (const wtx of wtxs) {
      const details = await this._toDetails(wtx);

      if (!details)
        continue;

      out.push(details);
    }

    return out;
  }

  /**
   * Convert transaction to transaction details.
   * @private
   * @param {TXRecord} wtx
   * @returns {Promise<Details>}
   */

  async _toDetails(wtx) {
    const tx = wtx.tx;
    const block = wtx.getBlock();
    const details = new Details(wtx, block);
    const coins = await this.getSpentCoins(tx);

    for (let i = 0; i < tx.inputs.length; i++) {
      const coin = coins[i];

      let path = null;

      if (coin)
        path = await this.getPath(coin);

      details.setInput(i, path, coin);
    }

    for (let i = 0; i < tx.outputs.length; i++) {
      const output = tx.outputs[i];
      const path = await this.getPath(output);
      details.setOutput(i, path);
    }

    return details;
  }

  /**
   * Test whether the database has a transaction.
   * @param {Hash} hash
   * @returns {Promise<Boolean>}
   */

  hasTX(hash) {
    return this.bucket.has(layout.t.encode(hash));
  }

  /**
   * Get coin.
   * @param {Hash} hash
   * @param {Number} index
   * @returns {Promise<Coin?>}
   */

  async getCoin(hash, index) {
    const credit = await this.getCredit(hash, index);

    if (!credit)
      return null;

    return credit.coin;
  }

  /**
   * Get credit.
   * @param {Hash} hash
   * @param {Number} index
   * @returns {Promise<Credit?>}
   */

  async getCredit(hash, index) {
    const data = await this.bucket.get(layout.c.encode(hash, index));

    if (!data)
      return null;

    const credit = Credit.decode(data);
    credit.coin.hash = hash;
    credit.coin.index = index;

    return credit;
  }

  /**
   * Get spender coin.
   * @param {Outpoint} spent
   * @param {Outpoint} prevout
   * @returns {Promise<Coin?>}
   */

  async getSpentCoin(spent, prevout) {
    const key = layout.d.encode(spent.hash, spent.index);
    const data = await this.bucket.get(key);

    if (!data)
      return null;

    const coin = Coin.decode(data);
    coin.hash = prevout.hash;
    coin.index = prevout.index;

    return coin;
  }

  /**
   * Test whether the database has a spent coin.
   * @param {Outpoint} spent
   * @returns {Promise<Boolean>}
   */

  hasSpentCoin(spent) {
    return this.bucket.has(layout.d.encode(spent.hash, spent.index));
  }

  /**
   * Update spent coin height in storage.
   * @param {TX} tx - Sending transaction.
   * @param {Number} index
   * @param {Number} height
   * @returns {Promise}
   */

  async updateSpentCoin(b, tx, index, height) {
    const prevout = Outpoint.fromTX(tx, index);
    const spent = await this.getSpent(prevout.hash, prevout.index);

    if (!spent)
      return;

    const coin = await this.getSpentCoin(spent, prevout);

    if (!coin)
      return;

    coin.height = height;

    b.put(layout.d.encode(spent.hash, spent.index), coin.encode());
  }

  /**
   * Test whether the database has a transaction.
   * @param {Hash} hash
   * @returns {Promise<Boolean>}
   */

  async hasCoin(hash, index) {
    return this.bucket.has(layout.c.encode(hash, index));
  }

  /**
   * Calculate balance.
   * @param {Number?} account
   * @returns {Promise<Balance>}
   */

  async getBalance(acct) {
    assert(typeof acct === 'number');

    if (acct !== -1)
      return this.getAccountBalance(acct);

    return this.getWalletBalance();
  }

  /**
   * Calculate balance.
   * @returns {Promise<Balance>}
   */

  async getWalletBalance() {
    const data = await this.bucket.get(layout.R.encode());

    if (!data)
      return new Balance();

    return Balance.decode(data);
  }

  /**
   * Calculate balance by account.
   * @param {Number} acct
   * @returns {Promise<Balance>}
   */

  async getAccountBalance(acct) {
    const data = await this.bucket.get(layout.r.encode(acct));

    if (!data)
      return new Balance(acct);

    const balance = Balance.decode(data);
    balance.account = acct;
    return balance;
  }

  /**
   * Zap pending transactions older than `age`.
   * @param {Number} acct
   * @param {Number} age - Age delta.
   * @returns {Promise<Hash[]>} - zapped tx hashes.
   */

  async zap(acct, age) {
    assert((age >>> 0) === age);

    const now = this.nowFn();
    const options = {
      time: now - age,
      limit: Math.min(100, this.maxTXs),
      reverse: true
    };

    let txs = await this.listUnconfirmedByTime(acct, options);

    const hashes = [];

    while (txs.length) {
      for (const wtx of txs) {
        this.logger.debug('Zapping TX: %h (%d)',
                          wtx.hash, this.wid);

        await this.remove(wtx.hash);

        hashes.push(wtx.hash);
      }

      txs = await this.listUnconfirmedByTime(acct, options);
    }

    return hashes;
  }

  /**
   * Abandon transaction.
   * @param {Hash} hash
   * @returns {Promise<Details>} - removed tx details.
   */

  async abandon(hash) {
    const result = await this.bucket.has(layout.p.encode(hash));

    if (!result)
      throw new Error('TX not eligible.');

    return this.remove(hash);
  }

  /**
   * Dump database (for debugging).
   * @returns {bdb.Iterator}
   */

  async dump() {
    const iter = this.bucket.iterator({
      values: true
    });

    const records = Object.create(null);

    for await (const {key, value} of iter)
      records[key.toString('hex')] = value.toString('hex');

    return records;
  }
}

/**
 * Balance
 * @alias module:wallet.Balance
 */

class Balance extends bio.Struct {
  /**
   * Create a balance.
   * @constructor
   * @param {Number} account
   */

  constructor(acct = -1) {
    super();

    assert(typeof acct === 'number');

    this.account = acct;
    this.tx = 0;
    this.coin = 0;
    this.unconfirmed = 0;
    this.confirmed = 0;
    this.ulocked = 0;
    this.clocked = 0;
  }

  /**
   * Apply delta.
   * @param {Balance} balance
   */

  applyTo(balance) {
    balance.tx += this.tx;
    balance.coin += this.coin;
    balance.unconfirmed += this.unconfirmed;
    balance.confirmed += this.confirmed;
    balance.ulocked += this.ulocked;
    balance.clocked += this.clocked;

    assert(balance.tx >= 0);
    assert(balance.coin >= 0);
    assert(balance.unconfirmed >= 0);
    assert(balance.confirmed >= 0);
    assert(balance.ulocked >= 0);
    assert(balance.clocked >= 0);
  }

  /**
   * Calculate size.
   * @returns {Number}
   */

  getSize() {
    return 48;
  }

  /**
   * Serialize balance.
   * @returns {Buffer}
   */

  write(bw) {
    bw.writeU64(this.tx);
    bw.writeU64(this.coin);
    bw.writeU64(this.unconfirmed);
    bw.writeU64(this.confirmed);
    bw.writeU64(this.ulocked);
    bw.writeU64(this.clocked);
    return bw;
  }

  /**
   * Inject properties from serialized data.
   * @private
   * @param {Buffer} data
   * @returns {Balance}
   */

  read(br) {
    this.tx = br.readU64();
    this.coin = br.readU64();
    this.unconfirmed = br.readU64();
    this.confirmed = br.readU64();
    this.ulocked = br.readU64();
    this.clocked = br.readU64();
    return this;
  }

  /**
   * Convert balance to a more json-friendly object.
   * @param {Boolean} [minimal=false]
   * @returns {Object}
   */

  getJSON(minimal) {
    return {
      account: !minimal ? this.account : undefined,
      tx: this.tx,
      coin: this.coin,
      unconfirmed: this.unconfirmed,
      confirmed: this.confirmed,
      lockedUnconfirmed: this.ulocked,
      lockedConfirmed: this.clocked
    };
  }

  /**
   * Inspect balance.
   * @param {String}
   */

  format() {
    return '<Balance'
      + ` tx=${this.tx}`
      + ` coin=${this.coin}`
      + ` unconfirmed=${Amount.coin(this.unconfirmed)}`
      + ` confirmed=${Amount.coin(this.confirmed)}`
      + ` lockedUnconfirmed=${Amount.coin(this.ulocked)}`
      + ` lockedConfirmed=${Amount.coin(this.clocked)}`
      + '>';
  }
}

/**
 * Balance Delta
 * @ignore
 */

class BalanceDelta {
  /** @type {Balance} */
  wallet;

  /** @type {Map<Number, Balance>} */
  accounts;

  /**
   * Create a balance delta.
   * @constructor
   */

  constructor() {
    this.wallet = new Balance();
    this.accounts = new Map();
  }

  updated() {
    return this.wallet.tx !== 0;
  }

  applyTo(balance) {
    this.wallet.applyTo(balance);
  }

  get(path) {
    if (!this.accounts.has(path.account))
      this.accounts.set(path.account, new Balance());

    return this.accounts.get(path.account);
  }

  tx(path, value) {
    const account = this.get(path);
    account.tx = value;
    this.wallet.tx = value;
  }

  coin(path, value) {
    const account = this.get(path);
    account.coin += value;
    this.wallet.coin += value;
  }

  unconfirmed(path, value) {
    const account = this.get(path);
    account.unconfirmed += value;
    this.wallet.unconfirmed += value;
  }

  confirmed(path, value) {
    const account = this.get(path);
    account.confirmed += value;
    this.wallet.confirmed += value;
  }

  ulocked(path, value) {
    const account = this.get(path);
    account.ulocked += value;
    this.wallet.ulocked += value;
  }

  clocked(path, value) {
    const account = this.get(path);
    account.clocked += value;
    this.wallet.clocked += value;
  }
}

/**
 * Credit (wrapped coin)
 * @alias module:wallet.Credit
 * @property {Coin} coin
 * @property {Boolean} spent
 */

class Credit extends bio.Struct {
  /**
   * Create a credit.
   * @constructor
   * @param {Coin} coin
   * @param {Boolean?} spent
   */

  constructor(coin, spent) {
    super();
    this.coin = coin || new Coin();
    this.spent = spent || false;
    this.own = false;
  }

  /**
   * Inject properties from serialized data.
   * @private
   * @param {Buffer} data
   */

  read(br) {
    this.coin.read(br);
    this.spent = br.readU8() === 1;
    this.own = br.readU8() === 1;
    return this;
  }

  /**
   * Get serialization size.
   * @returns {Number}
   */

  getSize() {
    return this.coin.getSize() + 2;
  }

  /**
   * Serialize credit.
   * @returns {Buffer}
   */

  write(bw) {
    this.coin.write(bw);
    bw.writeU8(this.spent ? 1 : 0);
    bw.writeU8(this.own ? 1 : 0);
    return bw;
  }

  /**
   * Inject properties from tx object.
   * @private
   * @param {TX} tx
   * @param {Number} index
   * @returns {Credit}
   */

  fromTX(tx, index, height) {
    this.coin.fromTX(tx, index, height);
    this.spent = false;
    this.own = false;
    return this;
  }

  /**
   * Instantiate credit from transaction.
   * @param {TX} tx
   * @param {Number} index
   * @returns {Credit}
   */

  static fromTX(tx, index, height) {
    return new this().fromTX(tx, index, height);
  }
}

/**
 * Transaction Details
 * @alias module:wallet.Details
 */

class Details {
  /**
   * Create transaction details.
   * @constructor
   * @param {TXRecord} wtx
   * @param {BlockMeta} block
   */

  constructor(wtx, block) {
    this.hash = wtx.hash;
    this.tx = wtx.tx;
    this.mtime = wtx.mtime;
    this.size = this.tx.getSize();
    this.vsize = this.tx.getVirtualSize();

    this.block = null;
    this.height = -1;
    this.time = 0;

    if (block) {
      this.block = block.hash;
      this.height = block.height;
      this.time = block.time;
    }

    this.inputs = [];
    this.outputs = [];

    this.init();
  }

  /**
   * Initialize transaction details.
   * @private
   */

  init() {
    for (const input of this.tx.inputs) {
      const member = new DetailsMember();
      member.address = input.getAddress();
      this.inputs.push(member);
    }

    for (const output of this.tx.outputs) {
      const member = new DetailsMember();
      member.value = output.value;
      member.address = output.getAddress();
      member.covenant = output.covenant;
      this.outputs.push(member);
    }
  }

  /**
   * Add necessary info to input member.
   * @param {Number} i
   * @param {Path} path
   * @param {Coin} coin
   */

  setInput(i, path, coin) {
    const member = this.inputs[i];

    if (coin) {
      member.value = coin.value;
      member.address = coin.getAddress();
    }

    if (path)
      member.path = path;
  }

  /**
   * Add necessary info to output member.
   * @param {Number} i
   * @param {Path} path
   */

  setOutput(i, path) {
    const member = this.outputs[i];

    if (path)
      member.path = path;
  }

  /**
   * Calculate confirmations.
   * @returns {Number}
   */

  getDepth(height) {
    if (this.height === -1)
      return 0;

    if (height == null)
      return 0;

    const depth = height - this.height;

    if (depth < 0)
      return 0;

    return depth + 1;
  }

  /**
   * Calculate fee. Only works if wallet
   * owns all inputs. Returns 0 otherwise.
   * @returns {Amount}
   */

  getFee() {
    let inputValue = 0;
    let outputValue = 0;

    for (const input of this.inputs) {
      if (!input.path)
        return 0;

      inputValue += input.value;
    }

    for (const output of this.outputs)
      outputValue += output.value;

    return inputValue - outputValue;
  }

  /**
   * Calculate fee rate. Only works if wallet
   * owns all inputs. Returns 0 otherwise.
   * @param {Amount} fee
   * @returns {Rate}
   */

  getRate(fee) {
    return policy.getRate(this.vsize, fee);
  }

  /**
   * Convert details to a more json-friendly object.
   * @returns {Object}
   */

  getJSON(network, height) {
    const fee = this.getFee();
    const rate = this.getRate(fee);

    return {
      hash: this.hash.toString('hex'),
      height: this.height,
      block: this.block ? this.block.toString('hex') : null,
      time: this.time,
      mtime: this.mtime,
      date: util.date(this.time),
      mdate: util.date(this.mtime),
      size: this.size,
      virtualSize: this.vsize,
      fee: fee,
      rate: rate,
      confirmations: this.getDepth(height),
      inputs: this.inputs.map((input) => {
        return input.getJSON(network);
      }),
      outputs: this.outputs.map((output) => {
        return output.getJSON(network);
      }),
      tx: this.tx.toHex()
    };
  }

  /**
   * Convert details to a more json-friendly object.
   * @returns {Object}
   */

  toJSON() {
    return this.getJSON();
  }
}

/**
 * Transaction Details Member
 * @property {Number} value
 * @property {Address} address
 * @property {Path} path
 */

class DetailsMember {
  /**
   * Create details member.
   * @constructor
   */

  constructor() {
    this.value = 0;
    this.address = null;
    this.covenant = null;
    this.path = null;
  }

  /**
   * Convert the member to a more json-friendly object.
   * @returns {Object}
   */

  toJSON() {
    return this.getJSON();
  }

  /**
   * Convert the member to a more json-friendly object.
   * @param {Network} network
   * @returns {Object}
   */

  getJSON(network) {
    return {
      value: this.value,
      address: this.address
        ? this.address.toString(network)
        : null,
      covenant: this.covenant
        ? this.covenant.toJSON()
        : undefined,
      path: this.path
        ? this.path.toJSON()
        : null
    };
  }
}

/**
 * Block Record
 * @alias module:wallet.BlockRecord
 */

class BlockRecord extends bio.Struct {
  /**
   * Create a block record.
   * @constructor
   * @param {Hash} hash
   * @param {Number} height
   * @param {Number} time
   */

  constructor(hash, height, time) {
    super();
    this.hash = hash || consensus.ZERO_HASH;
    this.height = height != null ? height : -1;
    this.time = time || 0;
    this.hashes = new BufferSet();
  }

  /**
   * Add transaction to block record.
   * @param {Hash} hash
   * @returns {Boolean}
   */

  add(hash) {
    if (this.hashes.has(hash))
      return false;

    this.hashes.add(hash);

    return true;
  }

  /**
   * Remove transaction from block record.
   * @param {Hash} hash
   * @returns {Boolean}
   */

  remove(hash) {
    return this.hashes.delete(hash);
  }

  /**
   * Instantiate wallet block from serialized tip data.
   * @private
   * @param {bio.BufferReader} br
   */

  read(br) {
    this.hash = br.readHash();
    this.height = br.readU32();
    this.time = br.readU32();

    const count = br.readU32();

    for (let i = 0; i < count; i++) {
      const hash = br.readHash();
      this.hashes.add(hash);
    }

    return this;
  }

  /**
   * Get serialization size.
   * @returns {Number}
   */

  getSize() {
    return 44 + this.hashes.size * 32;
  }

  /**
   * Serialize the wallet block as a tip (hash and height).
   * @returns {Buffer}
   */

  write(bw) {
    bw.writeHash(this.hash);
    bw.writeU32(this.height);
    bw.writeU32(this.time);

    bw.writeU32(this.hashes.size);

    for (const hash of this.hashes)
      bw.writeHash(hash);

    return bw;
  }

  /**
   * Convert hashes set to an array.
   * @returns {Hash[]}
   */

  toArray() {
    return this.hashes.toArray();
  }

  /**
   * Convert the block to a more json-friendly object.
   * @returns {Object}
   */

  getJSON() {
    return {
      hash: this.hash.toString('hex'),
      height: this.height,
      time: this.time,
      hashes: this.toArray().map(h => h.toString('hex'))
    };
  }

  /**
   * Instantiate wallet block from block meta.
   * @private
   * @param {BlockMeta} block
   */

  fromMeta(block) {
    this.hash = block.hash;
    this.height = block.height;
    this.time = block.time;
    return this;
  }

  /**
   * Instantiate wallet block from block meta.
   * @param {BlockMeta} block
   * @returns {BlockRecord}
   */

  static fromMeta(block) {
    return new this().fromMeta(block);
  }
}

/**
 * Blind Bid
 */

class BlindBid extends bio.Struct {
  constructor() {
    super();
    this.name = EMPTY;
    this.nameHash = consensus.ZERO_HASH;
    this.prevout = new Outpoint();
    this.value = -1;
    this.lockup = 0;
    this.blind = consensus.ZERO_HASH;
    this.height = -1;
    this.own = false;
  }

  getSize() {
    return 1 + this.name.length + 45;
  }

  write(bw) {
    let height = this.height;

    if (height === -1)
      height = 0xffffffff;

    bw.writeU8(this.name.length);
    bw.writeBytes(this.name);
    bw.writeU64(this.lockup);
    bw.writeBytes(this.blind);
    bw.writeU32(height);
    bw.writeU8(this.own ? 1 : 0);
    return bw;
  }

  read(br) {
    this.name = br.readBytes(br.readU8());
    this.lockup = br.readU64();
    this.blind = br.readBytes(32);
    this.height = br.readU32();
    this.own = br.readU8() === 1;

    if (this.height === 0xffffffff)
      this.height = -1;

    return this;
  }

  getJSON() {
    return {
      name: this.name.toString('ascii'),
      nameHash: this.nameHash.toString('hex'),
      prevout: this.prevout.toJSON(),
      value: this.value === -1 ? undefined : this.value,
      lockup: this.lockup,
      blind: this.blind.toString('hex'),
      height: this.height,
      own: this.own
    };
  }
}

/**
 * Blind Value
 */

class BlindValue extends bio.Struct {
  constructor() {
    super();
    this.value = 0;
    this.nonce = consensus.ZERO_HASH;
  }

  getSize() {
    return 40;
  }

  write(bw) {
    bw.writeU64(this.value);
    bw.writeBytes(this.nonce);
    return bw;
  }

  read(br) {
    this.value = br.readU64();
    this.nonce = br.readBytes(32);
    return this;
  }

  getJSON() {
    return {
      value: this.value,
      nonce: this.nonce.toString('hex')
    };
  }
}

/**
 * Bid Reveal
 */

class BidReveal extends bio.Struct {
  constructor() {
    super();
    this.name = EMPTY;
    this.nameHash = consensus.ZERO_HASH;
    this.prevout = new Outpoint();
    this.bidPrevout = new Outpoint();
    this.value = 0;
    this.height = -1;
    this.own = false;
  }

  getSize() {
    return 1 + this.name.length + 13 + 36;
  }

  write(bw) {
    let height = this.height;

    if (height === -1)
      height = 0xffffffff;

    bw.writeU8(this.name.length);
    bw.writeBytes(this.name);
    bw.writeU64(this.value);
    bw.writeU32(height);
    bw.writeU8(this.own ? 1 : 0);
    this.bidPrevout.write(bw);

    return bw;
  }

  read(br) {
    this.name = br.readBytes(br.readU8());
    this.value = br.readU64();
    this.height = br.readU32();
    this.own = br.readU8() === 1;
    this.bidPrevout.read(br);

    if (this.height === 0xffffffff)
      this.height = -1;

    return this;
  }

  getJSON() {
    return {
      name: this.name.toString('ascii'),
      nameHash: this.nameHash.toString('hex'),
      prevout: this.prevout.toJSON(),
      bidPrevout: this.bidPrevout.isNull() ? null : this.bidPrevout.toJSON(),
      value: this.value,
      height: this.height,
      own: this.own
    };
  }
}

/**
 * TX Count
 *
 * This is used for tracking the block height and transaction
 * index for the wallet. This is used as entry point into
 * indexes that are organized by count.
 */

class TXCount {
  /**
   * Create tx count record.
   * @constructor
   * @param {Number} height
   * @param {Number} index
   */

  constructor(height, index) {
    this.height = height;
    this.index = index;
  }

  /**
   * Serialize.
   * @returns {Buffer}
   */

  encode() {
    const bw = bio.write(8);

    bw.writeU32(this.height);
    bw.writeU32(this.index);

    return bw.render();
  }

  /**
   * Deserialize.
   * @private
   * @param {Buffer} data
   */

  decode(data) {
    const br = bio.read(data);

    this.height = br.readU32();
    this.index = br.readU32();

    return this;
  }

  /**
   * Instantiate a tx count from a buffer.
   * @param {Buffer} data
   * @returns {TXCount}
   */

  static decode(data) {
    return new this().decode(data);
  }
}

/**
 * @param {Number} num
 * @returns {Buffer}
 */

function fromU32(num) {
  const data = Buffer.allocUnsafe(4);
  data.writeUInt32LE(num, 0, true);
  return data;
}

/*
 * Expose
 */

TXDB.Balance = Balance;
TXDB.BalanceDelta = BalanceDelta;
TXDB.Credit = Credit;
TXDB.Details = Details;
TXDB.DetailsMember = DetailsMember;
TXDB.BlockRecord = BlockRecord;
TXDB.BlindBid = BlindBid;
TXDB.BlindValue = BlindValue;
TXDB.BidReveal = BidReveal;
TXDB.TXCount = TXCount;

module.exports = TXDB;

handshake-org / hsd / 11895505322

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous