[NOD-827] Get rid of dbtools insecureimport.go and loadheaders.go (#655 )

* [NOD-827] Get rid of dbtools insecureimport.go and loadheaders.go * [NOD-827] Remove commands from realMain().
[NOD-816] Remove TxIndex and AddrIndex (#653 )
2026-03-22 16:13:45 +00:00 · 2020-03-10 16:31:13 +02:00 · 2020-03-10 16:09:31 +02:00 · 2020-03-10 15:32:19 +02:00 · 2020-03-10 11:09:33 +02:00 · 2020-03-08 11:24:37 +02:00
489 changed files with 8008 additions and 31078 deletions
--- a/955
+++ b/955
@@ -1,955 +0,0 @@
-============================================================================
-User visible changes for btcd
-  A full-node bitcoin implementation written in Go
-============================================================================
-
-Changes in 0.12.0 (Fri Nov 20 2015)
-  - Protocol and network related changes:
-    - Add a new checkpoint at block height 382320 (#555)
-    - Implement BIP0065 which includes support for version 4 blocks, a new
-      consensus opcode (OP_CHECKLOCKTIMEVERIFY) that enforces transaction
-      lock times, and a double-threshold switchover mechanism (#535, #459,
-      #455)
-    - Implement BIP0111 which provides a new bloom filter service flag and
-      hence provides support for protocol version 70011 (#499)
-    - Add a new parameter --nopeerbloomfilters to allow disabling bloom
-      filter support (#499)
-    - Reject non-canonically encoded variable length integers (#507)
-    - Add mainnet peer discovery DNS seed (seed.bitcoin.jonasschnelli.ch)
-      (#496)
-    - Correct reconnect handling for persistent peers (#463, #464)
-    - Ignore requests for block headers if not fully synced (#444)
-    - Add CLI support for specifying the zone id on IPv6 addresses (#538)
-    - Fix a couple of issues where the initial block sync could stall (#518,
-      #229, #486)
-    - Fix an issue which prevented the --onion option from working as
-      intended (#446)
-  - Transaction relay (memory pool) changes:
-    - Require transactions to only include signatures encoded with the
-    canonical 'low-s' encoding (#512)
-    - Add a new parameter --minrelaytxfee to allow the minimum transaction
-      fee in BTC/kB to be overridden (#520)
-    - Retain memory pool transactions when they redeem another one that is
-      removed when a block is accepted (#539)
-    - Do not send reject messages for a transaction if it is valid but
-      causes an orphan transaction which depends on it to be determined
-      as invalid (#546)
-    - Refrain from attempting to add orphans to the memory pool multiple
-      times when the transaction they redeem is added (#551)
-    - Modify minimum transaction fee calculations to scale based on bytes
-      instead of full kilobyte boundaries (#521, #537)
-  - Implement signature cache:
-    - Provides a limited memory cache of validated signatures which is a
-      huge optimization when verifying blocks for transactions that are
-      already in the memory pool (#506)
-    - Add a new parameter '--sigcachemaxsize' which allows the size of the
-      new cache to be manually changed if desired (#506)
-  - Mining support changes:
-    - Notify getblocktemplate long polling clients when a block is pushed
-      via submitblock (#488)
-    - Speed up getblocktemplate by making use of the new signature cache
-      (#506)
-  - RPC changes:
-    - Implement getmempoolinfo command (#453)
-    - Implement getblockheader command (#461)
-    - Modify createrawtransaction command to accept a new optional parameter
-      'locktime' (#529)
-    - Modify listunspent result to include the 'spendable' field (#440)
-    - Modify getinfo command to include 'errors' field (#511)
-    - Add timestamps to blockconnected and blockdisconnected notifications
-      (#450)
-    - Several modifications to searchrawtranscations command:
-      - Accept a new optional parameter 'vinextra' which causes the results
-        to include information about the outputs referenced by a transaction's
-        inputs (#485, #487)
-      - Skip entries in the mempool too (#495)
-      - Accept a new optional parameter 'reverse' to return the results in
-        reverse order (most recent to oldest) (#497)
-      - Accept a new optional parameter 'filteraddrs' which causes the
-        results to only include inputs and outputs which involve the
-        provided addresses (#516)
-    - Change the notification order to notify clients about mined
-      transactions (recvtx, redeemingtx) before the blockconnected
-      notification (#449)
-    - Update verifymessage RPC to use the standard algorithm so it is
-      compatible with other implementations (#515)
-    - Improve ping statistics by pinging on an interval (#517)
-  - Websocket changes:
-    - Implement session command which returns a per-session unique id (#500,
-      #503)
-  - btcctl utility changes:
-    - Add getmempoolinfo command (#453)
-    - Add getblockheader command (#461)
-    - Add getwalletinfo command (#471)
-  - Notable developer-related package changes:
-    - Introduce a new peer package which acts a common base for creating and
-      concurrently managing bitcoin network peers (#445)
-    - Various cleanup of the new peer package (#528, #531, #524, #534,
-      #549)
-    - Blocks heights now consistently use int32 everywhere (#481)
-    - The BlockHeader type in the wire package now provides the BtcDecode
-      and BtcEncode methods (#467)
-    - Update wire package to recognize BIP0064 (getutxo) service bit (#489)
-    - Export LockTimeThreshold constant from txscript package (#454)
-    - Export MaxDataCarrierSize constant from txscript package (#466)
-    - Provide new IsUnspendable function from the txscript package (#478)
-    - Export variable length string functions from the wire package (#514)
-    - Export DNS Seeds for each network from the chaincfg package (#544)
-    - Preliminary work towards separating the memory pool into a separate
-      package (#525, #548)
-  - Misc changes:
-    - Various documentation updates (#442, #462, #465, #460, #470, #473,
-      #505, #530, #545)
-    - Add installation instructions for gentoo (#542)
-    - Ensure an error is shown if OS limits can't be set at startup (#498)
-    - Tighten the standardness checks for multisig scripts (#526)
-    - Test coverage improvement (#468, #494, #527, #543, #550)
-    - Several optimizations (#457, #474, #475, #476, #508, #509)
-    - Minor code cleanup and refactoring (#472, #479, #482, #519, #540)
-  - Contributors (alphabetical order):
-    - Ben Echols
-    - Bruno Clermont
-    - danda
-    - Daniel Krawisz
-    - Dario Nieuwenhuis
-    - Dave Collins
-    - David Hill
-    - Javed Khan
-    - Jonathan Gillham
-    - Joseph Becher
-    - Josh Rickmar
-    - Justus Ranvier
-    - Mawuli Adzoe
-    - Olaoluwa Osuntokun
-    - Rune T. Aune
-
-Changes in 0.11.1 (Wed May 27 2015)
-  - Protocol and network related changes:
-    - Use correct sub-command in reject message for rejected transactions
-      (#436, #437)
-    - Add a new parameter --torisolation which forces new circuits for each
-      connection when using tor (#430)
-  - Transaction relay (memory pool) changes:
-    - Reduce the default number max number of allowed orphan transactions
-      to 1000 (#419)
-    - Add a new parameter --maxorphantx which allows the maximum number of
-      orphan transactions stored in the mempool to be specified (#419)
-  - RPC changes:
-    - Modify listtransactions result to include the 'involveswatchonly' and
-      'vout' fields (#427)
-    - Update getrawtransaction result to omit the 'confirmations' field
-      when it is 0 (#420, #422)
-    - Update signrawtransaction result to include errors (#423)
-  - btcctl utility changes:
-    - Add gettxoutproof command (#428)
-    - Add verifytxoutproof command (#428)
-  - Notable developer-related package changes:
-    - The btcec package now provides the ability to perform ECDH
-      encryption and decryption (#375)
-    - The block and header validation in the blockchain package has been
-      split to help pave the way toward concurrent downloads (#386)
-  - Misc changes:
-    - Minor peer optimization (#433)
-  - Contributors (alphabetical order):
-    - Dave Collins
-    - David Hill
-    - Federico Bond
-    - Ishbir Singh
-    - Josh Rickmar
-
-Changes in 0.11.0 (Wed May 06 2015)
-  - Protocol and network related changes:
-    - **IMPORTANT: Update is required due to the following point**
-    - Correct a few corner cases in script handling which could result in
-      forking from the network on non-standard transactions (#425)
-    - Add a new checkpoint at block height 352940 (#418)
-    - Optimized script execution (#395, #400, #404, #409)
-    - Fix a case that could lead stalled syncs (#138, #296)
-  - Network address manager changes:
-    - Implement eclipse attack countermeasures as proposed in
-      http://cs-people.bu.edu/heilman/eclipse (#370, #373)
-  - Optional address indexing changes:
-    - Fix an issue where a reorg could cause an orderly shutdown when the
-      address index is active (#340, #357)
-  - Transaction relay (memory pool) changes:
-    - Increase maximum allowed space for nulldata transactions to 80 bytes
-      (#331)
-    - Implement support for the following rules specified by BIP0062:
-      - The S value in ECDSA signature must be at most half the curve order
-        (rule 5) (#349)
-      - Script execution must result in a single non-zero value on the stack
-        (rule 6) (#347)
-      - NOTE: All 7 rules of BIP0062 are now implemented
-    - Use network adjusted time in finalized transaction checks to improve
-      consistency across nodes (#332)
-    - Process orphan transactions on acceptance of new transactions (#345)
-  - RPC changes:
-    - Add support for a limited RPC user which is not allowed admin level
-      operations on the server (#363)
-    - Implement node command for more unified control over connected peers
-      (#79, #341)
-    - Implement generate command for regtest/simnet to support
-      deterministically mining a specified number of blocks (#362, #407)
-    - Update searchrawtransactions to return the matching transactions in
-      order (#354)
-    - Correct an issue with searchrawtransactions where it could return
-      duplicates (#346, #354)
-    - Increase precision of 'difficulty' field in getblock result to 8
-      (#414, #415)
-    - Omit 'nextblockhash' field from getblock result when it is empty
-      (#416, #417)
-    - Add 'id' and 'timeoffset' fields to getpeerinfo result (#335)
-  - Websocket changes:
-    - Implement new commands stopnotifyspent, stopnotifyreceived,
-      stopnotifyblocks, and stopnotifynewtransactions to allow clients to
-      cancel notification registrations (#122, #342)
-  - btcctl utility changes:
-    - A single dash can now be used as an argument to cause that argument to
-      be read from stdin (#348)
-    - Add generate command
-  - Notable developer-related package changes:
-    - The new version 2 btcjson package has now replaced the deprecated
-      version 1 package (#368)
-    - The btcec package now performs all signing using RFC6979 deterministic
-      signatures (#358, #360)
-    - The txscript package has been significantly cleaned up and had a few
-      API changes (#387, #388, #389, #390, #391, #392, #393, #395, #396,
-      #400, #403, #404, #405, #406, #408, #409, #410, #412)
-    - A new PkScriptLocs function has been added to the wire package MsgTx
-      type which provides callers that deal with scripts optimization
-      opportunities (#343)
-  - Misc changes:
-    - Minor wire hashing optimizations (#366, #367)
-    - Other minor internal optimizations
-  - Contributors (alphabetical order):
-    - Alex Akselrod
-    - Arne Brutschy
-    - Chris Jepson
-    - Daniel Krawisz
-    - Dave Collins
-    - David Hill
-    - Jimmy Song
-    - Jonas Nick
-    - Josh Rickmar
-    - Olaoluwa Osuntokun
-    - Oleg Andreev
-
-Changes in 0.10.0 (Sun Mar 01 2015)
-  - Protocol and network related changes:
-    - Add a new checkpoint at block height 343185
-    - Implement BIP066 which includes support for version 3 blocks, a new
-      consensus rule which prevents non-DER encoded signatures, and a
-      double-threshold switchover mechanism
-    - Rather than announcing all known addresses on getaddr requests which
-      can possibly result in multiple messages, randomize the results and
-      limit them to the max allowed by a single message (1000 addresses)
-    - Add more reserved IP spaces to the address manager
-  - Transaction relay (memory pool) changes:
-    - Make transactions which contain reserved opcodes nonstandard
-    - No longer accept or relay free and low-fee transactions that have
-      insufficient priority to be mined in the next block
-    - Implement support for the following rules specified by BIP0062:
-      - ECDSA signature must use strict DER encoding (rule 1)
-      - The signature script must only contain push operations (rule 2)
-      - All push operations must use the smallest possible encoding (rule 3)
-      - All stack values interpreted as a number must be encoding using the
-        shortest possible form (rule 4)
-      - NOTE: Rule 1 was already enforced, however the entire script now
-        evaluates to false rather than only the signature verification as
-        required by BIP0062
-    - Allow transactions with nulldata transaction outputs to be treated as
-      standard
-  - Mining support changes:
-    - Modify the getblocktemplate RPC to generate and return block templates
-      for version 3 blocks which are compatible with BIP0066
-    - Allow getblocktemplate to serve blocks when the current time is
-      less than the minimum allowed time for a generated block template
-      (https://github.com/btcsuite/btcd/issues/209)
-  - Crypto changes:
-    - Optimize scalar multiplication by the base point by using a
-      pre-computed table which results in approximately a 35% speedup
-     (https://github.com/btcsuite/btcec/issues/2)
-    - Optimize general scalar multiplication by using the secp256k1
-      endomorphism which results in approximately a 17-20% speedup
-     (https://github.com/btcsuite/btcec/issues/1)
-    - Optimize general scalar multiplication by using non-adjacent form
-      which results in approximately an additional 8% speedup
-     (https://github.com/btcsuite/btcec/issues/3)
-  - Implement optional address indexing:
-    - Add a new parameter --addrindex which will enable the creation of an
-      address index which can be queried to determine all transactions which
-      involve a given address
-      (https://github.com/btcsuite/btcd/issues/190)
-    - Add a new logging subsystem for address index related operations
-    - Support new searchrawtransactions RPC
-      (https://github.com/btcsuite/btcd/issues/185)
-  - RPC changes:
-    - Require TLS version 1.2 as the minimum version for all TLS connections
-    - Provide support for disabling TLS when only listening on localhost
-      (https://github.com/btcsuite/btcd/pull/192)
-    - Modify help output for all commands to provide much more consistent
-      and detailed information
-    - Correct case in getrawtransaction which would refuse to serve certain
-      transactions with invalid scripts
-      (https://github.com/btcsuite/btcd/issues/210)
-    - Correct error handling in the getrawtransaction RPC which could lead
-      to a crash in rare cases
-      (https://github.com/btcsuite/btcd/issues/196)
-    - Update getinfo RPC to include the appropriate 'timeoffset' calculated
-      from the median network time
-    - Modify listreceivedbyaddress result type to include txids field so it
-      is compatible
-    - Add 'iswatchonly' field to validateaddress result
-    - Add 'startingpriority' and 'currentpriority' fields to getrawmempool
-      (https://github.com/btcsuite/btcd/issues/178)
-    - Don't omit the 'confirmations' field from getrawtransaction when it is
-      zero
-  - Websocket changes:
-    - Modify the behavior of the rescan command to automatically register
-      for notifications about transactions paying to rescanned addresses
-      or spending outputs from the final rescan utxo set when the rescan
-      is through the best block in the chain
-  - btcctl utility changes:
-    - Make the list of commands available via the -l option rather than
-      dumping the entire list on usage errors
-    - Alphabetize and categorize the list of commands by chain and wallet
-    - Make the help option only show the help options instead of also
-      dumping all of the commands
-    - Make the usage syntax much more consistent and correct a few cases of
-      misnamed fields
-      (https://github.com/btcsuite/btcd/issues/305)
-    - Improve usage errors to show the specific parameter number, reason,
-      and error code
-    - Only show the usage for specific command is shown when a valid command
-      is provided with invalid parameters
-    - Add support for a SOCK5 proxy
-    - Modify output for integer fields (such as timestamps) to display
-      normally instead in scientific notation
-    - Add invalidateblock command
-    - Add reconsiderblock command
-    - Add createnewaccount command
-    - Add renameaccount command
-    - Add searchrawtransactions command
-    - Add importaddress command
-    - Add importpubkey command
-  - showblock utility changes:
-    - Remove utility in favor of the RPC getblock method
-  - Notable developer-related package changes:
-    - Many of the core packages have been relocated into the btcd repository
-      (https://github.com/btcsuite/btcd/issues/214)
-    - A new version of the btcjson package that has been completely
-      redesigned from the ground up based based upon how the project has
-      evolved and lessons learned while using it since it was first written
-      is now available in the btcjson/v2/btcjson directory
-      - This will ultimately replace the current version so anyone making
-        use of this package will need to update their code accordingly
-    - The btcec package now provides better facilities for working directly
-      with its public and private keys without having to mix elements from
-      the ecdsa package
-    - Update the script builder to ensure all rules specified by BIP0062 are
-      adhered to when creating scripts
-    - The blockchain package now provides a MedianTimeSource interface and
-      concrete implementation for providing time samples from remote peers
-      and using that data to calculate an offset against the local time
-  - Misc changes:
-    - Fix a slow memory leak due to tickers not being stopped
-      (https://github.com/btcsuite/btcd/issues/189)
-    - Fix an issue where a mix of orphans and SPV clients could trigger a
-      condition where peers would no longer be served
-      (https://github.com/btcsuite/btcd/issues/231)
-    - The RPC username and password can now contain symbols which previously
-      conflicted with special symbols used in URLs
-    - Improve handling of obtaining random nonces to prevent cases where it
-      could error when not enough entropy was available
-    - Improve handling of home directory creation errors such as in the case
-      of unmounted symlinks (https://github.com/btcsuite/btcd/issues/193)
-    - Improve the error reporting for rejected transactions to include the
-      inputs which are missing and/or being double spent
-    - Update sample config file with new options and correct a comment
-      regarding the fact the RPC server only listens on localhost by default
-      (https://github.com/btcsuite/btcd/issues/218)
-    - Update the continuous integration builds to run several tools which
-      help keep code quality high
-    - Significant amount of internal code cleanup and improvements
-    - Other minor internal optimizations
-  - Code Contributors (alphabetical order):
-    - Beldur
-    - Ben Holden-Crowther
-    - Dave Collins
-    - David Evans
-    - David Hill
-    - Guilherme Salgado
-    - Javed Khan
-    - Jimmy Song
-    - John C. Vernaleo
-    - Jonathan Gillham
-    - Josh Rickmar
-    - Michael Ford
-    - Michail Kargakis
-    - kac
-    - Olaoluwa Osuntokun
-
-Changes in 0.9.0 (Sat Sep 20 2014)
-  - Protocol and network related changes:
-    - Add a new checkpoint at block height 319400
-    - Add support for BIP0037 bloom filters
-      (https://github.com/conformal/btcd/issues/132)
-    - Implement BIP0061 reject handling and hence support for protocol
-      version 70002 (https://github.com/conformal/btcd/issues/133)
-    - Add testnet DNS seeds for peer discovery (testnet-seed.alexykot.me
-      and testnet-seed.bitcoin.schildbach.de)
-    - Add mainnet DNS seed for peer discovery (seeds.bitcoin.open-nodes.org)
-    - Make multisig transactions with non-null dummy data nonstandard
-      (https://github.com/conformal/btcd/issues/131)
-    - Make transactions with an excessive number of signature operations
-      nonstandard
-    - Perform initial DNS lookups concurrently which allows connections
-      more quickly
-    - Improve the address manager to significantly reduce memory usage and
-      add tests
-    - Remove orphan transactions when they appear in a mined block
-      (https://github.com/conformal/btcd/issues/166)
-    - Apply incremental back off on connection retries for persistent peers
-      that give invalid replies to mirror the logic used for failed
-      connections (https://github.com/conformal/btcd/issues/103)
-    - Correct rate-limiting of free and low-fee transactions
-  - Mining support changes:
-    - Implement getblocktemplate RPC with the following support:
-      (https://github.com/conformal/btcd/issues/124)
-      - BIP0022 Non-Optional Sections
-      - BIP0022 Long Polling
-      - BIP0023 Basic Pool Extensions
-      - BIP0023 Mutation coinbase/append
-      - BIP0023 Mutations time, time/increment, and time/decrement
-      - BIP0023 Mutation transactions/add
-      - BIP0023 Mutations prevblock, coinbase, and generation
-      - BIP0023 Block Proposals
-    - Implement built-in concurrent CPU miner
-      (https://github.com/conformal/btcd/issues/137)
-      NOTE: CPU mining on mainnet is pointless. This has been provided
-      for testing purposes such as for the new simulation test network
-    - Add --generate flag to enable CPU mining
-    - Deprecate the --getworkkey flag in favor of --miningaddr which
-      specifies which addresses generated blocks will choose from to pay
-      the subsidy to
-  - RPC changes:
-    - Implement gettxout command
-      (https://github.com/conformal/btcd/issues/141)
-    - Implement validateaddress command
-    - Implement verifymessage command
-    - Mark getunconfirmedbalance RPC as wallet-only
-    - Mark getwalletinfo RPC as wallet-only
-    - Update getgenerate, setgenerate, gethashespersec, and getmininginfo
-      to return the appropriate information about new CPU mining status
-    - Modify getpeerinfo pingtime and pingwait field types to float64 so
-      they are compatible
-    - Improve disconnect handling for normal HTTP clients
-    - Make error code returns for invalid hex more consistent
-  - Websocket changes:
-    - Switch to a new more efficient websocket package
-      (https://github.com/conformal/btcd/issues/134)
-    - Add rescanfinished notification
-    - Modify the rescanprogress notification to include block hash as well
-      as height (https://github.com/conformal/btcd/issues/151)
-  - btcctl utility changes:
-    - Accept --simnet flag which automatically selects the appropriate port
-      and TLS certificates needed to communicate with btcd and btcwallet on
-      the simulation test network
-    - Fix createrawtransaction command to send amounts denominated in BTC
-    - Add estimatefee command
-    - Add estimatepriority command
-    - Add getmininginfo command
-    - Add getnetworkinfo command
-    - Add gettxout command
-    - Add lockunspent command
-    - Add signrawtransaction command
-  - addblock utility changes:
-    - Accept --simnet flag which automatically selects the appropriate port
-      and TLS certificates needed to communicate with btcd and btcwallet on
-      the simulation test network
-  - Notable developer-related package changes:
-    - Provide a new bloom package in btcutil which allows creating and
-      working with BIP0037 bloom filters
-    - Provide a new hdkeychain package in btcutil which allows working with
-      BIP0032 hierarchical deterministic key chains
-    - Introduce a new btcnet package which houses network parameters
-    - Provide new simnet network (--simnet) which is useful for private
-      simulation testing
-    - Enforce low S values in serialized signatures as detailed in BIP0062
-    - Return errors from all methods on the btcdb.Db interface
-      (https://github.com/conformal/btcdb/issues/5)
-    - Allow behavior flags to alter btcchain.ProcessBlock
-      (https://github.com/conformal/btcchain/issues/5)
-    - Provide a new SerializeSize API for blocks
-      (https://github.com/conformal/btcwire/issues/19)
-    - Several of the core packages now work with Google App Engine
-  - Misc changes:
-    - Correct an issue where the database could corrupt under certain
-      circumstances which would require a new chain download
-    - Slightly optimize deserialization
-    - Use the correct IP block for he.net
-    - Fix an issue where it was possible the block manager could hang on
-      shutdown
-    - Update sample config file so the comments are on a separate line
-      rather than the end of a line so they are not interpreted as settings
-      (https://github.com/conformal/btcd/issues/135)
-    - Correct an issue where getdata requests were not being properly
-      throttled which could lead to larger than necessary memory usage
-    - Always show help when given the help flag even when the config file
-      contains invalid entries
-    - General code cleanup and minor optimizations
-
-Changes in 0.8.0-beta (Sun May 25 2014)
-  - Btcd is now Beta (https://github.com/conformal/btcd/issues/130)
-  - Add a new checkpoint at block height 300255
-  - Protocol and network related changes:
-    - Lower the minimum transaction relay fee to 1000 satoshi to match
-      recent reference client changes
-      (https://github.com/conformal/btcd/issues/100)
-    - Raise the maximum signature script size to support standard 15-of-15
-      multi-signature pay-to-sript-hash transactions with compressed pubkeys
-      to remain compatible with the reference client
-      (https://github.com/conformal/btcd/issues/128)
-    - Reduce max bytes allowed for a standard nulldata transaction to 40 for
-      compatibility with the reference client
-    - Introduce a new btcnet package which houses all of the network params
-      for each network (mainnet, testnet, regtest) to ultimately enable
-      easier addition and tweaking of networks without needing to change
-      several packages
-    - Fix several script discrepancies found by reference client test data
-    - Add new DNS seed for peer discovery (seed.bitnodes.io)
-    - Reduce the max known inventory cache from 20000 items to 1000 items
-    - Fix an issue where unknown inventory types could lead to a hung peer
-    - Implement inventory rebroadcast handler for sendrawtransaction
-      (https://github.com/conformal/btcd/issues/99)
-    - Update user agent to fully support BIP0014
-      (https://github.com/conformal/btcwire/issues/10)
-  - Implement initial mining support:
-    - Add a new logging subsystem for mining related operations
-    - Implement infrastructure for creating block templates
-    - Provide options to control block template creation settings
-    - Support the getwork RPC
-    - Allow address identifiers to apply to more than one network since both
-      testnet and the regression test network unfortunately use the same
-      identifier
-  - RPC changes:
-    - Set the content type for HTTP POST RPC connections to application/json
-      (https://github.com/conformal/btcd/issues/121)
-    - Modified the RPC server startup so it only requires at least one valid
-      listen interface
-    - Correct an error path where it was possible certain errors would not
-      be returned
-    - Implement getwork command
-      (https://github.com/conformal/btcd/issues/125)
-    - Update sendrawtransaction command to reject orphans
-    - Update sendrawtransaction command to include the reason a transaction
-      was rejected
-    - Update getinfo command to populate connection count field
-    - Update getinfo command to include relay fee field
-      (https://github.com/conformal/btcd/issues/107)
-    - Allow transactions submitted with sendrawtransaction to bypass the
-      rate limiter
-    - Allow the getcurrentnet and getbestblock extensions to be accessed via
-      HTTP POST in addition to Websockets
-      (https://github.com/conformal/btcd/issues/127)
-  - Websocket changes:
-    - Rework notifications to ensure they are delivered in the order they
-      occur
-    - Rename notifynewtxs command to notifyreceived (funds received)
-    - Rename notifyallnewtxs command to notifynewtransactions
-    - Rename alltx notification to txaccepted
-    - Rename allverbosetx notification to txacceptedverbose
-      (https://github.com/conformal/btcd/issues/98)
-    - Add rescan progress notification
-    - Add recvtx notification
-    - Add redeemingtx notification
-    - Modify notifyspent command to accept an array of outpoints
-      (https://github.com/conformal/btcd/issues/123)
-    - Significantly optimize the rescan command to yield up to a 60x speed
-      increase
-  - btcctl utility changes:
-    - Add createencryptedwallet command
-    - Add getblockchaininfo command
-    - Add importwallet command
-    - Add addmultisigaddress command
-    - Add setgenerate command
-    - Accept --testnet and --wallet flags which automatically select
-      the appropriate port and TLS certificates needed to communicate
-      with btcd and btcwallet (https://github.com/conformal/btcd/issues/112)
-    - Allow path expansion from config file entries
-      (https://github.com/conformal/btcd/issues/113)
-    - Minor refactor simplify handling of options
-  - addblock utility changes:
-    - Improve logging by making it consistent with the logging provided by
-      btcd (https://github.com/conformal/btcd/issues/90)
-  - Improve several package APIs for developers:
-    - Add new amount type for consistently handling monetary values
-    - Add new coin selector API
-    - Add new WIF (Wallet Import Format) API
-    - Add new crypto types for private keys and signatures
-    - Add new API to sign transactions including script merging and hash
-      types
-    - Expose function to extract all pushed data from a script
-      (https://github.com/conformal/btcscript/issues/8)
-  - Misc changes:
-    - Optimize address manager shuffling to do 67% less work on average
-    - Resolve a couple of benign data races found by the race detector
-      (https://github.com/conformal/btcd/issues/101)
-    - Add IP address to all peer related errors to clarify which peer is the
-      cause (https://github.com/conformal/btcd/issues/102)
-    - Fix a UPNP case issue that prevented the --upnp option from working
-      with some UPNP servers
-    - Update documentation in the sample config file regarding debug levels
-    - Adjust some logging levels to improve debug messages
-    - Improve the throughput of query messages to the block manager
-    - Several minor optimizations to reduce GC churn and enhance speed
-    - Other minor refactoring
-    - General code cleanup
-
-Changes in 0.7.0 (Thu Feb 20 2014)
-  - Fix an issue when parsing scripts which contain a multi-signature script
-    which require zero signatures such as testnet block
-    000000001881dccfeda317393c261f76d09e399e15e27d280e5368420f442632
-    (https://github.com/conformal/btcscript/issues/7)
-  - Add check to ensure all transactions accepted to mempool only contain
-    canonical data pushes (https://github.com/conformal/btcscript/issues/6)
-  - Fix an issue causing excessive memory consumption
-  - Significantly rework and improve the websocket notification system:
-    - Each client is now independent so slow clients no longer limit the
-      speed of other connected clients
-    - Potentially long-running operations such as rescans are now run in
-      their own handler and rate-limited to one operation at a time without
-      preventing simultaneous requests from the same client for the faster
-      requests or notifications
-    - A couple of scenarios which could cause shutdown to hang have been
-      resolved
-    - Update notifynewtx notifications to support all address types instead
-      of only pay-to-pubkey-hash
-    - Provide a --rpcmaxwebsockets option to allow limiting the number of
-      concurrent websocket clients
-    - Add a new websocket command notifyallnewtxs to request notifications
-      (https://github.com/conformal/btcd/issues/86) (thanks @flammit)
-  - Improve btcctl utility in the following ways:
-    - Add getnetworkhashps command
-    - Add gettransaction command (wallet-specific)
-    - Add signmessage command (wallet-specific)
-    - Update getwork command to accept
-  - Continue cleanup and work on implementing the RPC API:
-    - Implement getnettotals command
-      (https://github.com/conformal/btcd/issues/84)
-    - Implement networkhashps command
-      (https://github.com/conformal/btcd/issues/87)
-    - Update getpeerinfo to always include syncnode field even when false
-    - Remove help addenda for getpeerinfo now that it supports all fields
-  - Close standard RPC connections on auth failure
-  - Provide a --rpcmaxclients option to allow limiting the number of
-    concurrent RPC clients (https://github.com/conformal/btcd/issues/68)
-  - Include IP address in RPC auth failure log messages
-  - Resolve a rather harmless data races found by the race detector
-    (https://github.com/conformal/btcd/issues/94)
-  - Increase block priority size and max standard transaction size to 50k
-    and 100k, respectively (https://github.com/conformal/btcd/issues/71)
-  - Add rate limiting of free transactions to the memory pool to prevent
-    penny flooding (https://github.com/conformal/btcd/issues/40)
-  - Provide a --logdir option (https://github.com/conformal/btcd/issues/95)
-  - Change the default log file path to include the network
-  - Add a new ScriptBuilder interface to btcscript to support creation of
-    custom scripts (https://github.com/conformal/btcscript/issues/5)
-  - General code cleanup
-
-Changes in 0.6.0 (Tue Feb 04 2014)
-  - Fix an issue when parsing scripts which contain invalid signatures that
-    caused a chain fork on block
-    0000000000000001e4241fd0b3469a713f41c5682605451c05d3033288fb2244
-  - Correct an issue which could lead to an error in removeBlockNode
-    (https://github.com/conformal/btcchain/issues/4)
-  - Improve addblock utility as follows:
-    - Check imported blocks against all chain rules and checkpoints
-    - Skip blocks which are already known so you can stop and restart the
-      import or start the import after you have already downloaded a portion
-      of the chain
-    - Correct an issue where the utility did not shutdown cleanly after
-      processing all blocks
-    - Add error on attempt to import orphan blocks
-    - Improve error handling and reporting
-    - Display statistics after input file has been fully processed
-  - Rework, optimize, and improve headers-first mode:
-    - Resuming the chain sync from any point before the final checkpoint
-      will now use headers-first mode
-      (https://github.com/conformal/btcd/issues/69)
-    - Verify all checkpoints as opposed to only the final one
-    - Reduce and bound memory usage
-    - Rollback to the last known good point when a header does not match a
-      checkpoint
-    - Log information about what is happening with headers
-  - Improve btcctl utility in the following ways:
-    - Add getaddednodeinfo command
-    - Add getnettotals command
-    - Add getblocktemplate command (wallet-specific)
-    - Add getwork command (wallet-specific)
-    - Add getnewaddress command (wallet-specific)
-    - Add walletpassphrasechange command (wallet-specific)
-    - Add walletlock command (wallet-specific)
-    - Add sendfrom command (wallet-specific)
-    - Add sendmany command (wallet-specific)
-    - Add settxfee command (wallet-specific)
-    - Add listsinceblock command (wallet-specific)
-    - Add listaccounts command (wallet-specific)
-    - Add keypoolrefill command (wallet-specific)
-    - Add getreceivedbyaccount command (wallet-specific)
-    - Add getrawchangeaddress command (wallet-specific)
-    - Add gettxoutsetinfo command (wallet-specific)
-    - Add listaddressgroupings command (wallet-specific)
-    - Add listlockunspent command (wallet-specific)
-    - Add listlock command (wallet-specific)
-    - Add listreceivedbyaccount command (wallet-specific)
-    - Add validateaddress command (wallet-specific)
-    - Add verifymessage command (wallet-specific)
-    - Add sendtoaddress command (wallet-specific)
-  - Continue cleanup and work on implementing the RPC API:
-    - Implement submitblock command
-      (https://github.com/conformal/btcd/issues/61)
-    - Implement help command
-    - Implement ping command
-    - Implement getaddednodeinfo command
-      (https://github.com/conformal/btcd/issues/78)
-    - Implement getinfo command
-    - Update getpeerinfo to support bytesrecv and bytessent
-      (https://github.com/conformal/btcd/issues/83)
-  - Improve and correct several RPC server and websocket areas:
-    - Change the connection endpoint for websockets from /wallet to /ws
-      (https://github.com/conformal/btcd/issues/80)
-    - Implement an alternative authentication for websockets so clients
-      such as javascript from browsers that don't support setting HTTP
-      headers can authenticate (https://github.com/conformal/btcd/issues/77)
-    - Add an authentication deadline for RPC connections
-      (https://github.com/conformal/btcd/issues/68)
-    - Use standard authentication failure responses for RPC connections
-    - Make automatically generated certificate more standard so it works
-      from client such as node.js and Firefox
-    - Correct some minor issues which could prevent the RPC server from
-      shutting down in an orderly fashion
-    - Make all websocket notifications require registration
-    - Change the data sent over websockets to text since it is JSON-RPC
-    - Allow connections that do not have an Origin header set
-  - Expose and track the number of bytes read and written per peer
-    (https://github.com/conformal/btcwire/issues/6)
-  - Correct an issue with sendrawtransaction when invoked via websockets
-    which prevented a minedtx notification from being added
-  - Rescan operations issued from remote wallets are no stopped when
-    the wallet disconnects mid-operation
-    (https://github.com/conformal/btcd/issues/66)
-  - Several optimizations related to fetching block information from the
-    database
-  - General code cleanup
-
-Changes in 0.5.0 (Mon Jan 13 2014)
-  - Optimize initial block download by introducing a new mode which
-    downloads the block headers first (up to the final checkpoint)
-  - Improve peer handling to remove the potential for slow peers to cause
-    sluggishness amongst all peers
-    (https://github.com/conformal/btcd/issues/63)
-  - Fix an issue where the initial block sync could stall when the sync peer
-    disconnects (https://github.com/conformal/btcd/issues/62)
-  - Correct an issue where --externalip was doing a DNS lookup on the full
-    host:port instead of just the host portion
-    (https://github.com/conformal/btcd/issues/38)
-  - Fix an issue which could lead to a panic on chain switches
-    (https://github.com/conformal/btcd/issues/70)
-  - Improve btcctl utility in the following ways:
-    - Show getdifficulty output as floating point to 6 digits of precision
-    - Show all JSON object replies formatted as standard JSON
-    - Allow btcctl getblock to accept optional params
-    - Add getaccount command (wallet-specific)
-    - Add getaccountaddress command (wallet-specific)
-    - Add sendrawtransaction command
-  - Continue cleanup and work on implementing RPC API calls
-    - Update getrawmempool to support new optional verbose flag
-    - Update getrawtransaction to match the reference client
-    - Update getblock to support new optional verbose flag
-    - Update raw transactions to fully match the reference client including
-      support for all transaction types and address types
-    - Correct getrawmempool fee field to return BTC instead of Satoshi
-    - Correct getpeerinfo service flag to return 8 digit string so it
-      matches the reference client
-    - Correct verifychain to return a boolean
-    - Implement decoderawtransaction command
-    - Implement createrawtransaction command
-    - Implement decodescript command
-    - Implement gethashespersec command
-    - Allow RPC handler overrides when invoked via a websocket versus
-      legacy connection
-  - Add new DNS seed for peer discovery
-  - Display user agent on new valid peer log message
-    (https://github.com/conformal/btcd/issues/64)
-  - Notify wallet when new transactions that pay to registered addresses
-    show up in the mempool before being mined into a block
-  - Support a tor-specific proxy in addition to a normal proxy
-    (https://github.com/conformal/btcd/issues/47)
-  - Remove deprecated sqlite3 imports from utilities
-  - Remove leftover profile write from addblock utility
-  - Quite a bit of code cleanup and refactoring to improve maintainability
-
-Changes in 0.4.0 (Thu Dec 12 2013)
-  - Allow listen interfaces to be specified via --listen instead of only the
-    port (https://github.com/conformal/btcd/issues/33)
-  - Allow listen interfaces for the RPC server to be specified via
-    --rpclisten instead of only the port
-    (https://github.com/conformal/btcd/issues/34)
-  - Only disable listening when --connect or --proxy are used when no
-    --listen interface are specified
-    (https://github.com/conformal/btcd/issues/10)
-  - Add several new standard transaction checks to transaction memory pool:
-    - Support nulldata scripts as standard
-    - Only allow a max of one nulldata output per transaction
-    - Enforce a maximum of 3 public keys in multi-signature transactions
-    - The number of signatures in multi-signature transactions must not
-      exceed the number of public keys
-    - The number of inputs to a signature script must match the expected
-      number of inputs for the script type
-    - The number of inputs pushed onto the stack by a redeeming signature
-      script must match the number of inputs consumed by the referenced
-      public key script
-  - When a block is connected, remove any transactions from the memory pool
-    which are now double spends as a result of the newly connected
-    transactions
-  - Don't relay transactions resurrected during a chain switch since
-    other peers will also be switching chains and therefore already know
-    about them
-  - Cleanup a few cases where rejected transactions showed as an error
-    rather than as a rejected transaction
-  - Ignore the default configuration file when --regtest (regression test
-    mode) is specified
-  - Implement TLS support for RPC including automatic certificate generation
-  - Support HTTP authentication headers for web sockets
-  - Update address manager to recognize and properly work with Tor
-    addresses (https://github.com/conformal/btcd/issues/36) and
-    (https://github.com/conformal/btcd/issues/37)
-  - Improve btcctl utility in the following ways:
-    - Add the ability to specify a configuration file
-    - Add a default entry for the RPC cert to point to the location
-      it will likely be in the btcd home directory
-    - Implement --version flag
-    - Provide a --notls option to support non-TLS configurations
-  - Fix a couple of minor races found by the Go race detector
-  - Improve logging
-    - Allow logging level to be specified on a per subsystem basis
-      (https://github.com/conformal/btcd/issues/48)
-    - Allow logging levels to be dynamically changed via RPC
-      (https://github.com/conformal/btcd/issues/15)
-    - Implement a rolling log file with a max of 10MB per file and a
-      rotation size of 3 which results in a max logging size of 30 MB
-  - Correct a minor issue with the rescanning websocket call
-    (https://github.com/conformal/btcd/issues/54)
-  - Fix a race with pushing address messages that could lead to a panic
-    (https://github.com/conformal/btcd/issues/58)
-  - Improve which external IP address is reported to peers based on which
-    interface they are connected through
-    (https://github.com/conformal/btcd/issues/35)
-  - Add --externalip option to allow an external IP address to be specified
-    for cases such as tor hidden services or advanced network configurations
-    (https://github.com/conformal/btcd/issues/38)
-  - Add --upnp option to support automatic port mapping via UPnP
-    (https://github.com/conformal/btcd/issues/51)
-  - Update Ctrl+C interrupt handler to properly sync address manager and
-    remove the UPnP port mapping (if needed)
-  - Continue cleanup and work on implementing RPC API calls
-    - Add importprivkey (import private key) command to btcctl
-    - Update getrawtransaction to provide addresses properly, support
-      new verbose param, and match the reference implementation with the
-      exception of MULTISIG (thanks @flammit)
-    - Update getblock with new verbose flag (thanks @flammit)
-    - Add listtransactions command to btcctl
-    - Add getbalance command to btcctl
-  - Add basic support for btcd to run as a native Windows service
-    (https://github.com/conformal/btcd/issues/42)
-  - Package addblock utility with Windows MSIs
-  - Add support for TravisCI (continuous build integration)
-  - Cleanup some documentation and usage
-  - Several other minor bug fixes and general code cleanup
-
-Changes in 0.3.3 (Wed Nov 13 2013)
-  - Significantly improve initial block chain download speed
-    (https://github.com/conformal/btcd/issues/20)
-  - Add a new checkpoint at block height 267300
-  - Optimize most recently used inventory handling
-    (https://github.com/conformal/btcd/issues/21)
-  - Optimize duplicate transaction input check
-    (https://github.com/conformal/btcchain/issues/2)
-  - Optimize transaction hashing
-    (https://github.com/conformal/btcd/issues/25)
-  - Rework and optimize wallet listener notifications
-    (https://github.com/conformal/btcd/issues/22)
-  - Optimize serialization and deserialization
-    (https://github.com/conformal/btcd/issues/27)
-  - Add support for minimum transaction fee to memory pool acceptance
-    (https://github.com/conformal/btcd/issues/29)
-  - Improve leveldb database performance by removing explicit GC call
-  - Fix an issue where Ctrl+C was not always finishing orderly database
-    shutdown
-  - Fix an issue in the script handling for OP_CHECKSIG
-  - Impose max limits on all variable length protocol entries to prevent
-    abuse from malicious peers
-  - Enforce DER signatures for transactions allowed into the memory pool
-  - Separate the debug profile http server from the RPC server
-  - Rework of the RPC code to improve performance and make the code cleaner
-  - The getrawtransaction RPC call now properly checks the memory pool
-    before consulting the db (https://github.com/conformal/btcd/issues/26)
-  - Add support for the following RPC calls: getpeerinfo, getconnectedcount,
-    addnode, verifychain
-    (https://github.com/conformal/btcd/issues/13)
-    (https://github.com/conformal/btcd/issues/17)
-  - Implement rescan websocket extension to allow wallet rescans
-  - Use correct paths for application data storage for all supported
-    operating systems (https://github.com/conformal/btcd/issues/30)
-  - Add a default redirect to the http profiling page when accessing the
-    http profile server
-  - Add a new --cpuprofile option which can be used to generate CPU
-    profiling data on platforms that support it
-  - Several other minor performance optimizations
-  - Other minor bug fixes and general code cleanup
-
-Changes in 0.3.2 (Tue Oct 22 2013)
-  - Fix an issue that could cause the download of the block chain to stall
-    (https://github.com/conformal/btcd/issues/12)
-  - Remove deprecated sqlite as an available database backend
-  - Close sqlite compile issue as sqlite has now been removed
-    (https://github.com/conformal/btcd/issues/11)
-  - Change default RPC ports to 8334 (mainnet) and 18334 (testnet)
-  - Continue cleanup and work on implementing RPC API calls
-  - Add support for the following RPC calls: getrawmempool,
-    getbestblockhash, decoderawtransaction, getdifficulty,
-    getconnectioncount, getpeerinfo, and addnode
-  - Improve the btcctl utility that is used to issue JSON-RPC commands
-  - Fix an issue preventing btcd from cleanly shutting down with the RPC
-    stop command
-  - Add a number of database interface tests to ensure backends implement
-    the expected interface
-  - Expose some additional information from btcscript to be used for
-    identifying "standard"" transactions
-  - Add support for plan9 - thanks @mischief
-    (https://github.com/conformal/btcd/pull/19)
-  - Other minor bug fixes and general code cleanup
-
-Changes in 0.3.1-alpha (Tue Oct 15 2013)
-  - Change default database to leveldb
-    NOTE: This does mean you will have to redownload the block chain. Since we
-    are still in alpha, we didn't feel writing a converter was worth the time as
-    it would take away from more important issues at this stage
-  - Add a warning if there are multiple block chain databases of different types
-  - Fix issue with unexpected EOF in leveldb -- https://github.com/conformal/btcd/issues/18
-  - Fix issue preventing block 21066 on testnet -- https://github.com/conformal/btcchain/issues/1
-  - Fix issue preventing block 96464 on testnet -- https://github.com/conformal/btcscript/issues/1
-  - Optimize transaction lookups
-  - Correct a few cases of list removal that could result in improper cleanup
-    of no longer needed orphans
-  - Add functionality to increase ulimits on non-Windows platforms
-  - Add support for mempool command which allows remote peers to query the
-    transaction memory pool via the bitcoin protocol
-  - Clean up logging a bit
-  - Add a flag to disable checkpoints for developers
-  - Add a lot of useful debug logging such as message summaries
-  - Other minor bug fixes and general code cleanup
-
-Initial Release 0.3.0-alpha (Sat Oct 05 2013):
-  - Initial release
--- a/10
+++ b/10
@@ -1,10 +0,0 @@
-node {
-    stage 'Checkout'
-    checkout scm
-
-    stage 'Version'
-    sh './deploy.sh version'
-
-    stage 'Build'
-    sh "./deploy.sh build"
-}
--- a/1
+++ b/1
@@ -3,6 +3,7 @@ ISC License
 Copyright (c) 2018-2019 The kaspanet developers
 Copyright (c) 2013-2018 The btcsuite developers
 Copyright (c) 2015-2016 The Decred developers
+Copyright (c) 2013-2014 Conformal Systems LLC.

 Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ Kaspad
 Warning: This is pre-alpha software. There's no guarantee anything works.
 ====

-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](https://choosealicense.com/licenses/isc/)
 [![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/kaspanet/kaspad)

 Kaspad is the reference full node Kaspa implementation written in Go (golang).
@@ -75,5 +75,5 @@ The documentation is a work-in-progress. It is located in the [docs](https://git

 ## License

-Kaspad is licensed under the [copyfree](http://copyfree.org) ISC License.
+Kaspad is licensed under the copyfree [ISC License](https://choosealicense.com/licenses/isc/).

--- a/addrmgr/addrmanager.go
+++ b/addrmgr/addrmanager.go
@@ -7,7 +7,6 @@ package addrmgr
 import (
 	"container/list"
 	crand "crypto/rand" // for seeding
-	"encoding/base32"
 	"encoding/binary"
 	"encoding/json"
 	"github.com/pkg/errors"
@@ -17,7 +16,6 @@ import (
 	"os"
 	"path/filepath"
 	"strconv"
-	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -44,7 +42,6 @@ type AddrManager struct {
 	addrNewFullNodes   newBucket
 	addrTried          map[subnetworkid.SubnetworkID]*triedBucket
 	addrTriedFullNodes triedBucket
-	addrTrying         map[*KnownAddress]bool
 	started            int32
 	shutdown           int32
 	wg                 sync.WaitGroup
@@ -720,11 +717,7 @@ func (a *AddrManager) Start() {

 	// Start the address ticker to save addresses periodically.
 	a.wg.Add(1)
-	spawn(a.addressHandler, a.handlePanic)
-}
-
-func (a *AddrManager) handlePanic() {
-	atomic.AddInt32(&a.shutdown, 1)
+	spawn(a.addressHandler)
 }

 // Stop gracefully shuts down the address manager by stopping the main handler.
@@ -871,7 +864,6 @@ func (a *AddrManager) AddressCache(includeAllSubnetworks bool, subnetworkID *sub
 // reset resets the address manager by reinitialising the random source
 // and allocating fresh empty bucket storage.
 func (a *AddrManager) reset() {
-
 	a.addrIndex = make(map[string]*KnownAddress)

 	// fill key with bytes from a good random source.
@@ -890,28 +882,13 @@ func (a *AddrManager) reset() {
 	}
 	a.nNewFullNodes = 0
 	a.nTriedFullNodes = 0
-
-	a.addrTrying = make(map[*KnownAddress]bool)
 }

-// HostToNetAddress returns a netaddress given a host address. If the address
-// is a Tor .onion address this will be taken care of. Else if the host is
-// not an IP address it will be resolved (via Tor if required).
+// HostToNetAddress returns a netaddress given a host address. If
+// the host is not an IP address it will be resolved.
 func (a *AddrManager) HostToNetAddress(host string, port uint16, services wire.ServiceFlag) (*wire.NetAddress, error) {
-	// Tor address is 16 char base32 + ".onion"
-	var ip net.IP
-	if len(host) == 22 && host[16:] == ".onion" {
-		// go base32 encoding uses capitals (as does the rfc
-		// but Tor tend to user lowercase, so we switch
-		// case here.
-		data, err := base32.StdEncoding.DecodeString(
-			strings.ToUpper(host[:16]))
-		if err != nil {
-			return nil, err
-		}
-		prefix := []byte{0xfd, 0x87, 0xd8, 0x7e, 0xeb, 0x43}
-		ip = net.IP(append(prefix, data...))
-	} else if ip = net.ParseIP(host); ip == nil {
+	ip := net.ParseIP(host)
+	if ip == nil {
 		ips, err := a.lookupFunc(host)
 		if err != nil {
 			return nil, err
@@ -925,25 +902,12 @@ func (a *AddrManager) HostToNetAddress(host string, port uint16, services wire.S
 	return wire.NewNetAddressIPPort(ip, port, services), nil
 }

-// ipString returns a string for the ip from the provided NetAddress. If the
-// ip is in the range used for Tor addresses then it will be transformed into
-// the relevant .onion address.
-func ipString(na *wire.NetAddress) string {
-	if IsOnionCatTor(na) {
-		// We know now that na.IP is long enough.
-		base32 := base32.StdEncoding.EncodeToString(na.IP[6:])
-		return strings.ToLower(base32) + ".onion"
-	}
-
-	return na.IP.String()
-}
-
 // NetAddressKey returns a string key in the form of ip:port for IPv4 addresses
 // or [ip]:port for IPv6 addresses.
 func NetAddressKey(na *wire.NetAddress) string {
 	port := strconv.FormatUint(uint64(na.Port), 10)

-	return net.JoinHostPort(ipString(na), port)
+	return net.JoinHostPort(na.IP.String(), port)
 }

 // GetAddress returns a single address that should be routable. It picks a
@@ -965,13 +929,6 @@ func (a *AddrManager) GetAddress() *KnownAddress {
 			a.addrNew[subnetworkID], a.nNew[subnetworkID])
 	}

-	if knownAddress != nil {
-		if a.addrTrying[knownAddress] {
-			return nil
-		}
-		a.addrTrying[knownAddress] = true
-	}
-
 	return knownAddress

 }
@@ -1056,8 +1013,6 @@ func (a *AddrManager) Attempt(addr *wire.NetAddress) {
 	// set last tried time to now
 	ka.attempts++
 	ka.lastattempt = time.Now()
-
-	delete(a.addrTrying, ka)
 }

 // Connected Marks the given address as currently connected and working at the
@@ -1287,18 +1242,6 @@ func getReachabilityFrom(localAddr, remoteAddr *wire.NetAddress) int {
 		return Unreachable
 	}

-	if IsOnionCatTor(remoteAddr) {
-		if IsOnionCatTor(localAddr) {
-			return Private
-		}
-
-		if IsRoutable(localAddr) && IsIPv4(localAddr) {
-			return Ipv4
-		}
-
-		return Default
-	}
-
 	if IsRFC4380(remoteAddr) {
 		if !IsRoutable(localAddr) {
 			return Default
@@ -1376,7 +1319,7 @@ func (a *AddrManager) GetBestLocalAddress(remoteAddr *wire.NetAddress) *wire.Net

 		// Send something unroutable if nothing suitable.
 		var ip net.IP
-		if !IsIPv4(remoteAddr) && !IsOnionCatTor(remoteAddr) {
+		if !IsIPv4(remoteAddr) {
 			ip = net.IPv6zero
 		} else {
 			ip = net.IPv4zero
--- a/addrmgr/addrmanager_test.go
+++ b/addrmgr/addrmanager_test.go
@@ -5,17 +5,16 @@
 package addrmgr

 import (
-	"bou.ke/monkey"
 	"fmt"
 	"github.com/kaspanet/kaspad/config"
 	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/pkg/errors"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
 	"net"
 	"reflect"
 	"testing"
 	"time"

-	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"github.com/pkg/errors"

 	"github.com/kaspanet/kaspad/wire"
 )
@@ -38,59 +37,59 @@ var someIP = "173.194.115.66"
 func addNaTests() {
 	// IPv4
 	// Localhost
-	addNaTest("127.0.0.1", 8333, "127.0.0.1:8333")
-	addNaTest("127.0.0.1", 8334, "127.0.0.1:8334")
+	addNaTest("127.0.0.1", 16111, "127.0.0.1:16111")
+	addNaTest("127.0.0.1", 16110, "127.0.0.1:16110")

 	// Class A
-	addNaTest("1.0.0.1", 8333, "1.0.0.1:8333")
-	addNaTest("2.2.2.2", 8334, "2.2.2.2:8334")
+	addNaTest("1.0.0.1", 16111, "1.0.0.1:16111")
+	addNaTest("2.2.2.2", 16110, "2.2.2.2:16110")
 	addNaTest("27.253.252.251", 8335, "27.253.252.251:8335")
 	addNaTest("123.3.2.1", 8336, "123.3.2.1:8336")

 	// Private Class A
-	addNaTest("10.0.0.1", 8333, "10.0.0.1:8333")
-	addNaTest("10.1.1.1", 8334, "10.1.1.1:8334")
+	addNaTest("10.0.0.1", 16111, "10.0.0.1:16111")
+	addNaTest("10.1.1.1", 16110, "10.1.1.1:16110")
 	addNaTest("10.2.2.2", 8335, "10.2.2.2:8335")
 	addNaTest("10.10.10.10", 8336, "10.10.10.10:8336")

 	// Class B
-	addNaTest("128.0.0.1", 8333, "128.0.0.1:8333")
-	addNaTest("129.1.1.1", 8334, "129.1.1.1:8334")
+	addNaTest("128.0.0.1", 16111, "128.0.0.1:16111")
+	addNaTest("129.1.1.1", 16110, "129.1.1.1:16110")
 	addNaTest("180.2.2.2", 8335, "180.2.2.2:8335")
 	addNaTest("191.10.10.10", 8336, "191.10.10.10:8336")

 	// Private Class B
-	addNaTest("172.16.0.1", 8333, "172.16.0.1:8333")
-	addNaTest("172.16.1.1", 8334, "172.16.1.1:8334")
+	addNaTest("172.16.0.1", 16111, "172.16.0.1:16111")
+	addNaTest("172.16.1.1", 16110, "172.16.1.1:16110")
 	addNaTest("172.16.2.2", 8335, "172.16.2.2:8335")
 	addNaTest("172.16.172.172", 8336, "172.16.172.172:8336")

 	// Class C
-	addNaTest("193.0.0.1", 8333, "193.0.0.1:8333")
-	addNaTest("200.1.1.1", 8334, "200.1.1.1:8334")
+	addNaTest("193.0.0.1", 16111, "193.0.0.1:16111")
+	addNaTest("200.1.1.1", 16110, "200.1.1.1:16110")
 	addNaTest("205.2.2.2", 8335, "205.2.2.2:8335")
 	addNaTest("223.10.10.10", 8336, "223.10.10.10:8336")

 	// Private Class C
-	addNaTest("192.168.0.1", 8333, "192.168.0.1:8333")
-	addNaTest("192.168.1.1", 8334, "192.168.1.1:8334")
+	addNaTest("192.168.0.1", 16111, "192.168.0.1:16111")
+	addNaTest("192.168.1.1", 16110, "192.168.1.1:16110")
 	addNaTest("192.168.2.2", 8335, "192.168.2.2:8335")
 	addNaTest("192.168.192.192", 8336, "192.168.192.192:8336")

 	// IPv6
 	// Localhost
-	addNaTest("::1", 8333, "[::1]:8333")
-	addNaTest("fe80::1", 8334, "[fe80::1]:8334")
+	addNaTest("::1", 16111, "[::1]:16111")
+	addNaTest("fe80::1", 16110, "[fe80::1]:16110")

 	// Link-local
-	addNaTest("fe80::1:1", 8333, "[fe80::1:1]:8333")
-	addNaTest("fe91::2:2", 8334, "[fe91::2:2]:8334")
+	addNaTest("fe80::1:1", 16111, "[fe80::1:1]:16111")
+	addNaTest("fe91::2:2", 16110, "[fe91::2:2]:16110")
 	addNaTest("fea2::3:3", 8335, "[fea2::3:3]:8335")
 	addNaTest("feb3::4:4", 8336, "[feb3::4:4]:8336")

 	// Site-local
-	addNaTest("fec0::1:1", 8333, "[fec0::1:1]:8333")
-	addNaTest("fed1::2:2", 8334, "[fed1::2:2]:8334")
+	addNaTest("fec0::1:1", 16111, "[fec0::1:1]:16111")
+	addNaTest("fed1::2:2", 16110, "[fed1::2:2]:16110")
 	addNaTest("fee2::3:3", 8335, "[fee2::3:3]:8335")
 	addNaTest("fef3::4:4", 8336, "[fef3::4:4]:8336")
 }
@@ -116,15 +115,14 @@ func TestStartStop(t *testing.T) {
 }

 func TestAddAddressByIP(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	fmtErr := errors.Errorf("")
 	addrErr := &net.AddrError{}
@@ -133,7 +131,7 @@ func TestAddAddressByIP(t *testing.T) {
 		err    error
 	}{
 		{
-			someIP + ":8333",
+			someIP + ":16111",
 			nil,
 		},
 		{
@@ -170,15 +168,14 @@ func TestAddAddressByIP(t *testing.T) {
 }

 func TestAddLocalAddress(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	var tests = []struct {
 		address  wire.NetAddress
@@ -233,15 +230,14 @@ func TestAddLocalAddress(t *testing.T) {
 }

 func TestAttempt(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	n := New("testattempt", lookupFunc, nil)

@@ -265,15 +261,14 @@ func TestAttempt(t *testing.T) {
 }

 func TestConnected(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	n := New("testconnected", lookupFunc, nil)

@@ -295,15 +290,14 @@ func TestConnected(t *testing.T) {
 }

 func TestNeedMoreAddresses(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	n := New("testneedmoreaddresses", lookupFunc, nil)
 	addrsToAdd := 1500
@@ -337,15 +331,14 @@ func TestNeedMoreAddresses(t *testing.T) {
 }

 func TestGood(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	n := New("testgood", lookupFunc, nil)
 	addrsToAdd := 64 * 64
@@ -394,15 +387,14 @@ func TestGood(t *testing.T) {
 }

 func TestGoodChangeSubnetworkID(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	n := New("test_good_change_subnetwork_id", lookupFunc, nil)
 	addr := wire.NewNetAddressIPPort(net.IPv4(173, 144, 173, 111), 8333, 0)
@@ -473,15 +465,14 @@ func TestGoodChangeSubnetworkID(t *testing.T) {
 }

 func TestGetAddress(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	localSubnetworkID := &subnetworkid.SubnetworkID{0xff}
 	n := New("testgetaddress", lookupFunc, localSubnetworkID)
@@ -555,15 +546,14 @@ func TestGetAddress(t *testing.T) {
 }

 func TestGetBestLocalAddress(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	localAddrs := []wire.NetAddress{
 		{IP: net.ParseIP("192.168.0.100")},
@@ -657,7 +647,6 @@ func TestGetBestLocalAddress(t *testing.T) {
 		// Add a Tor generated IP address
 		localAddr = wire.NetAddress{IP: net.ParseIP("fd87:d87e:eb43:25::1")}
 		amgr.AddLocalAddress(&localAddr, ManualPrio)
-
 		// Test against want3
 		for x, test := range tests {
 			got := amgr.GetBestLocalAddress(&test.remoteAddr)
--- a/addrmgr/cov_report.sh
+++ b/addrmgr/cov_report.sh
@@ -1,17 +0,0 @@
-#!/bin/sh
-
-# This script uses gocov to generate a test coverage report.
-# The gocov tool my be obtained with the following command:
-#   go get github.com/axw/gocov/gocov
-#
-# It will be installed to $GOPATH/bin, so ensure that location is in your $PATH.
-
-# Check for gocov.
-type gocov >/dev/null 2>&1
-if [ $? -ne 0 ]; then
-	echo >&2 "This script requires the gocov tool."
-	echo >&2 "You may obtain it with the following command:"
-	echo >&2 "go get github.com/axw/gocov/gocov"
-	exit 1
-fi
-gocov test | gocov report
--- a/addrmgr/doc.go
+++ b/addrmgr/doc.go
@@ -1,7 +1,3 @@
-// Copyright (c) 2014 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
 /*
 Package addrmgr implements concurrency safe Kaspa address manager.

@@ -28,11 +24,11 @@ generally helps provide greater peer diversity, and perhaps more importantly,
 drastically reduces the chances an attacker is able to coerce your peer into
 only connecting to nodes they control.

-The address manager also understands routability and Tor addresses and tries
-hard to only return routable addresses. In addition, it uses the information
-provided by the caller about connected, known good, and attempted addresses to
-periodically purge peers which no longer appear to be good peers as well as
-bias the selection toward known good peers. The general idea is to make a best
-effort at only providing usable addresses.
+The address manager also understands routability and tries hard to only return
+routable addresses. In addition, it uses the information provided by the caller
+about connected, known good, and attempted addresses to periodically purge
+peers which no longer appear to be good peers as well as bias the selection
+toward known good peers. The general idea is to make a best effort at only
+providing usable addresses.
 */
 package addrmgr
--- a/addrmgr/log.go
+++ b/addrmgr/log.go
@@ -10,4 +10,4 @@ import (
 )

 var log, _ = logger.Get(logger.SubsystemTags.ADXR)
-var spawn = panics.GoroutineWrapperFuncWithPanicHandler(log)
+var spawn = panics.GoroutineWrapperFunc(log)
--- a/addrmgr/network.go
+++ b/addrmgr/network.go
@@ -5,7 +5,6 @@
 package addrmgr

 import (
-	"fmt"
 	"net"

 	"github.com/kaspanet/kaspad/config"
@@ -73,19 +72,6 @@ var (
 	// rfc6598Net specifies the IPv4 block as defined by RFC6598 (100.64.0.0/10)
 	rfc6598Net = ipNet("100.64.0.0", 10, 32)

-	// onionCatNet defines the IPv6 address block used to support Tor.
-	// We encode a .onion address as a 16 byte number by decoding the
-	// address prior to the .onion (i.e. the key hash) base32 into a ten
-	// byte number. It then stores the first 6 bytes of the address as
-	// 0xfd, 0x87, 0xd8, 0x7e, 0xeb, 0x43.
-	//
-	// This is the same range used by OnionCat, which is part part of the
-	// RFC4193 unique local IPv6 range.
-	//
-	// In summary the format is:
-	// { magic 6 bytes, 10 bytes base32 decode of key hash }
-	onionCatNet = ipNet("fd87:d87e:eb43::", 48, 128)
-
 	// zero4Net defines the IPv4 address block for address staring with 0
 	// (0.0.0.0/8).
 	zero4Net = ipNet("0.0.0.0", 8, 32)
@@ -111,14 +97,6 @@ func IsLocal(na *wire.NetAddress) bool {
 	return na.IP.IsLoopback() || zero4Net.Contains(na.IP)
 }

-// IsOnionCatTor returns whether or not the passed address is in the IPv6 range
-// used by Kaspa to support Tor (fd87:d87e:eb43::/48). Note that this range
-// is the same range used by OnionCat, which is part of the RFC4193 unique local
-// IPv6 range.
-func IsOnionCatTor(na *wire.NetAddress) bool {
-	return onionCatNet.Contains(na.IP)
-}
-
 // IsRFC1918 returns whether or not the passed address is part of the IPv4
 // private network address space as defined by RFC1918 (10.0.0.0/8,
 // 172.16.0.0/12, or 192.168.0.0/16).
@@ -232,13 +210,12 @@ func IsRoutable(na *wire.NetAddress) bool {
 	return IsValid(na) && !(IsRFC1918(na) || IsRFC2544(na) ||
 		IsRFC3927(na) || IsRFC4862(na) || IsRFC3849(na) ||
 		IsRFC4843(na) || IsRFC5737(na) || IsRFC6598(na) ||
-		IsLocal(na) || (IsRFC4193(na) && !IsOnionCatTor(na)))
+		IsLocal(na) || (IsRFC4193(na)))
 }

 // GroupKey returns a string representing the network group an address is part
 // of. This is the /16 for IPv4, the /32 (/36 for he.net) for IPv6, the string
-// "local" for a local address, the string "tor:key" where key is the /4 of the
-// onion address for Tor address, and the string "unroutable" for an unroutable
+// "local" for a local address, and the string "unroutable" for an unroutable
 // address.
 func GroupKey(na *wire.NetAddress) string {
 	if IsLocal(na) {
@@ -270,10 +247,6 @@ func GroupKey(na *wire.NetAddress) string {
 		}
 		return ip.Mask(net.CIDRMask(16, 32)).String()
 	}
-	if IsOnionCatTor(na) {
-		// group is keyed off the first 4 bits of the actual onion key.
-		return fmt.Sprintf("tor:%d", na.IP[6]&((1<<4)-1))
-	}

 	// OK, so now we know ourselves to be a IPv6 address.
 	// We use /32 for everything, except for Hurricane Electric's
--- a/addrmgr/network_test.go
+++ b/addrmgr/network_test.go
@@ -5,7 +5,6 @@
 package addrmgr_test

 import (
-	"bou.ke/monkey"
 	"github.com/kaspanet/kaspad/config"
 	"github.com/kaspanet/kaspad/dagconfig"
 	"net"
@@ -18,15 +17,14 @@ import (
 // TestIPTypes ensures the various functions which determine the type of an IP
 // address based on RFCs work as intended.
 func TestIPTypes(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	type ipTest struct {
 		in       wire.NetAddress
@@ -52,7 +50,7 @@ func TestIPTypes(t *testing.T) {
 		rfc4193, rfc4380, rfc4843, rfc4862, rfc5737, rfc6052, rfc6145, rfc6598,
 		local, valid, routable bool) ipTest {
 		nip := net.ParseIP(ip)
-		na := *wire.NewNetAddressIPPort(nip, 8333, wire.SFNodeNetwork)
+		na := *wire.NewNetAddressIPPort(nip, 16111, wire.SFNodeNetwork)
 		test := ipTest{na, rfc1918, rfc2544, rfc3849, rfc3927, rfc3964, rfc4193, rfc4380,
 			rfc4843, rfc4862, rfc5737, rfc6052, rfc6145, rfc6598, local, valid, routable}
 		return test
@@ -158,15 +156,14 @@ func TestIPTypes(t *testing.T) {
 // TestGroupKey tests the GroupKey function to ensure it properly groups various
 // IP addresses.
 func TestGroupKey(t *testing.T) {
-	activeConfigPatch := monkey.Patch(config.ActiveConfig, func() *config.Config {
-		return &config.Config{
-			Flags: &config.Flags{
-				NetworkFlags: config.NetworkFlags{
-					ActiveNetParams: &dagconfig.SimNetParams},
-			},
-		}
+	originalActiveCfg := config.ActiveConfig()
+	config.SetActiveConfig(&config.Config{
+		Flags: &config.Flags{
+			NetworkFlags: config.NetworkFlags{
+				ActiveNetParams: &dagconfig.SimnetParams},
+		},
 	})
-	defer activeConfigPatch.Unpatch()
+	defer config.SetActiveConfig(originalActiveCfg)

 	tests := []struct {
 		name     string
@@ -202,9 +199,9 @@ func TestGroupKey(t *testing.T) {
 		{name: "ipv6 rfc6145 translated ipv4", ip: "::ffff:0:0c01:0203", expected: "12.1.0.0"},

 		// Tor.
-		{name: "ipv6 tor onioncat", ip: "fd87:d87e:eb43:1234::5678", expected: "tor:2"},
-		{name: "ipv6 tor onioncat 2", ip: "fd87:d87e:eb43:1245::6789", expected: "tor:2"},
-		{name: "ipv6 tor onioncat 3", ip: "fd87:d87e:eb43:1345::6789", expected: "tor:3"},
+		{name: "ipv6 tor onioncat", ip: "fd87:d87e:eb43:1234::5678", expected: "unroutable"},
+		{name: "ipv6 tor onioncat 2", ip: "fd87:d87e:eb43:1245::6789", expected: "unroutable"},
+		{name: "ipv6 tor onioncat 3", ip: "fd87:d87e:eb43:1345::6789", expected: "unroutable"},

 		// IPv6 normal.
 		{name: "ipv6 normal", ip: "2602:100::1", expected: "2602:100::"},
--- a/addrmgr/test_coverage.txt
+++ b/addrmgr/test_coverage.txt
@@ -1,62 +0,0 @@
-
-github.com/conformal/btcd/addrmgr/network.go		 GroupKey				 100.00% (23/23)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.reset			 100.00% (6/6)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC5737				 100.00% (4/4)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC1918				 100.00% (4/4)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 New					 100.00% (3/3)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 NetAddressKey				 100.00% (2/2)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC4862				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.numAddresses		 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/log.go		 init					 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/log.go		 DisableLog				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 ipNet					 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsIPv4					 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsLocal				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsOnionCatTor				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC2544				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC3849				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC3927				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC3964				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC4193				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC4380				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC4843				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC6052				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC6145				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRFC6598				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsValid				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/network.go		 IsRoutable				 100.00% (1/1)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.GetBestLocalAddress	 94.74% (18/19)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.AddLocalAddress		 90.91% (10/11)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 getReachabilityFrom			 51.52% (17/33)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 ipString				 50.00% (2/4)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.GetAddress			 9.30% (4/43)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.deserializePeers		 0.00% (0/50)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.Good			 0.00% (0/44)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.savePeers			 0.00% (0/39)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.updateAddress		 0.00% (0/30)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.expireNew			 0.00% (0/22)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.AddressCache		 0.00% (0/16)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.HostToNetAddress		 0.00% (0/15)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.getNewBucket		 0.00% (0/15)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.AddAddressByIP		 0.00% (0/14)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.getTriedBucket		 0.00% (0/14)
-github.com/conformal/btcd/addrmgr/knownaddress.go	 knownAddress.chance			 0.00% (0/13)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.loadPeers			 0.00% (0/11)
-github.com/conformal/btcd/addrmgr/knownaddress.go	 knownAddress.isBad			 0.00% (0/11)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.Connected			 0.00% (0/10)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.addressHandler		 0.00% (0/9)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.pickTried			 0.00% (0/8)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.DeserializeNetAddress	 0.00% (0/7)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.Stop			 0.00% (0/7)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.Attempt			 0.00% (0/7)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.Start			 0.00% (0/6)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.AddAddresses		 0.00% (0/4)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.NeedMoreAddresses		 0.00% (0/3)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.NumAddresses		 0.00% (0/3)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.AddAddress			 0.00% (0/3)
-github.com/conformal/btcd/addrmgr/knownaddress.go	 knownAddress.LastAttempt		 0.00% (0/1)
-github.com/conformal/btcd/addrmgr/knownaddress.go	 knownAddress.NetAddress		 0.00% (0/1)
-github.com/conformal/btcd/addrmgr/addrmanager.go	 AddrManager.find			 0.00% (0/1)
-github.com/conformal/btcd/addrmgr/log.go		 UseLogger				 0.00% (0/1)
-github.com/conformal/btcd/addrmgr			 ---------------------------------	 21.04% (113/537)
-
--- a/blockdag/README.md
+++ b/blockdag/README.md
@@ -1,7 +1,7 @@
 blockchain
 ==========

-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](https://choosealicense.com/licenses/isc/)
 [![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/kaspanet/kaspad/blockchain)

 Package blockdag implements Kaspa block handling, organization of the blockDAG, 
--- a/blockdag/accept.go
+++ b/blockdag/accept.go
@@ -8,11 +8,12 @@ import (
 	"fmt"
 	"github.com/kaspanet/kaspad/database"
 	"github.com/kaspanet/kaspad/util"
+	"github.com/pkg/errors"
 )

 func (dag *BlockDAG) addNodeToIndexWithInvalidAncestor(block *util.Block) error {
 	blockHeader := &block.MsgBlock().Header
-	newNode := newBlockNode(blockHeader, newSet(), dag.dagParams.K)
+	newNode, _ := dag.newBlockNode(blockHeader, newBlockSet())
 	newNode.status = statusInvalidAncestor
 	dag.index.AddNode(newNode)
 	return dag.index.flushToDB()
@@ -30,7 +31,8 @@ func (dag *BlockDAG) addNodeToIndexWithInvalidAncestor(block *util.Block) error
 func (dag *BlockDAG) maybeAcceptBlock(block *util.Block, flags BehaviorFlags) error {
 	parents, err := lookupParentNodes(block, dag)
 	if err != nil {
-		if rErr, ok := err.(RuleError); ok && rErr.ErrorCode == ErrInvalidAncestorBlock {
+		var ruleErr RuleError
+		if ok := errors.As(err, &ruleErr); ok && ruleErr.ErrorCode == ErrInvalidAncestorBlock {
 			err := dag.addNodeToIndexWithInvalidAncestor(block)
 			if err != nil {
 				return err
@@ -47,7 +49,7 @@ func (dag *BlockDAG) maybeAcceptBlock(block *util.Block, flags BehaviorFlags) er
 	}

 	// Create a new block node for the block and add it to the node index.
-	newNode := newBlockNode(&block.MsgBlock().Header, parents, dag.dagParams.K)
+	newNode, selectedParentAnticone := dag.newBlockNode(&block.MsgBlock().Header, parents)
 	newNode.status = statusDataStored
 	dag.index.AddNode(newNode)

@@ -80,11 +82,11 @@ func (dag *BlockDAG) maybeAcceptBlock(block *util.Block, flags BehaviorFlags) er
 		}
 	}

-	block.SetChainHeight(newNode.chainHeight)
+	block.SetBlueScore(newNode.blueScore)

 	// Connect the passed block to the DAG. This also handles validation of the
 	// transaction scripts.
-	chainUpdates, err := dag.addBlock(newNode, parents, block, flags)
+	chainUpdates, err := dag.addBlock(newNode, block, selectedParentAnticone, flags)
 	if err != nil {
 		return err
 	}
@@ -112,14 +114,14 @@ func lookupParentNodes(block *util.Block, blockDAG *BlockDAG) (blockSet, error)
 	header := block.MsgBlock().Header
 	parentHashes := header.ParentHashes

-	nodes := newSet()
+	nodes := newBlockSet()
 	for _, parentHash := range parentHashes {
 		node := blockDAG.index.LookupNode(parentHash)
 		if node == nil {
-			str := fmt.Sprintf("parent block %s is unknown", parentHashes)
+			str := fmt.Sprintf("parent block %s is unknown", parentHash)
 			return nil, ruleError(ErrParentBlockUnknown, str)
 		} else if blockDAG.index.NodeStatus(node).KnownInvalid() {
-			str := fmt.Sprintf("parent block %s is known to be invalid", parentHashes)
+			str := fmt.Sprintf("parent block %s is known to be invalid", parentHash)
 			return nil, ruleError(ErrInvalidAncestorBlock, str)
 		}

--- a/blockdag/accept_test.go
+++ b/blockdag/accept_test.go
@@ -1,21 +1,17 @@
 package blockdag

 import (
-	"github.com/pkg/errors"
+	"errors"
 	"path/filepath"
-	"strings"
 	"testing"

-	"bou.ke/monkey"
 	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
 )

 func TestMaybeAcceptBlockErrors(t *testing.T) {
 	// Create a new database and DAG instance to run tests against.
 	dag, teardownFunc, err := DAGSetup("TestMaybeAcceptBlockErrors", Config{
-		DAGParams: &dagconfig.SimNetParams,
+		DAGParams: &dagconfig.SimnetParams,
 	})
 	if err != nil {
 		t.Fatalf("TestMaybeAcceptBlockErrors: Failed to setup DAG instance: %v", err)
@@ -38,8 +34,8 @@ func TestMaybeAcceptBlockErrors(t *testing.T) {
 		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are missing: "+
 			"Expected: %s, got: <nil>", ErrParentBlockUnknown)
 	}
-	ruleErr, ok := err.(RuleError)
-	if !ok {
+	var ruleErr RuleError
+	if ok := errors.As(err, &ruleErr); !ok {
 		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are missing: "+
 			"Expected RuleError but got %s", err)
 	} else if ruleErr.ErrorCode != ErrParentBlockUnknown {
@@ -57,11 +53,11 @@ func TestMaybeAcceptBlockErrors(t *testing.T) {

 	// Add a valid block and mark it as invalid
 	block1 := blocks[1]
-	isOrphan, delay, err := dag.ProcessBlock(block1, BFNone)
+	isOrphan, isDelayed, err := dag.ProcessBlock(block1, BFNone)
 	if err != nil {
 		t.Fatalf("TestMaybeAcceptBlockErrors: Valid block unexpectedly returned an error: %s", err)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("TestMaybeAcceptBlockErrors: block 1 is too far in the future")
 	}
 	if isOrphan {
@@ -76,8 +72,7 @@ func TestMaybeAcceptBlockErrors(t *testing.T) {
 		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are invalid: "+
 			"Expected: %s, got: <nil>", ErrInvalidAncestorBlock)
 	}
-	ruleErr, ok = err.(RuleError)
-	if !ok {
+	if ok := errors.As(err, &ruleErr); !ok {
 		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block if its parents are invalid: "+
 			"Expected RuleError but got %s", err)
 	} else if ruleErr.ErrorCode != ErrInvalidAncestorBlock {
@@ -96,8 +91,7 @@ func TestMaybeAcceptBlockErrors(t *testing.T) {
 		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block due to bad context: "+
 			"Expected: %s, got: <nil>", ErrUnexpectedDifficulty)
 	}
-	ruleErr, ok = err.(RuleError)
-	if !ok {
+	if ok := errors.As(err, &ruleErr); !ok {
 		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the block due to bad context: "+
 			"Expected RuleError but got %s", err)
 	} else if ruleErr.ErrorCode != ErrUnexpectedDifficulty {
@@ -107,37 +101,4 @@ func TestMaybeAcceptBlockErrors(t *testing.T) {

 	// Set block2's bits back to valid for next tests
 	block2.MsgBlock().Header.Bits = originalBits
-
-	// Test rejecting the node due to database error
-	databaseErrorMessage := "database error"
-	guard := monkey.Patch(dbStoreBlock, func(dbTx database.Tx, block *util.Block) error {
-		return errors.New(databaseErrorMessage)
-	})
-	defer guard.Unpatch()
-	err = dag.maybeAcceptBlock(block2, BFNone)
-	if err == nil {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the node due to database error: "+
-			"Expected: %s, got: <nil>", databaseErrorMessage)
-	}
-	if !strings.Contains(err.Error(), databaseErrorMessage) {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the node due to database error: "+
-			"Unexpected error. Want: %s, got: %s", databaseErrorMessage, err)
-	}
-	guard.Unpatch()
-
-	// Test rejecting the node due to index error
-	indexErrorMessage := "index error"
-	guard = monkey.Patch((*blockIndex).flushToDB, func(_ *blockIndex) error {
-		return errors.New(indexErrorMessage)
-	})
-	defer guard.Unpatch()
-	err = dag.maybeAcceptBlock(block2, BFNone)
-	if err == nil {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the node due to index error: "+
-			"Expected %s, got: <nil>", indexErrorMessage)
-	}
-	if !strings.Contains(err.Error(), indexErrorMessage) {
-		t.Errorf("TestMaybeAcceptBlockErrors: rejecting the node due to index error: "+
-			"Unexpected error. Want: %s, got: %s", indexErrorMessage, err)
-	}
 }
--- a/blockdag/blockheap.go
+++ b/blockdag/blockheap.go
@@ -2,8 +2,6 @@ package blockdag

 import (
 	"container/heap"
-
-	"github.com/kaspanet/kaspad/util/daghash"
 )

 // baseHeap is an implementation for heap.Interface that sorts blocks by their height
@@ -28,22 +26,14 @@ func (h *baseHeap) Pop() interface{} {
 type upHeap struct{ baseHeap }

 func (h upHeap) Less(i, j int) bool {
-	if h.baseHeap[i].blueScore == h.baseHeap[j].blueScore {
-		return daghash.HashToBig(h.baseHeap[i].hash).Cmp(daghash.HashToBig(h.baseHeap[j].hash)) < 0
-	}
-
-	return h.baseHeap[i].blueScore < h.baseHeap[j].blueScore
+	return h.baseHeap[i].less(h.baseHeap[j])
 }

 // downHeap extends baseHeap to include Less operation that traverses from top to bottom
 type downHeap struct{ baseHeap }

 func (h downHeap) Less(i, j int) bool {
-	if h.baseHeap[i].blueScore == h.baseHeap[j].blueScore {
-		return daghash.HashToBig(h.baseHeap[i].hash).Cmp(daghash.HashToBig(h.baseHeap[j].hash)) > 0
-	}
-
-	return h.baseHeap[i].blueScore > h.baseHeap[j].blueScore
+	return !h.baseHeap[i].less(h.baseHeap[j])
 }

 // blockHeap represents a mutable heap of Blocks, sorted by their height
@@ -77,7 +67,7 @@ func (bh blockHeap) Push(block *blockNode) {

 // pushSet pushes a blockset to the heap.
 func (bh blockHeap) pushSet(bs blockSet) {
-	for _, block := range bs {
+	for block := range bs {
 		heap.Push(bh.impl, block)
 	}
 }
--- a/blockdag/blockheap_test.go
+++ b/blockdag/blockheap_test.go
@@ -9,13 +9,22 @@ import (

 // TestBlockHeap tests pushing, popping, and determining the length of the heap.
 func TestBlockHeap(t *testing.T) {
-	block0Header := dagconfig.MainNetParams.GenesisBlock.Header
-	block0 := newBlockNode(&block0Header, newSet(), dagconfig.MainNetParams.K)
+	// Create a new database and DAG instance to run tests against.
+	dag, teardownFunc, err := DAGSetup("TestBlockHeap", Config{
+		DAGParams: &dagconfig.MainnetParams,
+	})
+	if err != nil {
+		t.Fatalf("TestBlockHeap: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()
+
+	block0Header := dagconfig.MainnetParams.GenesisBlock.Header
+	block0, _ := dag.newBlockNode(&block0Header, newBlockSet())

 	block100000Header := Block100000.Header
-	block100000 := newBlockNode(&block100000Header, setFromSlice(block0), dagconfig.MainNetParams.K)
+	block100000, _ := dag.newBlockNode(&block100000Header, blockSetFromSlice(block0))

-	block0smallHash := newBlockNode(&block0Header, newSet(), dagconfig.MainNetParams.K)
+	block0smallHash, _ := dag.newBlockNode(&block0Header, newBlockSet())
 	block0smallHash.hash = &daghash.Hash{}

 	tests := []struct {
--- a/blockdag/blockindex.go
+++ b/blockdag/blockindex.go
@@ -43,8 +43,8 @@ func newBlockIndex(db database.DB, dagParams *dagconfig.Params) *blockIndex {
 // This function is safe for concurrent access.
 func (bi *blockIndex) HaveBlock(hash *daghash.Hash) bool {
 	bi.RLock()
+	defer bi.RUnlock()
 	_, hasBlock := bi.index[*hash]
-	bi.RUnlock()
 	return hasBlock
 }

@@ -54,8 +54,8 @@ func (bi *blockIndex) HaveBlock(hash *daghash.Hash) bool {
 // This function is safe for concurrent access.
 func (bi *blockIndex) LookupNode(hash *daghash.Hash) *blockNode {
 	bi.RLock()
+	defer bi.RUnlock()
 	node := bi.index[*hash]
-	bi.RUnlock()
 	return node
 }

@@ -65,9 +65,9 @@ func (bi *blockIndex) LookupNode(hash *daghash.Hash) *blockNode {
 // This function is safe for concurrent access.
 func (bi *blockIndex) AddNode(node *blockNode) {
 	bi.Lock()
+	defer bi.Unlock()
 	bi.addNode(node)
 	bi.dirty[node] = struct{}{}
-	bi.Unlock()
 }

 // addNode adds the provided node to the block index, but does not mark it as
@@ -83,8 +83,8 @@ func (bi *blockIndex) addNode(node *blockNode) {
 // This function is safe for concurrent access.
 func (bi *blockIndex) NodeStatus(node *blockNode) blockStatus {
 	bi.RLock()
+	defer bi.RUnlock()
 	status := node.status
-	bi.RUnlock()
 	return status
 }

@@ -95,9 +95,9 @@ func (bi *blockIndex) NodeStatus(node *blockNode) blockStatus {
 // This function is safe for concurrent access.
 func (bi *blockIndex) SetStatusFlags(node *blockNode, flags blockStatus) {
 	bi.Lock()
+	defer bi.Unlock()
 	node.status |= flags
 	bi.dirty[node] = struct{}{}
-	bi.Unlock()
 }

 // UnsetStatusFlags flips the provided status flags on the block node to off,
@@ -106,9 +106,9 @@ func (bi *blockIndex) SetStatusFlags(node *blockNode, flags blockStatus) {
 // This function is safe for concurrent access.
 func (bi *blockIndex) UnsetStatusFlags(node *blockNode, flags blockStatus) {
 	bi.Lock()
+	defer bi.Unlock()
 	node.status &^= flags
 	bi.dirty[node] = struct{}{}
-	bi.Unlock()
 }

 // flushToDB writes all dirty block nodes to the database. If all writes
@@ -134,8 +134,9 @@ func (bi *blockIndex) flushToDBWithTx(dbTx database.Tx) error {
 			return err
 		}
 	}
-
-	// If write was successful, clear the dirty set.
-	bi.dirty = make(map[*blockNode]struct{})
 	return nil
 }
+
+func (bi *blockIndex) clearDirtyEntries() {
+	bi.dirty = make(map[*blockNode]struct{})
+}
--- a/blockdag/blockindex_test.go
+++ b/blockdag/blockindex_test.go
@@ -1,58 +1,27 @@
 package blockdag

 import (
-	"github.com/pkg/errors"
-	"strings"
 	"testing"
 	"time"

-	"bou.ke/monkey"
 	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
 )

 func TestAncestorErrors(t *testing.T) {
-	node := newTestNode(newSet(), int32(0x10000000), 0, time.Unix(0, 0), dagconfig.MainNetParams.K)
-	node.chainHeight = 2
+	// Create a new database and DAG instance to run tests against.
+	params := dagconfig.SimnetParams
+	dag, teardownFunc, err := DAGSetup("TestAncestorErrors", Config{
+		DAGParams: &params,
+	})
+	if err != nil {
+		t.Fatalf("TestAncestorErrors: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()
+
+	node := newTestNode(dag, newBlockSet(), int32(0x10000000), 0, time.Unix(0, 0))
+	node.blueScore = 2
 	ancestor := node.SelectedAncestor(3)
 	if ancestor != nil {
 		t.Errorf("TestAncestorErrors: Ancestor() unexpectedly returned a node. Expected: <nil>")
 	}
 }
-
-func TestFlushToDBErrors(t *testing.T) {
-	// Create a new database and DAG instance to run tests against.
-	dag, teardownFunc, err := DAGSetup("TestFlushToDBErrors", Config{
-		DAGParams: &dagconfig.SimNetParams,
-	})
-	if err != nil {
-		t.Fatalf("TestFlushToDBErrors: Failed to setup DAG instance: %s", err)
-	}
-	defer teardownFunc()
-
-	// Call flushToDB without anything to flush. This should succeed
-	err = dag.index.flushToDB()
-	if err != nil {
-		t.Errorf("TestFlushToDBErrors: flushToDB without anything to flush: "+
-			"Unexpected flushToDB error: %s", err)
-	}
-
-	// Mark the genesis block as dirty
-	dag.index.SetStatusFlags(dag.genesis, statusValid)
-
-	// Test flushToDB failure due to database error
-	databaseErrorMessage := "database error"
-	guard := monkey.Patch(dbStoreBlockNode, func(_ database.Tx, _ *blockNode) error {
-		return errors.New(databaseErrorMessage)
-	})
-	defer guard.Unpatch()
-	err = dag.index.flushToDB()
-	if err == nil {
-		t.Errorf("TestFlushToDBErrors: flushToDB failure due to database error: "+
-			"Expected: %s, got: <nil>", databaseErrorMessage)
-	}
-	if !strings.Contains(err.Error(), databaseErrorMessage) {
-		t.Errorf("TestFlushToDBErrors: flushToDB failure due to database error: "+
-			"Unexpected flushToDB error. Expected: %s, got: %s", databaseErrorMessage, err)
-	}
-}
--- a/blockdag/blocklocator.go
+++ b/blockdag/blocklocator.go
@@ -1,8 +1,8 @@
 package blockdag

 import (
-	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/pkg/errors"
 )

 // BlockLocator is used to help locate a specific block. The algorithm for
@@ -21,100 +21,59 @@ import (
 //  [17 16 14 11 7 2 genesis]
 type BlockLocator []*daghash.Hash

-// BlockLocatorFromHashes returns a block locator from start and stop hash.
+// BlockLocatorFromHashes returns a block locator from high and low hash.
 // See BlockLocator for details on the algorithm used to create a block locator.
 //
-// In addition to the general algorithm referenced above, this function will
-// return the block locator for the selected tip if the passed hash is not currently
-// known.
-//
 // This function is safe for concurrent access.
-func (dag *BlockDAG) BlockLocatorFromHashes(startHash, stopHash *daghash.Hash) BlockLocator {
+func (dag *BlockDAG) BlockLocatorFromHashes(highHash, lowHash *daghash.Hash) (BlockLocator, error) {
 	dag.dagLock.RLock()
 	defer dag.dagLock.RUnlock()
-	startNode := dag.index.LookupNode(startHash)
-	var stopNode *blockNode
-	if !stopHash.IsEqual(&daghash.ZeroHash) {
-		stopNode = dag.index.LookupNode(stopHash)
-	}
-	return dag.blockLocator(startNode, stopNode)
+
+	highNode := dag.index.LookupNode(highHash)
+	lowNode := dag.index.LookupNode(lowHash)
+
+	return dag.blockLocator(highNode, lowNode)
 }

-// LatestBlockLocator returns a block locator for the current tips of the DAG.
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) LatestBlockLocator() BlockLocator {
-	dag.dagLock.RLock()
-	defer dag.dagLock.RUnlock()
-	return dag.blockLocator(nil, nil)
-}
-
-// blockLocator returns a block locator for the passed start and stop nodes.
-// The default value for the start node is the selected tip, and the default
-// values of the stop node is the genesis block.
-//
+// blockLocator returns a block locator for the passed high and low nodes.
 // See the BlockLocator type comments for more details.
 //
 // This function MUST be called with the DAG state lock held (for reads).
-func (dag *BlockDAG) blockLocator(startNode, stopNode *blockNode) BlockLocator {
-	// Use the selected tip if requested.
-	if startNode == nil {
-		startNode = dag.virtual.selectedParent
-	}
-
-	if stopNode == nil {
-		stopNode = dag.genesis
-	}
-
-	// We use the selected parent of the start node, so the
-	// block locator won't contain the start node.
-	startNode = startNode.selectedParent
-
-	// If the start node or the stop node are not in the
-	// virtual's selected parent chain, we replace them with their
-	// closest selected parent that is part of the virtual's
-	// selected parent chain.
-	for !dag.IsInSelectedParentChain(stopNode.hash) {
-		stopNode = stopNode.selectedParent
-	}
-
-	for !dag.IsInSelectedParentChain(startNode.hash) {
-		startNode = startNode.selectedParent
-	}
-
-	// Calculate the max number of entries that will ultimately be in the
-	// block locator. See the description of the algorithm for how these
-	// numbers are derived.
-
-	// startNode.hash + stopNode.hash.
-	// Then floor(log2(startNode.chainHeight-stopNode.chainHeight)) entries for the skip portion.
-	maxEntries := 2 + util.FastLog2Floor(startNode.chainHeight-stopNode.chainHeight)
-	locator := make(BlockLocator, 0, maxEntries)
+func (dag *BlockDAG) blockLocator(highNode, lowNode *blockNode) (BlockLocator, error) {
+	// We use the selected parent of the high node, so the
+	// block locator won't contain the high node.
+	highNode = highNode.selectedParent

+	node := highNode
 	step := uint64(1)
-	for node := startNode; node != nil; {
+	locator := make(BlockLocator, 0)
+	for node != nil {
 		locator = append(locator, node.hash)

-		// Nothing more to add once the stop node has been added.
-		if node.chainHeight == stopNode.chainHeight {
+		// Nothing more to add once the low node has been added.
+		if node.blueScore <= lowNode.blueScore {
+			if node != lowNode {
+				return nil, errors.Errorf("highNode and lowNode are " +
+					"not in the same selected parent chain.")
+			}
 			break
 		}

-		// Calculate chainHeight of previous node to include ensuring the
-		// final node is stopNode.
-		nextChainHeight := node.chainHeight - step
-		if nextChainHeight < stopNode.chainHeight {
-			nextChainHeight = stopNode.chainHeight
+		// Calculate blueScore of previous node to include ensuring the
+		// final node is lowNode.
+		nextBlueScore := node.blueScore - step
+		if nextBlueScore < lowNode.blueScore {
+			nextBlueScore = lowNode.blueScore
 		}

 		// walk backwards through the nodes to the correct ancestor.
-		node = node.SelectedAncestor(nextChainHeight)
+		node = node.SelectedAncestor(nextBlueScore)

 		// Double the distance between included hashes.
 		step *= 2
 	}

-	return locator
+	return locator, nil
 }

 // FindNextLocatorBoundaries returns the lowest unknown block locator, hash
@@ -123,21 +82,21 @@ func (dag *BlockDAG) blockLocator(startNode, stopNode *blockNode) BlockLocator {
 // sync peer.
 //
 // This function MUST be called with the DAG state lock held (for reads).
-func (dag *BlockDAG) FindNextLocatorBoundaries(locator BlockLocator) (startHash, stopHash *daghash.Hash) {
+func (dag *BlockDAG) FindNextLocatorBoundaries(locator BlockLocator) (highHash, lowHash *daghash.Hash) {
 	// Find the most recent locator block hash in the DAG. In the case none of
 	// the hashes in the locator are in the DAG, fall back to the genesis block.
-	stopNode := dag.genesis
+	lowNode := dag.genesis
 	nextBlockLocatorIndex := int64(len(locator) - 1)
 	for i, hash := range locator {
 		node := dag.index.LookupNode(hash)
 		if node != nil {
-			stopNode = node
+			lowNode = node
 			nextBlockLocatorIndex = int64(i) - 1
 			break
 		}
 	}
 	if nextBlockLocatorIndex < 0 {
-		return nil, stopNode.hash
+		return nil, lowNode.hash
 	}
-	return locator[nextBlockLocatorIndex], stopNode.hash
+	return locator[nextBlockLocatorIndex], lowNode.hash
 }
--- a/blockdag/blocknode.go
+++ b/blockdag/blocknode.go
@@ -6,6 +6,9 @@ package blockdag

 import (
 	"fmt"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/pkg/errors"
+	"math"
 	"time"

 	"github.com/kaspanet/kaspad/util/daghash"
@@ -28,11 +31,6 @@ const (
 	// statusInvalidAncestor indicates that one of the block's ancestors has
 	// has failed validation, thus the block is also invalid.
 	statusInvalidAncestor
-
-	// statusNone indicates that the block has no validation state flags set.
-	//
-	// NOTE: This must be defined last in order to avoid influencing iota.
-	statusNone blockStatus = 0
 )

 // KnownValid returns whether the block is known to be valid. This will return
@@ -75,12 +73,13 @@ type blockNode struct {
 	// blueScore is the count of all the blue blocks in this block's past
 	blueScore uint64

+	// bluesAnticoneSizes is a map holding the set of blues affected by this block and their
+	// modified blue anticone size.
+	bluesAnticoneSizes map[*blockNode]dagconfig.KType
+
 	// hash is the double sha 256 of the block.
 	hash *daghash.Hash

-	// chainHeight is the number of hops you need to go down the selected parent chain in order to get to the genesis block.
-	chainHeight uint64
-
 	// Some fields from block headers to aid in  reconstructing headers
 	// from memory. These must be treated as immutable and are intentionally
 	// ordered to avoid padding on 64-bit platforms.
@@ -102,14 +101,17 @@ type blockNode struct {
 	isFinalized bool
 }

-// initBlockNode initializes a block node from the given header and parent nodes.
-// This function is NOT safe for concurrent access. It must only be called when
-// initially creating a node.
-func initBlockNode(node *blockNode, blockHeader *wire.BlockHeader, parents blockSet, phantomK uint32) {
-	*node = blockNode{
-		parents:   parents,
-		children:  make(blockSet),
-		timestamp: time.Now().Unix(),
+// newBlockNode returns a new block node for the given block header and parents, and the
+// anticone of its selected parent (parent with highest blue score).
+// selectedParentAnticone is used to update reachability data we store for future reachability queries.
+// This function is NOT safe for concurrent access.
+func (dag *BlockDAG) newBlockNode(blockHeader *wire.BlockHeader, parents blockSet) (node *blockNode, selectedParentAnticone []*blockNode) {
+	node = &blockNode{
+		parents:            parents,
+		children:           make(blockSet),
+		blueScore:          math.MaxUint64, // Initialized to the max value to avoid collisions with the genesis block
+		timestamp:          dag.AdjustedTime().Unix(),
+		bluesAnticoneSizes: make(map[*blockNode]dagconfig.KType),
 	}

 	// blockHeader is nil only for the virtual block
@@ -126,34 +128,34 @@ func initBlockNode(node *blockNode, blockHeader *wire.BlockHeader, parents block
 		node.hash = &daghash.ZeroHash
 	}

-	if len(parents) > 0 {
-		node.blues, node.selectedParent, node.blueScore = phantom(node, phantomK)
-		node.chainHeight = calculateChainHeight(node)
+	if len(parents) == 0 {
+		// The genesis block is defined to have a blueScore of 0
+		node.blueScore = 0
+		return node, nil
 	}
-}

-func calculateChainHeight(node *blockNode) uint64 {
-	if node.isGenesis() {
-		return 0
+	selectedParentAnticone, err := dag.ghostdag(node)
+	if err != nil {
+		panic(errors.Wrap(err, "unexpected error in GHOSTDAG"))
 	}
-	return node.selectedParent.chainHeight + 1
-}
-
-// newBlockNode returns a new block node for the given block header and parent
-//nodes. This function is NOT safe for concurrent access.
-func newBlockNode(blockHeader *wire.BlockHeader, parents blockSet, phantomK uint32) *blockNode {
-	var node blockNode
-	initBlockNode(&node, blockHeader, parents, phantomK)
-	return &node
+	return node, selectedParentAnticone
 }

 // updateParentsChildren updates the node's parents to point to new node
 func (node *blockNode) updateParentsChildren() {
-	for _, parent := range node.parents {
+	for parent := range node.parents {
 		parent.children.add(node)
 	}
 }

+func (node *blockNode) less(other *blockNode) bool {
+	if node.blueScore == other.blueScore {
+		return daghash.Less(node.hash, other.hash)
+	}
+
+	return node.blueScore < other.blueScore
+}
+
 // Header constructs a block header from the node and returns it.
 //
 // This function is safe for concurrent access.
@@ -171,31 +173,31 @@ func (node *blockNode) Header() *wire.BlockHeader {
 	}
 }

-// SelectedAncestor returns the ancestor block node at the provided chain-height by following
+// SelectedAncestor returns the ancestor block node at the provided blue score by following
 // the selected-parents chain backwards from this node. The returned block will be nil when a
-// height is requested that is after the height of the passed node.
+// blue score is requested that is higher than the blue score of the passed node.
 //
 // This function is safe for concurrent access.
-func (node *blockNode) SelectedAncestor(chainHeight uint64) *blockNode {
-	if chainHeight < 0 || chainHeight > node.chainHeight {
+func (node *blockNode) SelectedAncestor(blueScore uint64) *blockNode {
+	if blueScore > node.blueScore {
 		return nil
 	}

 	n := node
-	for ; n != nil && n.chainHeight != chainHeight; n = n.selectedParent {
-		// Intentionally left blank
+	for n != nil && n.blueScore > blueScore {
+		n = n.selectedParent
 	}

 	return n
 }

 // RelativeAncestor returns the ancestor block node a relative 'distance' of
-// chain-blocks before this node. This is equivalent to calling Ancestor with
-// the node's chain-height minus provided distance.
+// blue blocks before this node. This is equivalent to calling Ancestor with
+// the node's blue score minus provided distance.
 //
 // This function is safe for concurrent access.
 func (node *blockNode) RelativeAncestor(distance uint64) *blockNode {
-	return node.SelectedAncestor(node.chainHeight - distance)
+	return node.SelectedAncestor(node.blueScore - distance)
 }

 // CalcPastMedianTime returns the median time of the previous few blocks
--- a/blockdag/blocknode_test.go
+++ b/blockdag/blocknode_test.go
@@ -1,86 +1,41 @@
 package blockdag

 import (
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/daghash"
 	"testing"
 )

-func TestChainHeight(t *testing.T) {
-	phantomK := uint32(2)
-	buildNode := buildNodeGenerator(phantomK, true)
+// This test is to ensure the size BlueAnticoneSizesSize is serialized to the size of KType.
+// We verify that by serializing and deserializing the block while making sure that we stay within the expected range.
+func TestBlueAnticoneSizesSize(t *testing.T) {
+	dag, teardownFunc, err := DAGSetup("TestBlueAnticoneSizesSize", Config{
+		DAGParams: &dagconfig.SimnetParams,
+	})
+	if err != nil {
+		t.Fatalf("TestBlueAnticoneSizesSize: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()

-	node0 := buildNode(setFromSlice())
-	node1 := buildNode(setFromSlice(node0))
-	node2 := buildNode(setFromSlice(node0))
-	node3 := buildNode(setFromSlice(node0))
-	node4 := buildNode(setFromSlice(node1, node2, node3))
-	node5 := buildNode(setFromSlice(node1, node2, node3))
-	node6 := buildNode(setFromSlice(node1, node2, node3))
-	node7 := buildNode(setFromSlice(node0))
-	node8 := buildNode(setFromSlice(node7))
-	node9 := buildNode(setFromSlice(node8))
-	node10 := buildNode(setFromSlice(node9, node6))
+	k := dagconfig.KType(0)
+	k--

-	// Because nodes 7 & 8 were mined secretly, node10's selected
-	// parent will be node6, although node9 is higher. So in this
-	// case, node10.height and node10.chainHeight will be different
-
-	tests := []struct {
-		node                *blockNode
-		expectedChainHeight uint64
-	}{
-		{
-			node:                node0,
-			expectedChainHeight: 0,
-		},
-		{
-			node:                node1,
-			expectedChainHeight: 1,
-		},
-		{
-			node:                node2,
-			expectedChainHeight: 1,
-		},
-		{
-			node:                node3,
-			expectedChainHeight: 1,
-		},
-		{
-			node:                node4,
-			expectedChainHeight: 2,
-		},
-		{
-			node:                node5,
-			expectedChainHeight: 2,
-		},
-		{
-			node:                node6,
-			expectedChainHeight: 2,
-		},
-		{
-			node:                node7,
-			expectedChainHeight: 1,
-		},
-		{
-			node:                node8,
-			expectedChainHeight: 2,
-		},
-		{
-			node:                node9,
-			expectedChainHeight: 3,
-		},
-		{
-			node:                node10,
-			expectedChainHeight: 3,
-		},
+	if k < dagconfig.KType(0) {
+		t.Fatalf("KType must be unsigned")
 	}

-	for _, test := range tests {
-		if test.node.chainHeight != test.expectedChainHeight {
-			t.Errorf("block %v expected chain height %v but got %v", test.node, test.expectedChainHeight, test.node.chainHeight)
-		}
-		if calculateChainHeight(test.node) != test.expectedChainHeight {
-			t.Errorf("block %v expected calculated chain height %v but got %v", test.node, test.expectedChainHeight, test.node.chainHeight)
-		}
+	blockHeader := dagconfig.SimnetParams.GenesisBlock.Header
+	node, _ := dag.newBlockNode(&blockHeader, newBlockSet())
+	fakeBlue := &blockNode{hash: &daghash.Hash{1}}
+	dag.index.AddNode(fakeBlue)
+	// Setting maxKType to maximum value of KType.
+	// As we verify above that KType is unsigned we can be sure that maxKType is indeed the maximum value of KType.
+	maxKType := ^dagconfig.KType(0)
+	node.bluesAnticoneSizes[fakeBlue] = maxKType
+	serializedNode, _ := serializeBlockNode(node)
+	deserializedNode, _ := dag.deserializeBlockNode(serializedNode)
+	if deserializedNode.bluesAnticoneSizes[fakeBlue] != maxKType {
+		t.Fatalf("TestBlueAnticoneSizesSize: BlueAnticoneSize should not change when deserializing. Expected: %v but got %v",
+			maxKType, deserializedNode.bluesAnticoneSizes[fakeBlue])
 	}
-
 }
--- a/blockdag/blockset.go
+++ b/blockdag/blockset.go
@@ -7,68 +7,68 @@ import (
 )

 // blockSet implements a basic unsorted set of blocks
-type blockSet map[daghash.Hash]*blockNode
+type blockSet map[*blockNode]struct{}

-// newSet creates a new, empty BlockSet
-func newSet() blockSet {
-	return map[daghash.Hash]*blockNode{}
+// newBlockSet creates a new, empty BlockSet
+func newBlockSet() blockSet {
+	return map[*blockNode]struct{}{}
 }

-// setFromSlice converts a slice of blocks into an unordered set represented as map
-func setFromSlice(blocks ...*blockNode) blockSet {
-	set := newSet()
-	for _, block := range blocks {
-		set.add(block)
+// blockSetFromSlice converts a slice of blockNodes into an unordered set represented as map
+func blockSetFromSlice(nodes ...*blockNode) blockSet {
+	set := newBlockSet()
+	for _, node := range nodes {
+		set.add(node)
 	}
 	return set
 }

-// add adds a block to this BlockSet
-func (bs blockSet) add(block *blockNode) {
-	bs[*block.hash] = block
+// add adds a blockNode to this BlockSet
+func (bs blockSet) add(node *blockNode) {
+	bs[node] = struct{}{}
 }

-// remove removes a block from this BlockSet, if exists
-// Does nothing if this set does not contain the block
-func (bs blockSet) remove(block *blockNode) {
-	delete(bs, *block.hash)
+// remove removes a blockNode from this BlockSet, if exists
+// Does nothing if this set does not contain the blockNode
+func (bs blockSet) remove(node *blockNode) {
+	delete(bs, node)
 }

 // clone clones thie block set
 func (bs blockSet) clone() blockSet {
-	clone := newSet()
-	for _, block := range bs {
-		clone.add(block)
+	clone := newBlockSet()
+	for node := range bs {
+		clone.add(node)
 	}
 	return clone
 }

 // subtract returns the difference between the BlockSet and another BlockSet
 func (bs blockSet) subtract(other blockSet) blockSet {
-	diff := newSet()
-	for _, block := range bs {
-		if !other.contains(block) {
-			diff.add(block)
+	diff := newBlockSet()
+	for node := range bs {
+		if !other.contains(node) {
+			diff.add(node)
 		}
 	}
 	return diff
 }

-// addSet adds all blocks in other set to this set
+// addSet adds all blockNodes in other set to this set
 func (bs blockSet) addSet(other blockSet) {
-	for _, block := range other {
-		bs.add(block)
+	for node := range other {
+		bs.add(node)
 	}
 }

 // addSlice adds provided slice to this set
 func (bs blockSet) addSlice(slice []*blockNode) {
-	for _, block := range slice {
-		bs.add(block)
+	for _, node := range slice {
+		bs.add(node)
 	}
 }

-// union returns a BlockSet that contains all blocks included in this set,
+// union returns a BlockSet that contains all blockNodes included in this set,
 // the other set, or both
 func (bs blockSet) union(other blockSet) blockSet {
 	union := bs.clone()
@@ -78,39 +78,16 @@ func (bs blockSet) union(other blockSet) blockSet {
 	return union
 }

-// contains returns true iff this set contains block
-func (bs blockSet) contains(block *blockNode) bool {
-	_, ok := bs[*block.hash]
+// contains returns true iff this set contains node
+func (bs blockSet) contains(node *blockNode) bool {
+	_, ok := bs[node]
 	return ok
 }

-// containsHash returns true iff this set contains a block hash
-func (bs blockSet) containsHash(hash *daghash.Hash) bool {
-	_, ok := bs[*hash]
-	return ok
-}
-
-// hashesEqual returns true if the given hashes are equal to the hashes
-// of the blocks in this set.
-// NOTE: The given hash slice must not contain duplicates.
-func (bs blockSet) hashesEqual(hashes []*daghash.Hash) bool {
-	if len(hashes) != len(bs) {
-		return false
-	}
-
-	for _, hash := range hashes {
-		if _, wasFound := bs[*hash]; !wasFound {
-			return false
-		}
-	}
-
-	return true
-}
-
-// hashes returns the hashes of the blocks in this set.
+// hashes returns the hashes of the blockNodes in this set.
 func (bs blockSet) hashes() []*daghash.Hash {
 	hashes := make([]*daghash.Hash, 0, len(bs))
-	for _, node := range bs {
+	for node := range bs {
 		hashes = append(hashes, node.hash)
 	}
 	daghash.Sort(hashes)
@@ -119,27 +96,16 @@ func (bs blockSet) hashes() []*daghash.Hash {

 func (bs blockSet) String() string {
 	nodeStrs := make([]string, 0, len(bs))
-	for _, node := range bs {
+	for node := range bs {
 		nodeStrs = append(nodeStrs, node.String())
 	}
 	return strings.Join(nodeStrs, ",")
 }

-// anyChildInSet returns true iff any child of block is contained within this set
-func (bs blockSet) anyChildInSet(block *blockNode) bool {
-	for _, child := range block.children {
-		if bs.contains(child) {
-			return true
-		}
-	}
-
-	return false
-}
-
 func (bs blockSet) bluest() *blockNode {
 	var bluestNode *blockNode
 	var maxScore uint64
-	for _, node := range bs {
+	for node := range bs {
 		if bluestNode == nil ||
 			node.blueScore > maxScore ||
 			(node.blueScore == maxScore && daghash.Less(node.hash, bluestNode.hash)) {
--- a/blockdag/blockset_test.go
+++ b/blockdag/blockset_test.go
@@ -8,7 +8,7 @@ import (
 )

 func TestHashes(t *testing.T) {
-	bs := setFromSlice(
+	bs := blockSetFromSlice(
 		&blockNode{
 			hash: &daghash.Hash{3},
 		},
@@ -49,33 +49,33 @@ func TestBlockSetSubtract(t *testing.T) {
 	}{
 		{
 			name:           "both sets empty",
-			setA:           setFromSlice(),
-			setB:           setFromSlice(),
-			expectedResult: setFromSlice(),
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(),
 		},
 		{
 			name:           "subtract an empty set",
-			setA:           setFromSlice(node1),
-			setB:           setFromSlice(),
-			expectedResult: setFromSlice(node1),
+			setA:           blockSetFromSlice(node1),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(node1),
 		},
 		{
 			name:           "subtract from empty set",
-			setA:           setFromSlice(),
-			setB:           setFromSlice(node1),
-			expectedResult: setFromSlice(),
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(node1),
+			expectedResult: blockSetFromSlice(),
 		},
 		{
 			name:           "subtract unrelated set",
-			setA:           setFromSlice(node1),
-			setB:           setFromSlice(node2),
-			expectedResult: setFromSlice(node1),
+			setA:           blockSetFromSlice(node1),
+			setB:           blockSetFromSlice(node2),
+			expectedResult: blockSetFromSlice(node1),
 		},
 		{
 			name:           "typical case",
-			setA:           setFromSlice(node1, node2),
-			setB:           setFromSlice(node2, node3),
-			expectedResult: setFromSlice(node1),
+			setA:           blockSetFromSlice(node1, node2),
+			setB:           blockSetFromSlice(node2, node3),
+			expectedResult: blockSetFromSlice(node1),
 		},
 	}

@@ -101,33 +101,33 @@ func TestBlockSetAddSet(t *testing.T) {
 	}{
 		{
 			name:           "both sets empty",
-			setA:           setFromSlice(),
-			setB:           setFromSlice(),
-			expectedResult: setFromSlice(),
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(),
 		},
 		{
 			name:           "add an empty set",
-			setA:           setFromSlice(node1),
-			setB:           setFromSlice(),
-			expectedResult: setFromSlice(node1),
+			setA:           blockSetFromSlice(node1),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(node1),
 		},
 		{
 			name:           "add to empty set",
-			setA:           setFromSlice(),
-			setB:           setFromSlice(node1),
-			expectedResult: setFromSlice(node1),
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(node1),
+			expectedResult: blockSetFromSlice(node1),
 		},
 		{
 			name:           "add already added member",
-			setA:           setFromSlice(node1, node2),
-			setB:           setFromSlice(node1),
-			expectedResult: setFromSlice(node1, node2),
+			setA:           blockSetFromSlice(node1, node2),
+			setB:           blockSetFromSlice(node1),
+			expectedResult: blockSetFromSlice(node1, node2),
 		},
 		{
 			name:           "typical case",
-			setA:           setFromSlice(node1, node2),
-			setB:           setFromSlice(node2, node3),
-			expectedResult: setFromSlice(node1, node2, node3),
+			setA:           blockSetFromSlice(node1, node2),
+			setB:           blockSetFromSlice(node2, node3),
+			expectedResult: blockSetFromSlice(node1, node2, node3),
 		},
 	}

@@ -153,33 +153,33 @@ func TestBlockSetAddSlice(t *testing.T) {
 	}{
 		{
 			name:           "add empty slice to empty set",
-			set:            setFromSlice(),
+			set:            blockSetFromSlice(),
 			slice:          []*blockNode{},
-			expectedResult: setFromSlice(),
+			expectedResult: blockSetFromSlice(),
 		},
 		{
 			name:           "add an empty slice",
-			set:            setFromSlice(node1),
+			set:            blockSetFromSlice(node1),
 			slice:          []*blockNode{},
-			expectedResult: setFromSlice(node1),
+			expectedResult: blockSetFromSlice(node1),
 		},
 		{
 			name:           "add to empty set",
-			set:            setFromSlice(),
+			set:            blockSetFromSlice(),
 			slice:          []*blockNode{node1},
-			expectedResult: setFromSlice(node1),
+			expectedResult: blockSetFromSlice(node1),
 		},
 		{
 			name:           "add already added member",
-			set:            setFromSlice(node1, node2),
+			set:            blockSetFromSlice(node1, node2),
 			slice:          []*blockNode{node1},
-			expectedResult: setFromSlice(node1, node2),
+			expectedResult: blockSetFromSlice(node1, node2),
 		},
 		{
 			name:           "typical case",
-			set:            setFromSlice(node1, node2),
+			set:            blockSetFromSlice(node1, node2),
 			slice:          []*blockNode{node2, node3},
-			expectedResult: setFromSlice(node1, node2, node3),
+			expectedResult: blockSetFromSlice(node1, node2, node3),
 		},
 	}

@@ -205,33 +205,33 @@ func TestBlockSetUnion(t *testing.T) {
 	}{
 		{
 			name:           "both sets empty",
-			setA:           setFromSlice(),
-			setB:           setFromSlice(),
-			expectedResult: setFromSlice(),
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(),
 		},
 		{
 			name:           "union against an empty set",
-			setA:           setFromSlice(node1),
-			setB:           setFromSlice(),
-			expectedResult: setFromSlice(node1),
+			setA:           blockSetFromSlice(node1),
+			setB:           blockSetFromSlice(),
+			expectedResult: blockSetFromSlice(node1),
 		},
 		{
 			name:           "union from an empty set",
-			setA:           setFromSlice(),
-			setB:           setFromSlice(node1),
-			expectedResult: setFromSlice(node1),
+			setA:           blockSetFromSlice(),
+			setB:           blockSetFromSlice(node1),
+			expectedResult: blockSetFromSlice(node1),
 		},
 		{
 			name:           "union with subset",
-			setA:           setFromSlice(node1, node2),
-			setB:           setFromSlice(node1),
-			expectedResult: setFromSlice(node1, node2),
+			setA:           blockSetFromSlice(node1, node2),
+			setB:           blockSetFromSlice(node1),
+			expectedResult: blockSetFromSlice(node1, node2),
 		},
 		{
 			name:           "typical case",
-			setA:           setFromSlice(node1, node2),
-			setB:           setFromSlice(node2, node3),
-			expectedResult: setFromSlice(node1, node2, node3),
+			setA:           blockSetFromSlice(node1, node2),
+			setB:           blockSetFromSlice(node2, node3),
+			expectedResult: blockSetFromSlice(node1, node2, node3),
 		},
 	}

@@ -243,54 +243,3 @@ func TestBlockSetUnion(t *testing.T) {
 		}
 	}
 }
-
-func TestBlockSetHashesEqual(t *testing.T) {
-	node1 := &blockNode{hash: &daghash.Hash{10}}
-	node2 := &blockNode{hash: &daghash.Hash{20}}
-
-	tests := []struct {
-		name           string
-		set            blockSet
-		hashes         []*daghash.Hash
-		expectedResult bool
-	}{
-		{
-			name:           "empty set, no hashes",
-			set:            setFromSlice(),
-			hashes:         []*daghash.Hash{},
-			expectedResult: true,
-		},
-		{
-			name:           "empty set, one hash",
-			set:            setFromSlice(),
-			hashes:         []*daghash.Hash{node1.hash},
-			expectedResult: false,
-		},
-		{
-			name:           "set and hashes of different length",
-			set:            setFromSlice(node1, node2),
-			hashes:         []*daghash.Hash{node1.hash},
-			expectedResult: false,
-		},
-		{
-			name:           "set equal to hashes",
-			set:            setFromSlice(node1, node2),
-			hashes:         []*daghash.Hash{node1.hash, node2.hash},
-			expectedResult: true,
-		},
-		{
-			name:           "set equal to hashes, different order",
-			set:            setFromSlice(node1, node2),
-			hashes:         []*daghash.Hash{node2.hash, node1.hash},
-			expectedResult: true,
-		},
-	}
-
-	for _, test := range tests {
-		result := test.set.hashesEqual(test.hashes)
-		if result != test.expectedResult {
-			t.Errorf("blockSet.hashesEqual: unexpected result in test '%s'. "+
-				"Expected: %t, got: %t", test.name, test.expectedResult, result)
-		}
-	}
-}
--- a/blockdag/blockwindow.go
+++ b/blockdag/blockwindow.go
@@ -11,7 +11,7 @@ import (
 type blockWindow []*blockNode

 // blueBlockWindow returns a blockWindow of the given size that contains the
-// blues in the past of startindNode, sorted by phantom order.
+// blues in the past of startindNode, sorted by GHOSTDAG order.
 // If the number of blues in the past of startingNode is less then windowSize,
 // the window will be padded by genesis blocks to achieve a size of windowSize.
 func blueBlockWindow(startingNode *blockNode, windowSize uint64) blockWindow {
--- a/blockdag/blockwindow_test.go
+++ b/blockdag/blockwindow_test.go
@@ -2,7 +2,7 @@ package blockdag

 import (
 	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util"
 	"github.com/pkg/errors"
 	"reflect"
 	"testing"
@@ -10,9 +10,17 @@ import (
 )

 func TestBlueBlockWindow(t *testing.T) {
-	params := dagconfig.SimNetParams
+	params := dagconfig.SimnetParams
 	params.K = 1
-	dag := newTestDAG(&params)
+	dag, teardownFunc, err := DAGSetup("TestBlueBlockWindow", Config{
+		DAGParams: &params,
+	})
+	if err != nil {
+		t.Fatalf("Failed to setup dag instance: %v", err)
+	}
+	defer teardownFunc()
+
+	resetExtraNonceForTest()

 	windowSize := uint64(10)
 	genesisNode := dag.genesis
@@ -21,7 +29,6 @@ func TestBlueBlockWindow(t *testing.T) {
 	idByBlockMap := make(map[*blockNode]string)
 	blockByIDMap["A"] = genesisNode
 	idByBlockMap[genesisNode] = "A"
-	blockVersion := int32(0x10000000)

 	blocksData := []*struct {
 		parents                          []string
@@ -46,12 +53,12 @@ func TestBlueBlockWindow(t *testing.T) {
 		{
 			parents:                          []string{"C", "D"},
 			id:                               "E",
-			expectedWindowWithGenesisPadding: []string{"D", "C", "B", "A", "A", "A", "A", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"C", "D", "B", "A", "A", "A", "A", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"C", "D"},
 			id:                               "F",
-			expectedWindowWithGenesisPadding: []string{"D", "C", "B", "A", "A", "A", "A", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"C", "D", "B", "A", "A", "A", "A", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"A"},
@@ -66,37 +73,37 @@ func TestBlueBlockWindow(t *testing.T) {
 		{
 			parents:                          []string{"H", "F"},
 			id:                               "I",
-			expectedWindowWithGenesisPadding: []string{"F", "D", "C", "B", "A", "A", "A", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"F", "C", "D", "B", "A", "A", "A", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"I"},
 			id:                               "J",
-			expectedWindowWithGenesisPadding: []string{"I", "F", "D", "C", "B", "A", "A", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"I", "F", "C", "D", "B", "A", "A", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"J"},
 			id:                               "K",
-			expectedWindowWithGenesisPadding: []string{"J", "I", "F", "D", "C", "B", "A", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"J", "I", "F", "C", "D", "B", "A", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"K"},
 			id:                               "L",
-			expectedWindowWithGenesisPadding: []string{"K", "J", "I", "F", "D", "C", "B", "A", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"K", "J", "I", "F", "C", "D", "B", "A", "A", "A"},
 		},
 		{
 			parents:                          []string{"L"},
 			id:                               "M",
-			expectedWindowWithGenesisPadding: []string{"L", "K", "J", "I", "F", "D", "C", "B", "A", "A"},
+			expectedWindowWithGenesisPadding: []string{"L", "K", "J", "I", "F", "C", "D", "B", "A", "A"},
 		},
 		{
 			parents:                          []string{"M"},
 			id:                               "N",
-			expectedWindowWithGenesisPadding: []string{"M", "L", "K", "J", "I", "F", "D", "C", "B", "A"},
+			expectedWindowWithGenesisPadding: []string{"M", "L", "K", "J", "I", "F", "C", "D", "B", "A"},
 		},
 		{
 			parents:                          []string{"N"},
 			id:                               "O",
-			expectedWindowWithGenesisPadding: []string{"N", "M", "L", "K", "J", "I", "F", "D", "C", "B"},
+			expectedWindowWithGenesisPadding: []string{"N", "M", "L", "K", "J", "I", "F", "C", "D", "B"},
 		},
 	}

@@ -107,14 +114,26 @@ func TestBlueBlockWindow(t *testing.T) {
 			parent := blockByIDMap[parentID]
 			parents.add(parent)
 		}
-		node := newTestNode(parents, blockVersion, 0, blockTime, dag.dagParams.K)
-		node.hash = &daghash.Hash{} // It helps to predict hash order
-		for i, char := range blockData.id {
-			node.hash[i] = byte(char)
+
+		block, err := PrepareBlockForTest(dag, parents.hashes(), nil)
+		if err != nil {
+			t.Fatalf("block %v got unexpected error from PrepareBlockForTest: %v", blockData.id, err)
 		}

-		dag.index.AddNode(node)
-		node.updateParentsChildren()
+		utilBlock := util.NewBlock(block)
+		isOrphan, isDelayed, err := dag.ProcessBlock(utilBlock, BFNoPoWCheck)
+		if err != nil {
+			t.Fatalf("dag.ProcessBlock got unexpected error for block %v: %v", blockData.id, err)
+		}
+		if isDelayed {
+			t.Fatalf("block %s "+
+				"is too far in the future", blockData.id)
+		}
+		if isOrphan {
+			t.Fatalf("block %v was unexpectedly orphan", blockData.id)
+		}
+
+		node := dag.index.LookupNode(utilBlock.Hash())

 		blockByIDMap[blockData.id] = node
 		idByBlockMap[node] = blockData.id
--- a/blockdag/common_test.go
+++ b/blockdag/common_test.go
@@ -23,17 +23,6 @@ import (
 	"github.com/kaspanet/kaspad/wire"
 )

-func loadBlocksWithLog(t *testing.T, filename string) ([]*util.Block, error) {
-	blocks, err := LoadBlocks(filename)
-	if err == nil {
-		t.Logf("Loaded %d blocks from file %s", len(blocks), filename)
-		for i, b := range blocks {
-			t.Logf("Block #%d: %s", i, b.Hash())
-		}
-	}
-	return blocks, err
-}
-
 // loadUTXOSet returns a utxo view loaded from a file.
 func loadUTXOSet(filename string) (UTXOSet, error) {
 	// The utxostore file format is:
@@ -113,14 +102,9 @@ func (dag *BlockDAG) TestSetCoinbaseMaturity(maturity uint64) {
 // it is not usable with all functions and the tests must take care when making
 // use of it.
 func newTestDAG(params *dagconfig.Params) *BlockDAG {
-	// Create a genesis block node and block index index populated with it
-	// for use when creating the fake DAG below.
-	node := newBlockNode(&params.GenesisBlock.Header, newSet(), params.K)
 	index := newBlockIndex(nil, params)
-	index.AddNode(node)
-
 	targetTimePerBlock := int64(params.TargetTimePerBlock / time.Second)
-	return &BlockDAG{
+	dag := &BlockDAG{
 		dagParams:                      params,
 		timeSource:                     NewMedianTime(),
 		targetTimePerBlock:             targetTimePerBlock,
@@ -128,16 +112,22 @@ func newTestDAG(params *dagconfig.Params) *BlockDAG {
 		TimestampDeviationTolerance:    params.TimestampDeviationTolerance,
 		powMaxBits:                     util.BigToCompact(params.PowMax),
 		index:                          index,
-		virtual:                        newVirtualBlock(setFromSlice(node), params.K),
-		genesis:                        index.LookupNode(params.GenesisHash),
 		warningCaches:                  newThresholdCaches(vbNumBits),
 		deploymentCaches:               newThresholdCaches(dagconfig.DefinedDeployments),
 	}
+
+	// Create a genesis block node and block index index populated with it
+	// on the above fake DAG.
+	dag.genesis, _ = dag.newBlockNode(&params.GenesisBlock.Header, newBlockSet())
+	index.AddNode(dag.genesis)
+
+	dag.virtual = newVirtualBlock(dag, blockSetFromSlice(dag.genesis))
+	return dag
 }

 // newTestNode creates a block node connected to the passed parent with the
 // provided fields populated and fake values for the other fields.
-func newTestNode(parents blockSet, blockVersion int32, bits uint32, timestamp time.Time, phantomK uint32) *blockNode {
+func newTestNode(dag *BlockDAG, parents blockSet, blockVersion int32, bits uint32, timestamp time.Time) *blockNode {
 	// Make up a header and create a block node from it.
 	header := &wire.BlockHeader{
 		Version:              blockVersion,
@@ -148,36 +138,16 @@ func newTestNode(parents blockSet, blockVersion int32, bits uint32, timestamp ti
 		AcceptedIDMerkleRoot: &daghash.ZeroHash,
 		UTXOCommitment:       &daghash.ZeroHash,
 	}
-	return newBlockNode(header, parents, phantomK)
+	node, _ := dag.newBlockNode(header, parents)
+	return node
 }

 func addNodeAsChildToParents(node *blockNode) {
-	for _, parent := range node.parents {
+	for parent := range node.parents {
 		parent.children.add(node)
 	}
 }

-func buildNodeGenerator(phantomK uint32, withChildren bool) func(parents blockSet) *blockNode {
-	// For the purposes of these tests, we'll create blockNodes whose hashes are a
-	// series of numbers from 1 to 255.
-	hashCounter := byte(1)
-	buildNode := func(parents blockSet) *blockNode {
-		block := newBlockNode(nil, parents, phantomK)
-		block.hash = &daghash.Hash{hashCounter}
-		hashCounter++
-
-		return block
-	}
-	if withChildren {
-		return func(parents blockSet) *blockNode {
-			node := buildNode(parents)
-			addNodeAsChildToParents(node)
-			return node
-		}
-	}
-	return buildNode
-}
-
 // checkRuleError ensures the type of the two passed errors are of the
 // same type (either both nil or both of type RuleError) and their error codes
 // match when not nil.
@@ -209,3 +179,35 @@ func checkRuleError(gotErr, wantErr error) error {

 	return nil
 }
+
+func prepareAndProcessBlock(t *testing.T, dag *BlockDAG, parents ...*wire.MsgBlock) *wire.MsgBlock {
+	parentHashes := make([]*daghash.Hash, len(parents))
+	for i, parent := range parents {
+		parentHashes[i] = parent.BlockHash()
+	}
+	daghash.Sort(parentHashes)
+	block, err := PrepareBlockForTest(dag, parentHashes, nil)
+	if err != nil {
+		t.Fatalf("error in PrepareBlockForTest: %s", err)
+	}
+	utilBlock := util.NewBlock(block)
+	isOrphan, isDelayed, err := dag.ProcessBlock(utilBlock, BFNoPoWCheck)
+	if err != nil {
+		t.Fatalf("unexpected error in ProcessBlock: %s", err)
+	}
+	if isDelayed {
+		t.Fatalf("block is too far in the future")
+	}
+	if isOrphan {
+		t.Fatalf("block was unexpectedly orphan")
+	}
+	return block
+}
+
+func nodeByMsgBlock(t *testing.T, dag *BlockDAG, block *wire.MsgBlock) *blockNode {
+	node := dag.index.LookupNode(block.BlockHash())
+	if node == nil {
+		t.Fatalf("couldn't find block node with hash %s", block.BlockHash())
+	}
+	return node
+}
--- a/blockdag/dag.go
+++ b/blockdag/dag.go
@@ -6,12 +6,13 @@ package blockdag

 import (
 	"fmt"
-	"github.com/pkg/errors"
 	"math"
 	"sort"
 	"sync"
 	"time"

+	"github.com/pkg/errors"
+
 	"github.com/kaspanet/kaspad/util/subnetworkid"

 	"github.com/kaspanet/kaspad/dagconfig"
@@ -26,6 +27,8 @@ const (
 	// maxOrphanBlocks is the maximum number of orphan blocks that can be
 	// queued.
 	maxOrphanBlocks = 100
+
+	isDAGCurrentMaxDiff = 12 * time.Hour
 )

 // orphanBlock represents a block that we don't yet have the parent for. It
@@ -36,6 +39,12 @@ type orphanBlock struct {
 	expiration time.Time
 }

+// delayedBlock represents a block which has a delayed timestamp and will be processed at processTime
+type delayedBlock struct {
+	block       *util.Block
+	processTime time.Time
+}
+
 // chainUpdates represents the updates made to the selected parent chain after
 // a block had been added to the DAG.
 type chainUpdates struct {
@@ -99,6 +108,13 @@ type BlockDAG struct {
 	prevOrphans  map[daghash.Hash][]*orphanBlock
 	newestOrphan *orphanBlock

+	// delayedBlocks is a list of all delayed blocks. We are maintaining this
+	// list for the case where a new block with a valid timestamp points to a delayed block.
+	// In that case we will delay the processing of the child block so it would be processed
+	// after its parent.
+	delayedBlocks      map[daghash.Hash]*delayedBlock
+	delayedBlocksQueue delayedBlocksHeap
+
 	// The following caches are used to efficiently keep track of the
 	// current deployment threshold state of each rule change deployment.
 	//
@@ -134,28 +150,28 @@ type BlockDAG struct {

 	lastFinalityPoint *blockNode

-	SubnetworkStore *SubnetworkStore
-	utxoDiffStore   *utxoDiffStore
+	SubnetworkStore   *SubnetworkStore
+	utxoDiffStore     *utxoDiffStore
+	reachabilityStore *reachabilityStore
 }

-// HaveBlock returns whether or not the DAG instance has the block represented
+// IsKnownBlock returns whether or not the DAG instance has the block represented
 // by the passed hash. This includes checking the various places a block can
 // be in, like part of the DAG or the orphan pool.
 //
 // This function is safe for concurrent access.
-func (dag *BlockDAG) HaveBlock(hash *daghash.Hash) bool {
-	exists := dag.BlockExists(hash)
-	return exists || dag.IsKnownOrphan(hash)
+func (dag *BlockDAG) IsKnownBlock(hash *daghash.Hash) bool {
+	return dag.IsInDAG(hash) || dag.IsKnownOrphan(hash) || dag.isKnownDelayedBlock(hash)
 }

-// HaveBlocks returns whether or not the DAG instances has all blocks represented
+// AreKnownBlocks returns whether or not the DAG instances has all blocks represented
 // by the passed hashes. This includes checking the various places a block can
 // be in, like part of the DAG or the orphan pool.
 //
 // This function is safe for concurrent access.
-func (dag *BlockDAG) HaveBlocks(hashes []*daghash.Hash) bool {
+func (dag *BlockDAG) AreKnownBlocks(hashes []*daghash.Hash) bool {
 	for _, hash := range hashes {
-		haveBlock := dag.HaveBlock(hash)
+		haveBlock := dag.IsKnownBlock(hash)
 		if !haveBlock {
 			return false
 		}
@@ -178,8 +194,8 @@ func (dag *BlockDAG) IsKnownOrphan(hash *daghash.Hash) bool {
 	// Protect concurrent access. Using a read lock only so multiple
 	// readers can query without blocking each other.
 	dag.orphanLock.RLock()
+	defer dag.orphanLock.RUnlock()
 	_, exists := dag.orphans[*hash]
-	dag.orphanLock.RUnlock()

 	return exists
 }
@@ -216,11 +232,9 @@ func (dag *BlockDAG) GetOrphanMissingAncestorHashes(orphanHash *daghash.Hash) ([
 			visited[*current] = true
 			orphan, orphanExists := dag.orphans[*current]
 			if orphanExists {
-				for _, parentHash := range orphan.block.MsgBlock().Header.ParentHashes {
-					queue = append(queue, parentHash)
-				}
+				queue = append(queue, orphan.block.MsgBlock().Header.ParentHashes...)
 			} else {
-				if !dag.BlockExists(current) && current != orphanHash {
+				if !dag.IsInDAG(current) && current != orphanHash {
 					missingAncestorsHashes = append(missingAncestorsHashes, current)
 				}
 			}
@@ -462,15 +476,15 @@ func LockTimeToSequence(isSeconds bool, locktime uint64) uint64 {
 //  - BFFastAdd: Avoids several expensive transaction validation operations.
 //
 // This function MUST be called with the DAG state lock held (for writes).
-func (dag *BlockDAG) addBlock(node *blockNode, parentNodes blockSet,
-	block *util.Block, flags BehaviorFlags) (*chainUpdates, error) {
+func (dag *BlockDAG) addBlock(node *blockNode,
+	block *util.Block, selectedParentAnticone []*blockNode, flags BehaviorFlags) (*chainUpdates, error) {
 	// Skip checks if node has already been fully validated.
 	fastAdd := flags&BFFastAdd == BFFastAdd || dag.index.NodeStatus(node).KnownValid()

 	// Connect the block to the DAG.
-	chainUpdates, err := dag.connectBlock(node, block, fastAdd)
+	chainUpdates, err := dag.connectBlock(node, block, selectedParentAnticone, fastAdd)
 	if err != nil {
-		if _, ok := err.(RuleError); ok {
+		if errors.As(err, &RuleError{}) {
 			dag.index.SetStatusFlags(node, statusValidateFailed)
 		} else {
 			return nil, err
@@ -532,7 +546,7 @@ func (node *blockNode) validateAcceptedIDMerkleRoot(dag *BlockDAG, txsAcceptance
 //
 // This function MUST be called with the DAG state lock held (for writes).
 func (dag *BlockDAG) connectBlock(node *blockNode,
-	block *util.Block, fastAdd bool) (*chainUpdates, error) {
+	block *util.Block, selectedParentAnticone []*blockNode, fastAdd bool) (*chainUpdates, error) {
 	// No warnings about unknown rules or versions until the DAG is
 	// current.
 	if dag.isCurrent() {
@@ -560,8 +574,9 @@ func (dag *BlockDAG) connectBlock(node *blockNode,
 	newBlockUTXO, txsAcceptanceData, newBlockFeeData, err := node.verifyAndBuildUTXO(dag, block.Transactions(), fastAdd)
 	if err != nil {
 		newErrString := fmt.Sprintf("error verifying UTXO for %s: %s", node, err)
-		if err, ok := err.(RuleError); ok {
-			return nil, ruleError(err.ErrorCode, newErrString)
+		var ruleErr RuleError
+		if ok := errors.As(err, &ruleErr); ok {
+			return nil, ruleError(ruleErr.ErrorCode, newErrString)
 		}
 		return nil, errors.New(newErrString)
 	}
@@ -572,7 +587,7 @@ func (dag *BlockDAG) connectBlock(node *blockNode,
 	}

 	// Apply all changes to the DAG.
-	virtualUTXODiff, virtualTxsAcceptanceData, chainUpdates, err := dag.applyDAGChanges(node, newBlockUTXO, fastAdd)
+	virtualUTXODiff, virtualTxsAcceptanceData, chainUpdates, err := dag.applyDAGChanges(node, newBlockUTXO, selectedParentAnticone)
 	if err != nil {
 		// Since all validation logic has already ran, if applyDAGChanges errors out,
 		// this means we have a problem in the internal structure of the DAG - a problem which is
@@ -606,6 +621,11 @@ func (dag *BlockDAG) saveChangesFromBlock(block *util.Block, virtualUTXODiff *UT
 			return err
 		}

+		err = dag.reachabilityStore.flushToDB(dbTx)
+		if err != nil {
+			return err
+		}
+
 		// Update best block state.
 		state := &dagState{
 			TipHashes:         dag.TipHashes(),
@@ -652,7 +672,9 @@ func (dag *BlockDAG) saveChangesFromBlock(block *util.Block, virtualUTXODiff *UT
 	if err != nil {
 		return err
 	}
+	dag.index.clearDirtyEntries()
 	dag.utxoDiffStore.clearDirtyEntries()
+	dag.reachabilityStore.clearDirtyEntries()
 	return nil
 }

@@ -753,7 +775,7 @@ func (dag *BlockDAG) updateFinalityPoint() {

 func (dag *BlockDAG) finalizeNodesBelowFinalityPoint(deleteDiffData bool) {
 	queue := make([]*blockNode, 0, len(dag.lastFinalityPoint.parents))
-	for _, parent := range dag.lastFinalityPoint.parents {
+	for parent := range dag.lastFinalityPoint.parents {
 		queue = append(queue, parent)
 	}
 	var blockHashesToDelete []*daghash.Hash
@@ -768,7 +790,7 @@ func (dag *BlockDAG) finalizeNodesBelowFinalityPoint(deleteDiffData bool) {
 			if deleteDiffData {
 				blockHashesToDelete = append(blockHashesToDelete, current.hash)
 			}
-			for _, parent := range current.parents {
+			for parent := range current.parents {
 				queue = append(queue, parent)
 			}
 		}
@@ -813,16 +835,6 @@ func (dag *BlockDAG) NextBlockCoinbaseTransactionNoLock(scriptPubKey []byte, ext
 	return dag.virtual.blockNode.expectedCoinbaseTransaction(dag, txsAcceptanceData, scriptPubKey, extraData)
 }

-// NextAcceptedIDMerkleRoot prepares the acceptedIDMerkleRoot for the next mined block
-//
-// This function CAN'T be called with the DAG lock held.
-func (dag *BlockDAG) NextAcceptedIDMerkleRoot() (*daghash.Hash, error) {
-	dag.dagLock.RLock()
-	defer dag.dagLock.RUnlock()
-
-	return dag.NextAcceptedIDMerkleRootNoLock()
-}
-
 // NextAcceptedIDMerkleRootNoLock prepares the acceptedIDMerkleRoot for the next mined block
 //
 // This function MUST be called with the DAG read-lock held
@@ -855,33 +867,28 @@ func (dag *BlockDAG) TxsAcceptedByBlockHash(blockHash *daghash.Hash) (MultiBlock
 	return txsAcceptanceData, err
 }

-// BlockPastUTXO retrieves the past UTXO of this block
-//
-// This function MUST be called with the DAG read-lock held
-func (dag *BlockDAG) BlockPastUTXO(blockHash *daghash.Hash) (UTXOSet, error) {
-	node := dag.index.LookupNode(blockHash)
-	if node == nil {
-		return nil, errors.Errorf("Couldn't find block %s", blockHash)
-	}
-	pastUTXO, _, err := dag.pastUTXO(node)
-	return pastUTXO, err
-}
-
 // applyDAGChanges does the following:
 // 1. Connects each of the new block's parents to the block.
 // 2. Adds the new block to the DAG's tips.
 // 3. Updates the DAG's full UTXO set.
 // 4. Updates each of the tips' utxoDiff.
 // 5. Applies the new virtual's blue score to all the unaccepted UTXOs
-// 6. Updates the finality point of the DAG (if required).
+// 6. Adds the block to the reachability structures
+// 7. Updates the finality point of the DAG (if required).
 //
 // It returns the diff in the virtual block's UTXO set.
 //
 // This function MUST be called with the DAG state lock held (for writes).
-func (dag *BlockDAG) applyDAGChanges(node *blockNode, newBlockUTXO UTXOSet, fastAdd bool) (
+func (dag *BlockDAG) applyDAGChanges(node *blockNode, newBlockUTXO UTXOSet, selectedParentAnticone []*blockNode) (
 	virtualUTXODiff *UTXODiff, virtualTxsAcceptanceData MultiBlockTxsAcceptanceData,
 	chainUpdates *chainUpdates, err error) {

+	// Add the block to the reachability structures
+	err = dag.updateReachability(node, selectedParentAnticone)
+	if err != nil {
+		return nil, nil, nil, errors.Wrap(err, "failed updating reachability")
+	}
+
 	if err = node.updateParents(dag, newBlockUTXO); err != nil {
 		return nil, nil, nil, errors.Wrapf(err, "failed updating parents of %s", node)
 	}
@@ -1048,11 +1055,11 @@ func (node *blockNode) applyBlueBlocks(acceptedSelectedParentUTXO UTXOSet, selec
 		TxAcceptanceData: selectedParentAcceptanceData,
 	}}

-	// Add blueBlocks to multiBlockTxsAcceptanceData bottom-to-top instead of
-	// top-to-bottom. This is so that anyone who iterates over it would process
-	// blocks (and transactions) in their order of appearance in the DAG.
-	// We skip the selected parent, because we calculated its UTXO before.
-	for i := len(blueBlocks) - 2; i >= 0; i-- {
+	// Add blueBlocks to multiBlockTxsAcceptanceData in topological order. This
+	// is so that anyone who iterates over it would process blocks (and transactions)
+	// in their order of appearance in the DAG.
+	// We skip the selected parent, because we calculated its UTXO in acceptSelectedParentTransactions.
+	for i := 1; i < len(blueBlocks); i++ {
 		blueBlock := blueBlocks[i]
 		transactions := blueBlock.Transactions()
 		blockTxsAcceptanceData := BlockTxsAcceptanceData{
@@ -1098,7 +1105,7 @@ func (node *blockNode) updateParentsDiffs(dag *BlockDAG, newBlockUTXO UTXOSet) e
 		return err
 	}

-	for _, parent := range node.parents {
+	for parent := range node.parents {
 		diffChild, err := dag.utxoDiffStore.diffChildByNode(parent)
 		if err != nil {
 			return err
@@ -1145,7 +1152,7 @@ func (dag *BlockDAG) pastUTXO(node *blockNode) (
 		return nil, nil, err
 	}

-	selectedParent := blueBlocks[len(blueBlocks)-1]
+	selectedParent := blueBlocks[0]
 	acceptedSelectedParentUTXO, selectedParentAcceptanceData, err := node.acceptSelectedParentTransactions(selectedParent, selectedParentUTXO)
 	if err != nil {
 		return nil, nil, err
@@ -1182,6 +1189,8 @@ func (node *blockNode) acceptSelectedParentTransactions(selectedParent *util.Blo
 func (dag *BlockDAG) restoreUTXO(node *blockNode) (UTXOSet, error) {
 	stack := []*blockNode{}

+	// Iterate over the chain of diff-childs from node till virtual and add them
+	// all into a stack
 	for current := node; current != nil; {
 		stack = append(stack, current)
 		var err error
@@ -1191,25 +1200,33 @@ func (dag *BlockDAG) restoreUTXO(node *blockNode) (UTXOSet, error) {
 		}
 	}

-	utxo := UTXOSet(dag.virtual.utxoSet)
+	// Start with the top item in the stack, going over it top-to-bottom,
+	// applying the UTXO-diff one-by-one.
+	topNode, stack := stack[len(stack)-1], stack[:len(stack)-1] // pop the top item in the stack
+	topNodeDiff, err := dag.utxoDiffStore.diffByNode(topNode)
+	if err != nil {
+		return nil, err
+	}
+	accumulatedDiff := topNodeDiff.clone()

 	for i := len(stack) - 1; i >= 0; i-- {
 		diff, err := dag.utxoDiffStore.diffByNode(stack[i])
 		if err != nil {
 			return nil, err
 		}
-		utxo, err = utxo.WithDiff(diff)
+		// Use WithDiffInPlace, otherwise copying the diffs again and again create a polynomial overhead
+		err = accumulatedDiff.WithDiffInPlace(diff)
 		if err != nil {
 			return nil, err
 		}
 	}

-	return utxo, nil
+	return NewDiffUTXOSet(dag.virtual.utxoSet, accumulatedDiff), nil
 }

 // updateTipsUTXO builds and applies new diff UTXOs for all the DAG's tips
 func updateTipsUTXO(dag *BlockDAG, virtualUTXO UTXOSet) error {
-	for _, tip := range dag.virtual.parents {
+	for tip := range dag.virtual.parents {
 		tipUTXO, err := dag.restoreUTXO(tip)
 		if err != nil {
 			return err
@@ -1247,8 +1264,15 @@ func (dag *BlockDAG) isCurrent() bool {
 	} else {
 		dagTimestamp = selectedTip.timestamp
 	}
-	minus24Hours := dag.timeSource.AdjustedTime().Add(-24 * time.Hour).Unix()
-	return dagTimestamp >= minus24Hours
+	dagTime := time.Unix(dagTimestamp, 0)
+	return dag.AdjustedTime().Sub(dagTime) <= isDAGCurrentMaxDiff
+}
+
+// AdjustedTime returns the adjusted time according to
+// dag.timeSource. See MedianTimeSource.AdjustedTime for
+// more details.
+func (dag *BlockDAG) AdjustedTime() time.Time {
+	return dag.timeSource.AdjustedTime()
 }

 // IsCurrent returns whether or not the DAG believes it is current. Several
@@ -1352,6 +1376,23 @@ func (dag *BlockDAG) BlockConfirmationsByHashNoLock(hash *daghash.Hash) (uint64,
 	return dag.blockConfirmations(node)
 }

+// UTXOConfirmations returns the confirmations for the given outpoint, if it exists
+// in the DAG's UTXO set.
+//
+// This function is safe for concurrent access.
+func (dag *BlockDAG) UTXOConfirmations(outpoint *wire.Outpoint) (uint64, bool) {
+	dag.dagLock.RLock()
+	defer dag.dagLock.RUnlock()
+
+	utxoEntry, ok := dag.GetUTXOEntry(*outpoint)
+	if !ok {
+		return 0, false
+	}
+	confirmations := dag.SelectedTipBlueScore() - utxoEntry.BlockBlueScore() + 1
+
+	return confirmations, true
+}
+
 // UTXOCommitment returns a commitment to the dag's current UTXOSet
 func (dag *BlockDAG) UTXOCommitment() string {
 	return dag.UTXOSet().UTXOMultiset.Hash().String()
@@ -1363,9 +1404,6 @@ func (dag *BlockDAG) UTXOCommitment() string {
 // * If the node is the selected tip			-> 1
 // * Otherwise									-> selectedTip.blueScore - acceptingBlock.blueScore + 2
 func (dag *BlockDAG) blockConfirmations(node *blockNode) (uint64, error) {
-	if node == dag.selectedTip() {
-		return 1, nil
-	}
 	acceptingBlock, err := dag.acceptingBlock(node)
 	if err != nil {
 		return 0, err
@@ -1376,7 +1414,7 @@ func (dag *BlockDAG) blockConfirmations(node *blockNode) (uint64, error) {
 		return 0, nil
 	}

-	return dag.selectedTip().blueScore - acceptingBlock.blueScore + 2, nil
+	return dag.selectedTip().blueScore - acceptingBlock.blueScore + 1, nil
 }

 // acceptingBlock finds the node in the selected-parent chain that had accepted
@@ -1388,13 +1426,21 @@ func (dag *BlockDAG) acceptingBlock(node *blockNode) (*blockNode, error) {
 	}

 	// If the node is a chain-block itself, the accepting block is its chain-child
-	if dag.IsInSelectedParentChain(node.hash) {
+	isNodeInSelectedParentChain, err := dag.IsInSelectedParentChain(node.hash)
+	if err != nil {
+		return nil, err
+	}
+	if isNodeInSelectedParentChain {
 		if len(node.children) == 0 {
 			// If the node is the selected tip, it doesn't have an accepting block
 			return nil, nil
 		}
-		for _, child := range node.children {
-			if dag.IsInSelectedParentChain(child.hash) {
+		for child := range node.children {
+			isChildInSelectedParentChain, err := dag.IsInSelectedParentChain(child.hash)
+			if err != nil {
+				return nil, err
+			}
+			if isChildInSelectedParentChain {
 				return child, nil
 			}
 		}
@@ -1438,61 +1484,75 @@ func (dag *BlockDAG) oldestChainBlockWithBlueScoreGreaterThan(blueScore uint64)
 }

 // IsInSelectedParentChain returns whether or not a block hash is found in the selected
-// parent chain.
+// parent chain. Note that this method returns an error if the given blockHash does not
+// exist within the block index.
 //
 // This method MUST be called with the DAG lock held
-func (dag *BlockDAG) IsInSelectedParentChain(blockHash *daghash.Hash) bool {
-	return dag.virtual.selectedParentChainSet.containsHash(blockHash)
+func (dag *BlockDAG) IsInSelectedParentChain(blockHash *daghash.Hash) (bool, error) {
+	blockNode := dag.index.LookupNode(blockHash)
+	if blockNode == nil {
+		str := fmt.Sprintf("block %s is not in the DAG", blockHash)
+		return false, errNotInDAG(str)
+	}
+	return dag.virtual.selectedParentChainSet.contains(blockNode), nil
 }

-// SelectedParentChain returns the selected parent chain starting from startHash (exclusive)
-// up to the virtual (exclusive). If startHash is nil then the genesis block is used. If
-// startHash is not within the select parent chain, go down its own selected parent chain,
+// SelectedParentChain returns the selected parent chain starting from blockHash (exclusive)
+// up to the virtual (exclusive). If blockHash is nil then the genesis block is used. If
+// blockHash is not within the select parent chain, go down its own selected parent chain,
 // while collecting each block hash in removedChainHashes, until reaching a block within
 // the main selected parent chain.
 //
 // This method MUST be called with the DAG lock held
-func (dag *BlockDAG) SelectedParentChain(startHash *daghash.Hash) ([]*daghash.Hash, []*daghash.Hash, error) {
-	if startHash == nil {
-		startHash = dag.genesis.hash
+func (dag *BlockDAG) SelectedParentChain(blockHash *daghash.Hash) ([]*daghash.Hash, []*daghash.Hash, error) {
+	if blockHash == nil {
+		blockHash = dag.genesis.hash
 	}
-	if !dag.BlockExists(startHash) {
-		return nil, nil, errors.Errorf("startHash %s does not exist in the DAG", startHash)
+	if !dag.IsInDAG(blockHash) {
+		return nil, nil, errors.Errorf("blockHash %s does not exist in the DAG", blockHash)
 	}

-	// If startHash is not in the selected parent chain, go down its selected parent chain
+	// If blockHash is not in the selected parent chain, go down its selected parent chain
 	// until we find a block that is in the main selected parent chain.
 	var removedChainHashes []*daghash.Hash
-	for !dag.IsInSelectedParentChain(startHash) {
-		removedChainHashes = append(removedChainHashes, startHash)
+	isBlockInSelectedParentChain, err := dag.IsInSelectedParentChain(blockHash)
+	if err != nil {
+		return nil, nil, err
+	}
+	for !isBlockInSelectedParentChain {
+		removedChainHashes = append(removedChainHashes, blockHash)

-		node := dag.index.LookupNode(startHash)
-		startHash = node.selectedParent.hash
+		node := dag.index.LookupNode(blockHash)
+		blockHash = node.selectedParent.hash
+
+		isBlockInSelectedParentChain, err = dag.IsInSelectedParentChain(blockHash)
+		if err != nil {
+			return nil, nil, err
+		}
 	}

-	// Find the index of the startHash in the selectedParentChainSlice
-	startHashIndex := len(dag.virtual.selectedParentChainSlice) - 1
-	for startHashIndex >= 0 {
-		node := dag.virtual.selectedParentChainSlice[startHashIndex]
-		if node.hash.IsEqual(startHash) {
+	// Find the index of the blockHash in the selectedParentChainSlice
+	blockHashIndex := len(dag.virtual.selectedParentChainSlice) - 1
+	for blockHashIndex >= 0 {
+		node := dag.virtual.selectedParentChainSlice[blockHashIndex]
+		if node.hash.IsEqual(blockHash) {
 			break
 		}
-		startHashIndex--
+		blockHashIndex--
 	}

-	// Copy all the addedChainHashes starting from startHashIndex (exclusive)
-	addedChainHashes := make([]*daghash.Hash, len(dag.virtual.selectedParentChainSlice)-startHashIndex-1)
-	for i, node := range dag.virtual.selectedParentChainSlice[startHashIndex+1:] {
+	// Copy all the addedChainHashes starting from blockHashIndex (exclusive)
+	addedChainHashes := make([]*daghash.Hash, len(dag.virtual.selectedParentChainSlice)-blockHashIndex-1)
+	for i, node := range dag.virtual.selectedParentChainSlice[blockHashIndex+1:] {
 		addedChainHashes[i] = node.hash
 	}

 	return removedChainHashes, addedChainHashes, nil
 }

-// ChainHeight return the chain-height of the selected tip. In other words - it returns
-// the length of the dag's selected-parent chain
-func (dag *BlockDAG) ChainHeight() uint64 {
-	return dag.selectedTip().chainHeight
+// SelectedTipBlueScore returns the blue score of the selected tip.
+func (dag *BlockDAG) SelectedTipBlueScore() uint64 {
+	return dag.selectedTip().blueScore
 }

 // VirtualBlueScore returns the blue score of the current virtual block
@@ -1514,7 +1574,7 @@ func (dag *BlockDAG) TipHashes() []*daghash.Hash {
 func (dag *BlockDAG) CurrentBits() uint32 {
 	tips := dag.virtual.tips()
 	minBits := uint32(math.MaxUint32)
-	for _, tip := range tips {
+	for tip := range tips {
 		if minBits > tip.Header().Bits {
 			minBits = tip.Header().Bits
 		}
@@ -1534,20 +1594,6 @@ func (dag *BlockDAG) HeaderByHash(hash *daghash.Hash) (*wire.BlockHeader, error)
 	return node.Header(), nil
 }

-// BlockChainHeightByHash returns the chain height of the block with the given
-// hash in the DAG.
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) BlockChainHeightByHash(hash *daghash.Hash) (uint64, error) {
-	node := dag.index.LookupNode(hash)
-	if node == nil {
-		str := fmt.Sprintf("block %s is not in the DAG", hash)
-		return 0, errNotInDAG(str)
-	}
-
-	return node.chainHeight, nil
-}
-
 // ChildHashesByHash returns the child hashes of the block with the given hash in the
 // DAG.
 //
@@ -1563,88 +1609,31 @@ func (dag *BlockDAG) ChildHashesByHash(hash *daghash.Hash) ([]*daghash.Hash, err
 	return node.children.hashes(), nil
 }

-// ChainHeightToHashRange returns a range of block hashes for the given start chain
-// height and end hash, inclusive on both ends. The hashes are for all blocks that
-// are ancestors of endHash with height greater than or equal to startChainHeight.
-// The end hash must belong to a block that is known to be valid.
+// SelectedParentHash returns the selected parent hash of the block with the given hash in the
+// DAG.
 //
 // This function is safe for concurrent access.
-func (dag *BlockDAG) ChainHeightToHashRange(startChainHeight uint64,
-	endHash *daghash.Hash, maxResults int) ([]*daghash.Hash, error) {
+func (dag *BlockDAG) SelectedParentHash(blockHash *daghash.Hash) (*daghash.Hash, error) {
+	node := dag.index.LookupNode(blockHash)
+	if node == nil {
+		str := fmt.Sprintf("block %s is not in the DAG", blockHash)
+		return nil, errNotInDAG(str)

-	endNode := dag.index.LookupNode(endHash)
-	if endNode == nil {
-		return nil, errors.Errorf("no known block header with hash %s", endHash)
-	}
-	if !dag.index.NodeStatus(endNode).KnownValid() {
-		return nil, errors.Errorf("block %s is not yet validated", endHash)
-	}
-	endChainHeight := endNode.chainHeight
-
-	if startChainHeight < 0 {
-		return nil, errors.Errorf("start chain height (%d) is below 0", startChainHeight)
-	}
-	if startChainHeight > endChainHeight {
-		return nil, errors.Errorf("start chain height (%d) is past end chain height (%d)",
-			startChainHeight, endChainHeight)
 	}

-	resultsLength := int(endChainHeight - startChainHeight + 1)
-	if resultsLength > maxResults {
-		return nil, errors.Errorf("number of results (%d) would exceed max (%d)",
-			resultsLength, maxResults)
+	if node.selectedParent == nil {
+		return nil, nil
 	}
-
-	// Walk backwards from endChainHeight to startChainHeight, collecting block hashes.
-	node := endNode
-	hashes := make([]*daghash.Hash, resultsLength)
-	for i := resultsLength - 1; i >= 0; i-- {
-		hashes[i] = node.hash
-		node = node.selectedParent
-	}
-	return hashes, nil
+	return node.selectedParent.hash, nil
 }

-// IntervalBlockHashes returns hashes for all blocks that are ancestors of
-// endHash where the block height is a positive multiple of interval.
-//
-// This function is safe for concurrent access.
-func (dag *BlockDAG) IntervalBlockHashes(endHash *daghash.Hash, interval uint64,
-) ([]*daghash.Hash, error) {
-
-	endNode := dag.index.LookupNode(endHash)
-	if endNode == nil {
-		return nil, errors.Errorf("no known block header with hash %s", endHash)
-	}
-	if !dag.index.NodeStatus(endNode).KnownValid() {
-		return nil, errors.Errorf("block %s is not yet validated", endHash)
-	}
-	endChainHeight := endNode.chainHeight
-
-	resultsLength := endChainHeight / interval
-	hashes := make([]*daghash.Hash, resultsLength)
-
-	dag.virtual.mtx.Lock()
-	defer dag.virtual.mtx.Unlock()
-
-	blockNode := endNode
-	for index := endChainHeight / interval; index > 0; index-- {
-		blockHeight := index * interval
-		blockNode = blockNode.SelectedAncestor(blockHeight)
-
-		hashes[index-1] = blockNode.hash
-	}
-
-	return hashes, nil
-}
-
-// getBlueBlocksHashesBetween returns the hashes of the blocks after the provided
-// start hash until the provided stop hash is reached, or up to the
-// provided max number of block hashes.
+// antiPastHashesBetween returns the hashes of the blocks between the
+// lowHash's antiPast and highHash's antiPast, or up to the provided
+// max number of block hashes.
 //
 // This function MUST be called with the DAG state lock held (for reads).
-func (dag *BlockDAG) getBlueBlocksHashesBetween(startHash, stopHash *daghash.Hash, maxHashes uint64) ([]*daghash.Hash, error) {
-	nodes, err := dag.getBlueBlocksBetween(startHash, stopHash, maxHashes)
+func (dag *BlockDAG) antiPastHashesBetween(lowHash, highHash *daghash.Hash, maxHashes uint64) ([]*daghash.Hash, error) {
+	nodes, err := dag.antiPastBetween(lowHash, highHash, maxHashes)
 	if err != nil {
 		return nil, err
 	}
@@ -1655,74 +1644,97 @@ func (dag *BlockDAG) getBlueBlocksHashesBetween(startHash, stopHash *daghash.Has
 	return hashes, nil
 }

-func (dag *BlockDAG) getBlueBlocksBetween(startHash, stopHash *daghash.Hash, maxEntries uint64) ([]*blockNode, error) {
-	startNode := dag.index.LookupNode(startHash)
-	if startNode == nil {
-		return nil, errors.Errorf("Couldn't find start hash %s", startHash)
+// antiPastBetween returns the blockNodes between the lowHash's antiPast
+// and highHash's antiPast, or up to the provided max number of blocks.
+//
+// This function MUST be called with the DAG state lock held (for reads).
+func (dag *BlockDAG) antiPastBetween(lowHash, highHash *daghash.Hash, maxEntries uint64) ([]*blockNode, error) {
+	lowNode := dag.index.LookupNode(lowHash)
+	if lowNode == nil {
+		return nil, errors.Errorf("Couldn't find low hash %s", lowHash)
 	}
-	stopNode := dag.index.LookupNode(stopHash)
-	if stopNode == nil {
-		return nil, errors.Errorf("Couldn't find stop hash %s", stopHash)
+	highNode := dag.index.LookupNode(highHash)
+	if highNode == nil {
+		return nil, errors.Errorf("Couldn't find high hash %s", highHash)
+	}
+	if lowNode.blueScore >= highNode.blueScore {
+		return nil, errors.Errorf("Low hash blueScore >= high hash blueScore (%d >= %d)",
+			lowNode.blueScore, highNode.blueScore)
 	}

-	// In order to get no more then maxEntries of blue blocks from
-	// the future of the start node (including itself), we iterate
-	// the selected parent chain of the stopNode and add the blues
-	// each node (including the stopNode itself). This is why the
-	// number of returned blocks will be
-	// stopNode.blueScore-startNode.blueScore+1.
-	// If stopNode.blueScore-startNode.blueScore+1 > maxEntries, we
-	// first iterate on the selected parent chain of the stop node
-	// until we find a new stop node
-	// where stopNode.blueScore-startNode.blueScore+1 <= maxEntries
-
-	for stopNode.blueScore-startNode.blueScore+1 > maxEntries {
-		stopNode = stopNode.selectedParent
+	// In order to get no more then maxEntries blocks from the
+	// future of the lowNode (including itself), we iterate the
+	// selected parent chain of the highNode and stop once we reach
+	// highNode.blueScore-lowNode.blueScore+1 <= maxEntries. That
+	// stop point becomes the new highNode.
+	// Using blueScore as an approximation is considered to be
+	// fairly accurate because we presume that most DAG blocks are
+	// blue.
+	for highNode.blueScore-lowNode.blueScore+1 > maxEntries {
+		highNode = highNode.selectedParent
 	}

-	// Populate and return the found nodes.
-	nodes := make([]*blockNode, 0, stopNode.blueScore-startNode.blueScore+1)
-	nodes = append(nodes, stopNode)
-	current := stopNode
-	for current.blueScore > startNode.blueScore {
-		for _, blue := range current.blues {
-			nodes = append(nodes, blue)
+	// Collect every node in highNode's past (including itself) but
+	// NOT in the lowNode's past (excluding itself) into an up-heap
+	// (a heap sorted by blueScore from lowest to greatest).
+	visited := newBlockSet()
+	candidateNodes := newUpHeap()
+	queue := newDownHeap()
+	queue.Push(highNode)
+	for queue.Len() > 0 {
+		current := queue.pop()
+		if visited.contains(current) {
+			continue
+		}
+		visited.add(current)
+		isCurrentAncestorOfLowNode, err := dag.isAncestorOf(current, lowNode)
+		if err != nil {
+			return nil, err
+		}
+		if isCurrentAncestorOfLowNode {
+			continue
+		}
+		candidateNodes.Push(current)
+		for parent := range current.parents {
+			queue.Push(parent)
 		}
-		current = current.selectedParent
 	}
-	if current != startNode {
-		return nil, errors.Errorf("the start hash is not found in the " +
-			"selected parent chain of the stop hash")
+
+	// Pop candidateNodes into a slice. Since candidateNodes is
+	// an up-heap, it's guaranteed to be ordered from low to high
+	nodesLen := int(maxEntries)
+	if candidateNodes.Len() < nodesLen {
+		nodesLen = candidateNodes.Len()
 	}
-	reversedNodes := make([]*blockNode, len(nodes))
-	for i, node := range nodes {
-		reversedNodes[len(reversedNodes)-i-1] = node
+	nodes := make([]*blockNode, nodesLen)
+	for i := 0; i < nodesLen; i++ {
+		nodes[i] = candidateNodes.pop()
 	}
-	return reversedNodes, nil
+	return nodes, nil
 }

-// GetBlueBlocksHashesBetween returns the hashes of the blue blocks after the
-// provided start hash until the provided stop hash is reached, or up to the
-// provided max number of block hashes.
+// AntiPastHashesBetween returns the hashes of the blocks between the
+// lowHash's antiPast and highHash's antiPast, or up to the provided
+// max number of block hashes.
 //
 // This function is safe for concurrent access.
-func (dag *BlockDAG) GetBlueBlocksHashesBetween(startHash, stopHash *daghash.Hash, maxHashes uint64) ([]*daghash.Hash, error) {
+func (dag *BlockDAG) AntiPastHashesBetween(lowHash, highHash *daghash.Hash, maxHashes uint64) ([]*daghash.Hash, error) {
 	dag.dagLock.RLock()
-	hashes, err := dag.getBlueBlocksHashesBetween(startHash, stopHash, maxHashes)
+	defer dag.dagLock.RUnlock()
+	hashes, err := dag.antiPastHashesBetween(lowHash, highHash, maxHashes)
 	if err != nil {
 		return nil, err
 	}
-	dag.dagLock.RUnlock()
 	return hashes, nil
 }

-// getBlueBlocksHeadersBetween returns the headers of the blue blocks after the
-// provided start hash until the provided stop hash is reached, or up to the
-// provided max number of block headers.
+// antiPastHeadersBetween returns the headers of the blocks between the
+// lowHash's antiPast and highHash's antiPast, or up to the provided
+// max number of block headers.
 //
 // This function MUST be called with the DAG state lock held (for reads).
-func (dag *BlockDAG) getBlueBlocksHeadersBetween(startHash, stopHash *daghash.Hash, maxHeaders uint64) ([]*wire.BlockHeader, error) {
-	nodes, err := dag.getBlueBlocksBetween(startHash, stopHash, maxHeaders)
+func (dag *BlockDAG) antiPastHeadersBetween(lowHash, highHash *daghash.Hash, maxHeaders uint64) ([]*wire.BlockHeader, error) {
+	nodes, err := dag.antiPastBetween(lowHash, highHash, maxHeaders)
 	if err != nil {
 		return nil, err
 	}
@@ -1733,23 +1745,22 @@ func (dag *BlockDAG) getBlueBlocksHeadersBetween(startHash, stopHash *daghash.Ha
 	return headers, nil
 }

-// GetTopHeaders returns the top wire.MaxBlockHeadersPerMsg block headers ordered by height.
-func (dag *BlockDAG) GetTopHeaders(startHash *daghash.Hash) ([]*wire.BlockHeader, error) {
-	startNode := &dag.virtual.blockNode
-	if startHash != nil {
-		startNode = dag.index.LookupNode(startHash)
-		if startNode == nil {
-			return nil, errors.Errorf("Couldn't find the start hash %s in the dag", startHash)
+// GetTopHeaders returns the top wire.MaxBlockHeadersPerMsg block headers ordered by blue score.
+func (dag *BlockDAG) GetTopHeaders(highHash *daghash.Hash, maxHeaders uint64) ([]*wire.BlockHeader, error) {
+	highNode := &dag.virtual.blockNode
+	if highHash != nil {
+		highNode = dag.index.LookupNode(highHash)
+		if highNode == nil {
+			return nil, errors.Errorf("Couldn't find the high hash %s in the dag", highHash)
 		}
 	}
-	headers := make([]*wire.BlockHeader, 0, startNode.blueScore)
+	headers := make([]*wire.BlockHeader, 0, highNode.blueScore)
 	queue := newDownHeap()
-	queue.pushSet(startNode.parents)
+	queue.pushSet(highNode.parents)

-	visited := newSet()
-	for i := uint32(0); queue.Len() > 0 && len(headers) < wire.MaxBlockHeadersPerMsg; i++ {
-		var current *blockNode
-		current = queue.pop()
+	visited := newBlockSet()
+	for i := uint32(0); queue.Len() > 0 && uint64(len(headers)) < maxHeaders; i++ {
+		current := queue.pop()
 		if !visited.contains(current) {
 			visited.add(current)
 			headers = append(headers, current.Header())
@@ -1779,18 +1790,18 @@ func (dag *BlockDAG) RUnlock() {
 	dag.dagLock.RUnlock()
 }

-// GetBlueBlocksHeadersBetween returns the headers of the blocks after the provided
-// start hash until the provided stop hash is reached, or up to the
-// provided max number of block headers.
+// AntiPastHeadersBetween returns the headers of the blocks between the
+// lowHash's antiPast and highHash's antiPast, or up to
+// wire.MaxBlockHeadersPerMsg block headers.
 //
 // This function is safe for concurrent access.
-func (dag *BlockDAG) GetBlueBlocksHeadersBetween(startHash, stopHash *daghash.Hash) ([]*wire.BlockHeader, error) {
+func (dag *BlockDAG) AntiPastHeadersBetween(lowHash, highHash *daghash.Hash, maxHeaders uint64) ([]*wire.BlockHeader, error) {
 	dag.dagLock.RLock()
-	headers, err := dag.getBlueBlocksHeadersBetween(startHash, stopHash, wire.MaxBlockHeadersPerMsg)
+	defer dag.dagLock.RUnlock()
+	headers, err := dag.antiPastHeadersBetween(lowHash, highHash, maxHeaders)
 	if err != nil {
 		return nil, err
 	}
-	dag.dagLock.RUnlock()
 	return headers, nil
 }

@@ -1799,6 +1810,55 @@ func (dag *BlockDAG) SubnetworkID() *subnetworkid.SubnetworkID {
 	return dag.subnetworkID
 }

+func (dag *BlockDAG) addDelayedBlock(block *util.Block, delay time.Duration) error {
+	processTime := dag.AdjustedTime().Add(delay)
+	log.Debugf("Adding block to delayed blocks queue (block hash: %s, process time: %s)", block.Hash().String(), processTime)
+	delayedBlock := &delayedBlock{
+		block:       block,
+		processTime: processTime,
+	}
+
+	dag.delayedBlocks[*block.Hash()] = delayedBlock
+	dag.delayedBlocksQueue.Push(delayedBlock)
+	return dag.processDelayedBlocks()
+}
+
+// processDelayedBlocks loops over all delayed blocks and processes blocks which are due.
+// This method is invoked after processing a block (ProcessBlock method).
+func (dag *BlockDAG) processDelayedBlocks() error {
+	// Check if the delayed block with the earliest process time should be processed
+	for dag.delayedBlocksQueue.Len() > 0 {
+		earliestDelayedBlockProcessTime := dag.peekDelayedBlock().processTime
+		if earliestDelayedBlockProcessTime.After(dag.AdjustedTime()) {
+			break
+		}
+		delayedBlock := dag.popDelayedBlock()
+		_, _, err := dag.processBlockNoLock(delayedBlock.block, BFAfterDelay)
+		if err != nil {
+			log.Errorf("Error while processing delayed block (block %s)", delayedBlock.block.Hash().String())
+			// Rule errors should not be propagated as they refer only to the delayed block,
+			// while this function runs in the context of another block
+			if !errors.As(err, &RuleError{}) {
+				return err
+			}
+		}
+		log.Debugf("Processed delayed block (block %s)", delayedBlock.block.Hash().String())
+	}
+
+	return nil
+}
+
+// popDelayedBlock removes the topmost (delayed block with earliest process time) of the queue and returns it.
+func (dag *BlockDAG) popDelayedBlock() *delayedBlock {
+	delayedBlock := dag.delayedBlocksQueue.pop()
+	delete(dag.delayedBlocks, *delayedBlock.block.Hash())
+	return delayedBlock
+}
+
+func (dag *BlockDAG) peekDelayedBlock() *delayedBlock {
+	return dag.delayedBlocksQueue.peek()
+}
+
 // IndexManager provides a generic interface that is called when blocks are
 // connected to the DAG for the purpose of supporting optional indexes.
 type IndexManager interface {
@@ -1883,7 +1943,7 @@ func New(config *Config) (*BlockDAG, error) {
 	targetTimePerBlock := int64(params.TargetTimePerBlock / time.Second)

 	index := newBlockIndex(config.DB, params)
-	dag := BlockDAG{
+	dag := &BlockDAG{
 		db:                             config.DB,
 		dagParams:                      params,
 		timeSource:                     config.TimeSource,
@@ -1894,9 +1954,10 @@ func New(config *Config) (*BlockDAG, error) {
 		TimestampDeviationTolerance:    params.TimestampDeviationTolerance,
 		powMaxBits:                     util.BigToCompact(params.PowMax),
 		index:                          index,
-		virtual:                        newVirtualBlock(nil, params.K),
 		orphans:                        make(map[daghash.Hash]*orphanBlock),
 		prevOrphans:                    make(map[daghash.Hash][]*orphanBlock),
+		delayedBlocks:                  make(map[daghash.Hash]*delayedBlock),
+		delayedBlocksQueue:             newDelayedBlocksHeap(),
 		warningCaches:                  newThresholdCaches(vbNumBits),
 		deploymentCaches:               newThresholdCaches(dagconfig.DefinedDeployments),
 		blockCount:                     0,
@@ -1904,7 +1965,9 @@ func New(config *Config) (*BlockDAG, error) {
 		subnetworkID:                   config.SubnetworkID,
 	}

-	dag.utxoDiffStore = newUTXODiffStore(&dag)
+	dag.virtual = newVirtualBlock(dag, nil)
+	dag.utxoDiffStore = newUTXODiffStore(dag)
+	dag.reachabilityStore = newReachabilityStore(dag)

 	// Initialize the DAG state from the passed database. When the db
 	// does not yet contain any DAG state, both it and the DAG state
@@ -1925,7 +1988,7 @@ func New(config *Config) (*BlockDAG, error) {
 	// Initialize and catch up all of the currently active optional indexes
 	// as needed.
 	if config.IndexManager != nil {
-		err = config.IndexManager.Init(dag.db, &dag, config.Interrupt)
+		err = config.IndexManager.Init(dag.db, dag, config.Interrupt)
 		if err != nil {
 			return nil, err
 		}
@@ -1935,13 +1998,14 @@ func New(config *Config) (*BlockDAG, error) {

 	if genesis == nil {
 		genesisBlock := util.NewBlock(dag.dagParams.GenesisBlock)
-		var isOrphan bool
-		var delay time.Duration
-		isOrphan, delay, err = dag.ProcessBlock(genesisBlock, BFNone)
+		// To prevent the creation of a new err variable unintentionally so the
+		// defered function above could read err - declare isOrphan and isDelayed explicitly.
+		var isOrphan, isDelayed bool
+		isOrphan, isDelayed, err = dag.ProcessBlock(genesisBlock, BFNone)
 		if err != nil {
 			return nil, err
 		}
-		if delay != 0 {
+		if isDelayed {
 			return nil, errors.New("Genesis block shouldn't be in the future")
 		}
 		if isOrphan {
@@ -1960,8 +2024,13 @@ func New(config *Config) (*BlockDAG, error) {
 	}

 	selectedTip := dag.selectedTip()
-	log.Infof("DAG state (chain height %d, hash %s)",
-		selectedTip.chainHeight, selectedTip.hash)
+	log.Infof("DAG state (blue score %d, hash %s)",
+		selectedTip.blueScore, selectedTip.hash)

-	return &dag, nil
+	return dag, nil
+}
+
+func (dag *BlockDAG) isKnownDelayedBlock(hash *daghash.Hash) bool {
+	_, exists := dag.delayedBlocks[*hash]
+	return exists
 }
--- a/blockdag/dag_test.go
+++ b/blockdag/dag_test.go
@@ -9,15 +9,9 @@ import (
 	"github.com/pkg/errors"
 	"os"
 	"path/filepath"
-	"reflect"
-	"strings"
 	"testing"
 	"time"

-	"bou.ke/monkey"
-
-	"math/rand"
-
 	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/database"
 	"github.com/kaspanet/kaspad/txscript"
@@ -47,7 +41,7 @@ func TestBlockCount(t *testing.T) {

 	// Create a new database and DAG instance to run tests against.
 	dag, teardownFunc, err := DAGSetup("TestBlockCount", Config{
-		DAGParams: &dagconfig.SimNetParams,
+		DAGParams: &dagconfig.SimnetParams,
 	})
 	if err != nil {
 		t.Fatalf("Failed to setup DAG instance: %v", err)
@@ -59,11 +53,11 @@ func TestBlockCount(t *testing.T) {
 	dag.TestSetCoinbaseMaturity(0)

 	for i := 1; i < len(blocks); i++ {
-		isOrphan, delay, err := dag.ProcessBlock(blocks[i], BFNone)
+		isOrphan, isDelayed, err := dag.ProcessBlock(blocks[i], BFNone)
 		if err != nil {
 			t.Fatalf("ProcessBlock fail on block %v: %v\n", i, err)
 		}
-		if delay != 0 {
+		if isDelayed {
 			t.Fatalf("ProcessBlock: block %d "+
 				"is too far in the future", i)
 		}
@@ -79,8 +73,8 @@ func TestBlockCount(t *testing.T) {
 	}
 }

-// TestHaveBlock tests the HaveBlock API to ensure proper functionality.
-func TestHaveBlock(t *testing.T) {
+// TestIsKnownBlock tests the IsKnownBlock API to ensure proper functionality.
+func TestIsKnownBlock(t *testing.T) {
 	// Load up blocks such that there is a fork in the DAG.
 	// (genesis block) -> 1 -> 2 -> 3 -> 4
 	//                          \-> 3b
@@ -100,7 +94,7 @@ func TestHaveBlock(t *testing.T) {

 	// Create a new database and DAG instance to run tests against.
 	dag, teardownFunc, err := DAGSetup("haveblock", Config{
-		DAGParams: &dagconfig.SimNetParams,
+		DAGParams: &dagconfig.SimnetParams,
 	})
 	if err != nil {
 		t.Fatalf("Failed to setup DAG instance: %v", err)
@@ -112,11 +106,11 @@ func TestHaveBlock(t *testing.T) {
 	dag.TestSetCoinbaseMaturity(0)

 	for i := 1; i < len(blocks); i++ {
-		isOrphan, delay, err := dag.ProcessBlock(blocks[i], BFNone)
+		isOrphan, isDelayed, err := dag.ProcessBlock(blocks[i], BFNone)
 		if err != nil {
 			t.Fatalf("ProcessBlock fail on block %v: %v\n", i, err)
 		}
-		if delay != 0 {
+		if isDelayed {
 			t.Fatalf("ProcessBlock: block %d "+
 				"is too far in the future", i)
 		}
@@ -138,13 +132,13 @@ func TestHaveBlock(t *testing.T) {
 		}
 		blocks = append(blocks, blockTmp...)
 	}
-	isOrphan, delay, err := dag.ProcessBlock(blocks[6], BFNone)
+	isOrphan, isDelayed, err := dag.ProcessBlock(blocks[6], BFNone)

 	// Block 3C should fail to connect since its parents are related. (It points to 1 and 2, and 1 is the parent of 2)
 	if err == nil {
 		t.Fatalf("ProcessBlock for block 3C has no error when expected to have an error\n")
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: block 3C " +
 			"is too far in the future")
 	}
@@ -165,20 +159,21 @@ func TestHaveBlock(t *testing.T) {
 		}
 		blocks = append(blocks, blockTmp...)
 	}
-	isOrphan, delay, err = dag.ProcessBlock(blocks[7], BFNone)
+	isOrphan, isDelayed, err = dag.ProcessBlock(blocks[7], BFNone)

 	// Block 3D should fail to connect since it has a transaction with the same input twice
 	if err == nil {
 		t.Fatalf("ProcessBlock for block 3D has no error when expected to have an error\n")
 	}
-	rErr, ok := err.(RuleError)
+	var ruleErr RuleError
+	ok := errors.As(err, &ruleErr)
 	if !ok {
 		t.Fatalf("ProcessBlock for block 3D expected a RuleError, but got %v\n", err)
 	}
-	if !ok || rErr.ErrorCode != ErrDuplicateTxInputs {
-		t.Fatalf("ProcessBlock for block 3D expected error code %s but got %s\n", ErrDuplicateTxInputs, rErr.ErrorCode)
+	if !ok || ruleErr.ErrorCode != ErrDuplicateTxInputs {
+		t.Fatalf("ProcessBlock for block 3D expected error code %s but got %s\n", ErrDuplicateTxInputs, ruleErr.ErrorCode)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: block 3D " +
 			"is too far in the future")
 	}
@@ -188,13 +183,13 @@ func TestHaveBlock(t *testing.T) {
 	}

 	// Insert an orphan block.
-	isOrphan, delay, err = dag.ProcessBlock(util.NewBlock(&Block100000), BFNoPoWCheck)
+	isOrphan, isDelayed, err = dag.ProcessBlock(util.NewBlock(&Block100000), BFNoPoWCheck)
 	if err != nil {
 		t.Fatalf("Unable to process block 100000: %v", err)
 	}
-	if delay != 0 {
-		t.Fatalf("ProcessBlock incorrectly returned that block 100000 "+
-			"has a %s delay", delay)
+	if isDelayed {
+		t.Fatalf("ProcessBlock incorrectly returned that block 100000 " +
+			"has a delay")
 	}
 	if !isOrphan {
 		t.Fatalf("ProcessBlock indicated block is an not orphan when " +
@@ -206,10 +201,10 @@ func TestHaveBlock(t *testing.T) {
 		want bool
 	}{
 		// Genesis block should be present.
-		{hash: dagconfig.SimNetParams.GenesisHash.String(), want: true},
+		{hash: dagconfig.SimnetParams.GenesisHash.String(), want: true},

 		// Block 3b should be present (as a second child of Block 2).
-		{hash: "6ffe9704c50b3f1892ce9e667337304ec0e9eb50a23673bc8ff7aaa20745ee4a", want: true},
+		{hash: "264176fb6072e2362db18f92d3f4b739cff071a206736df7c407c0bf9a1d7fef", want: true},

 		// Block 100000 should be present (as an orphan).
 		{hash: "65b20b048a074793ebfd1196e49341c8d194dabfc6b44a4fd0c607406e122baf", want: true},
@@ -224,9 +219,9 @@ func TestHaveBlock(t *testing.T) {
 			t.Fatalf("NewHashFromStr: %v", err)
 		}

-		result := dag.HaveBlock(hash)
+		result := dag.IsKnownBlock(hash)
 		if result != test.want {
-			t.Fatalf("HaveBlock #%d got %v want %v", i, result,
+			t.Fatalf("IsKnownBlock #%d got %v want %v", i, result,
 				test.want)
 		}
 	}
@@ -237,7 +232,7 @@ func TestHaveBlock(t *testing.T) {
 // combinations of inputs to the CalcSequenceLock function in order to ensure
 // the returned SequenceLocks are correct for each test instance.
 func TestCalcSequenceLock(t *testing.T) {
-	netParams := &dagconfig.SimNetParams
+	netParams := &dagconfig.SimnetParams

 	blockVersion := int32(0x10000000)

@@ -248,9 +243,9 @@ func TestCalcSequenceLock(t *testing.T) {
 	numBlocksToGenerate := 5
 	for i := 0; i < numBlocksToGenerate; i++ {
 		blockTime = blockTime.Add(time.Second)
-		node = newTestNode(setFromSlice(node), blockVersion, 0, blockTime, netParams.K)
+		node = newTestNode(dag, blockSetFromSlice(node), blockVersion, 0, blockTime)
 		dag.index.AddNode(node)
-		dag.virtual.SetTips(setFromSlice(node))
+		dag.virtual.SetTips(blockSetFromSlice(node))
 	}

 	// Create a utxo view with a fake utxo for the inputs used in the
@@ -275,7 +270,7 @@ func TestCalcSequenceLock(t *testing.T) {
 		TxID:  *targetTx.ID(),
 		Index: 0,
 	}
-	prevUtxoChainHeight := uint64(numBlocksToGenerate) - 4
+	prevUtxoBlueScore := uint64(numBlocksToGenerate) - 4

 	// Obtain the past median time from the PoV of the input created above.
 	// The past median time for the input is the past median time from the PoV
@@ -287,7 +282,7 @@ func TestCalcSequenceLock(t *testing.T) {
 	// the MTP will be calculated from the PoV of the yet-to-be-mined
 	// block.
 	nextMedianTime := node.PastMedianTime(dag).Unix()
-	nextBlockChainHeight := int32(numBlocksToGenerate) + 1
+	nextBlockBlueScore := int32(numBlocksToGenerate) + 1

 	// Add an additional transaction which will serve as our unconfirmed
 	// output.
@@ -373,7 +368,7 @@ func TestCalcSequenceLock(t *testing.T) {
 			utxoSet: utxoSet,
 			want: &SequenceLock{
 				Seconds:        medianTime + (5 << wire.SequenceLockTimeGranularity) - 1,
-				BlockBlueScore: int64(prevUtxoChainHeight) + 3,
+				BlockBlueScore: int64(prevUtxoBlueScore) + 3,
 			},
 		},
 		// Transaction with a single input. The input's sequence number
@@ -386,7 +381,7 @@ func TestCalcSequenceLock(t *testing.T) {
 			utxoSet: utxoSet,
 			want: &SequenceLock{
 				Seconds:        -1,
-				BlockBlueScore: int64(prevUtxoChainHeight) + 2,
+				BlockBlueScore: int64(prevUtxoBlueScore) + 2,
 			},
 		},
 		// A transaction with two inputs with lock times expressed in
@@ -425,7 +420,7 @@ func TestCalcSequenceLock(t *testing.T) {
 			utxoSet: utxoSet,
 			want: &SequenceLock{
 				Seconds:        -1,
-				BlockBlueScore: int64(prevUtxoChainHeight) + 10,
+				BlockBlueScore: int64(prevUtxoBlueScore) + 10,
 			},
 		},
 		// A transaction with multiple inputs. Two inputs are time
@@ -451,7 +446,7 @@ func TestCalcSequenceLock(t *testing.T) {
 			utxoSet: utxoSet,
 			want: &SequenceLock{
 				Seconds:        medianTime + (13 << wire.SequenceLockTimeGranularity) - 1,
-				BlockBlueScore: int64(prevUtxoChainHeight) + 8,
+				BlockBlueScore: int64(prevUtxoBlueScore) + 8,
 			},
 		},
 		// A transaction with a single unconfirmed input. As the input
@@ -467,7 +462,7 @@ func TestCalcSequenceLock(t *testing.T) {
 			mempool: true,
 			want: &SequenceLock{
 				Seconds:        -1,
-				BlockBlueScore: int64(nextBlockChainHeight) + 1,
+				BlockBlueScore: int64(nextBlockBlueScore) + 1,
 			},
 		},
 		// A transaction with a single unconfirmed input. The input has
@@ -505,7 +500,7 @@ func TestCalcSequenceLock(t *testing.T) {
 }

 func TestCalcPastMedianTime(t *testing.T) {
-	netParams := &dagconfig.SimNetParams
+	netParams := &dagconfig.SimnetParams

 	blockVersion := int32(0x10000000)

@@ -516,7 +511,7 @@ func TestCalcPastMedianTime(t *testing.T) {
 	blockTime := dag.genesis.Header().Timestamp
 	for i := uint32(1); i < numBlocks; i++ {
 		blockTime = blockTime.Add(time.Second)
-		nodes[i] = newTestNode(setFromSlice(nodes[i-1]), blockVersion, 0, blockTime, netParams.K)
+		nodes[i] = newTestNode(dag, blockSetFromSlice(nodes[i-1]), blockVersion, 0, blockTime)
 		dag.index.AddNode(nodes[i])
 	}

@@ -548,321 +543,12 @@ func TestCalcPastMedianTime(t *testing.T) {
 			t.Errorf("TestCalcPastMedianTime: expected past median time of block %v to be %v seconds from genesis but got %v", test.blockNumber, test.expectedSecondsSinceGenesis, secondsSinceGenesis)
 		}
 	}
-
-}
-
-// nodeHashes is a convenience function that returns the hashes for all of the
-// passed indexes of the provided nodes. It is used to construct expected hash
-// slices in the tests.
-func nodeHashes(nodes []*blockNode, indexes ...int) []*daghash.Hash {
-	hashes := make([]*daghash.Hash, 0, len(indexes))
-	for _, idx := range indexes {
-		hashes = append(hashes, nodes[idx].hash)
-	}
-	return hashes
-}
-
-// testNoncePrng provides a deterministic prng for the nonce in generated fake
-// nodes. The ensures that the node have unique hashes.
-var testNoncePrng = rand.New(rand.NewSource(0))
-
-// chainedNodes returns the specified number of nodes constructed such that each
-// subsequent node points to the previous one to create a chain. The first node
-// will point to the passed parent which can be nil if desired.
-func chainedNodes(parents blockSet, numNodes int) []*blockNode {
-	nodes := make([]*blockNode, numNodes)
-	tips := parents
-	for i := 0; i < numNodes; i++ {
-		// This is invalid, but all that is needed is enough to get the
-		// synthetic tests to work.
-		header := wire.BlockHeader{
-			Nonce:                testNoncePrng.Uint64(),
-			HashMerkleRoot:       &daghash.ZeroHash,
-			AcceptedIDMerkleRoot: &daghash.ZeroHash,
-			UTXOCommitment:       &daghash.ZeroHash,
-		}
-		header.ParentHashes = tips.hashes()
-		nodes[i] = newBlockNode(&header, tips, dagconfig.SimNetParams.K)
-		tips = setFromSlice(nodes[i])
-	}
-	return nodes
-}
-
-// testTip is a convenience function to grab the tip of a chain of block nodes
-// created via chainedNodes.
-func testTip(nodes []*blockNode) *blockNode {
-	return nodes[len(nodes)-1]
-}
-
-// TestChainHeightToHashRange ensures that fetching a range of block hashes by start
-// chain height and end hash works as expected.
-func TestChainHeightToHashRange(t *testing.T) {
-	// Construct a synthetic block DAG with a block index consisting of
-	// the following structure.
-	// 	genesis -> 1 -> 2 -> ... -> 15 -> 16  -> 17  -> 18
-	// 	                              \-> 16a -> 17a -> 18a (unvalidated)
-	tip := testTip
-	blockDAG := newTestDAG(&dagconfig.SimNetParams)
-	branch0Nodes := chainedNodes(setFromSlice(blockDAG.genesis), 18)
-	branch1Nodes := chainedNodes(setFromSlice(branch0Nodes[14]), 3)
-	for _, node := range branch0Nodes {
-		blockDAG.index.SetStatusFlags(node, statusValid)
-		blockDAG.index.AddNode(node)
-	}
-	for _, node := range branch1Nodes {
-		if node.chainHeight < 18 {
-			blockDAG.index.SetStatusFlags(node, statusValid)
-		}
-		blockDAG.index.AddNode(node)
-	}
-	blockDAG.virtual.SetTips(setFromSlice(tip(branch0Nodes)))
-
-	tests := []struct {
-		name             string
-		startChainHeight uint64          // locator for requested inventory
-		endHash          *daghash.Hash   // stop hash for locator
-		maxResults       int             // max to locate, 0 = wire const
-		hashes           []*daghash.Hash // expected located hashes
-		expectError      bool
-	}{
-		{
-			name:             "blocks below tip",
-			startChainHeight: 11,
-			endHash:          branch0Nodes[14].hash,
-			maxResults:       10,
-			hashes:           nodeHashes(branch0Nodes, 10, 11, 12, 13, 14),
-		},
-		{
-			name:             "blocks on main chain",
-			startChainHeight: 15,
-			endHash:          branch0Nodes[17].hash,
-			maxResults:       10,
-			hashes:           nodeHashes(branch0Nodes, 14, 15, 16, 17),
-		},
-		{
-			name:             "blocks on stale chain",
-			startChainHeight: 15,
-			endHash:          branch1Nodes[1].hash,
-			maxResults:       10,
-			hashes: append(nodeHashes(branch0Nodes, 14),
-				nodeHashes(branch1Nodes, 0, 1)...),
-		},
-		{
-			name:             "invalid start chain height",
-			startChainHeight: 19,
-			endHash:          branch0Nodes[17].hash,
-			maxResults:       10,
-			expectError:      true,
-		},
-		{
-			name:             "too many results",
-			startChainHeight: 1,
-			endHash:          branch0Nodes[17].hash,
-			maxResults:       10,
-			expectError:      true,
-		},
-		{
-			name:             "unvalidated block",
-			startChainHeight: 15,
-			endHash:          branch1Nodes[2].hash,
-			maxResults:       10,
-			expectError:      true,
-		},
-	}
-	for _, test := range tests {
-		hashes, err := blockDAG.ChainHeightToHashRange(test.startChainHeight, test.endHash,
-			test.maxResults)
-		if err != nil {
-			if !test.expectError {
-				t.Errorf("%s: unexpected error: %v", test.name, err)
-			}
-			continue
-		}
-
-		if !reflect.DeepEqual(hashes, test.hashes) {
-			t.Errorf("%s: unxpected hashes -- got %v, want %v",
-				test.name, hashes, test.hashes)
-		}
-	}
-}
-
-// TestIntervalBlockHashes ensures that fetching block hashes at specified
-// intervals by end hash works as expected.
-func TestIntervalBlockHashes(t *testing.T) {
-	// Construct a synthetic block DAG with a block index consisting of
-	// the following structure.
-	// 	genesis -> 1 -> 2 -> ... -> 15 -> 16  -> 17  -> 18
-	// 	                              \-> 16a -> 17a -> 18a (unvalidated)
-	tip := testTip
-	dag := newTestDAG(&dagconfig.SimNetParams)
-	branch0Nodes := chainedNodes(setFromSlice(dag.genesis), 18)
-	branch1Nodes := chainedNodes(setFromSlice(branch0Nodes[14]), 3)
-	for _, node := range branch0Nodes {
-		dag.index.SetStatusFlags(node, statusValid)
-		dag.index.AddNode(node)
-	}
-	for _, node := range branch1Nodes {
-		if node.chainHeight < 18 {
-			dag.index.SetStatusFlags(node, statusValid)
-		}
-		dag.index.AddNode(node)
-	}
-	dag.virtual.SetTips(setFromSlice(tip(branch0Nodes)))
-
-	tests := []struct {
-		name        string
-		endHash     *daghash.Hash
-		interval    uint64
-		hashes      []*daghash.Hash
-		expectError bool
-	}{
-		{
-			name:     "blocks on main chain",
-			endHash:  branch0Nodes[17].hash,
-			interval: 8,
-			hashes:   nodeHashes(branch0Nodes, 7, 15),
-		},
-		{
-			name:     "blocks on stale chain",
-			endHash:  branch1Nodes[1].hash,
-			interval: 8,
-			hashes: append(nodeHashes(branch0Nodes, 7),
-				nodeHashes(branch1Nodes, 0)...),
-		},
-		{
-			name:     "no results",
-			endHash:  branch0Nodes[17].hash,
-			interval: 20,
-			hashes:   []*daghash.Hash{},
-		},
-		{
-			name:        "unvalidated block",
-			endHash:     branch1Nodes[2].hash,
-			interval:    8,
-			expectError: true,
-		},
-	}
-	for _, test := range tests {
-		hashes, err := dag.IntervalBlockHashes(test.endHash, test.interval)
-		if err != nil {
-			if !test.expectError {
-				t.Errorf("%s: unexpected error: %v", test.name, err)
-			}
-			continue
-		}
-
-		if !reflect.DeepEqual(hashes, test.hashes) {
-			t.Errorf("%s: unxpected hashes -- got %v, want %v",
-				test.name, hashes, test.hashes)
-		}
-	}
-}
-
-// TestApplyUTXOChangesErrors tests that
-// dag.applyUTXOChanges panics when unexpected
-// error occurs
-func TestApplyUTXOChangesPanic(t *testing.T) {
-	targetErrorMessage := "updateParents error"
-	defer func() {
-		if recover() == nil {
-			t.Errorf("Got no panic on past UTXO error, while expected panic")
-		}
-	}()
-	testErrorThroughPatching(
-		t,
-		targetErrorMessage,
-		(*blockNode).updateParents,
-		func(_ *blockNode, _ *virtualBlock, _ UTXOSet) error {
-			return errors.New(targetErrorMessage)
-		},
-	)
-}
-
-// TestRestoreUTXOErrors tests all error-cases in restoreUTXO.
-// The non-error-cases are tested in the more general tests.
-func TestRestoreUTXOErrors(t *testing.T) {
-	targetErrorMessage := "WithDiff error"
-	testErrorThroughPatching(
-		t,
-		targetErrorMessage,
-		(*FullUTXOSet).WithDiff,
-		func(fus *FullUTXOSet, other *UTXODiff) (UTXOSet, error) {
-			return nil, errors.New(targetErrorMessage)
-		},
-	)
-}
-
-func testErrorThroughPatching(t *testing.T, expectedErrorMessage string, targetFunction interface{}, replacementFunction interface{}) {
-	// Load up blocks such that there is a fork in the DAG.
-	// (genesis block) -> 1 -> 2 -> 3 -> 4
-	//                          \-> 3b
-	testFiles := []string{
-		"blk_0_to_4.dat",
-		"blk_3B.dat",
-	}
-
-	var blocks []*util.Block
-	for _, file := range testFiles {
-		blockTmp, err := LoadBlocks(filepath.Join("testdata/", file))
-		if err != nil {
-			t.Fatalf("Error loading file: %v\n", err)
-		}
-		blocks = append(blocks, blockTmp...)
-	}
-
-	// Create a new database and dag instance to run tests against.
-	dag, teardownFunc, err := DAGSetup("testErrorThroughPatching", Config{
-		DAGParams: &dagconfig.SimNetParams,
-	})
-	if err != nil {
-		t.Fatalf("Failed to setup dag instance: %v", err)
-	}
-	defer teardownFunc()
-
-	// Since we're not dealing with the real block DAG, set the coinbase
-	// maturity to 0.
-	dag.TestSetCoinbaseMaturity(0)
-
-	guard := monkey.Patch(targetFunction, replacementFunction)
-	defer guard.Unpatch()
-
-	err = nil
-	for i := 1; i < len(blocks); i++ {
-		var isOrphan bool
-		var delay time.Duration
-		isOrphan, delay, err = dag.ProcessBlock(blocks[i], BFNone)
-		if delay != 0 {
-			t.Fatalf("ProcessBlock: block %d "+
-				"is too far in the future", i)
-		}
-		if isOrphan {
-			t.Fatalf("ProcessBlock incorrectly returned block %v "+
-				"is an orphan\n", i)
-		}
-		if err != nil {
-			break
-		}
-	}
-	if err == nil {
-		t.Errorf("ProcessBlock unexpectedly succeeded. "+
-			"Expected: %s", expectedErrorMessage)
-	}
-	if !strings.Contains(err.Error(), expectedErrorMessage) {
-		t.Errorf("ProcessBlock returned wrong error. "+
-			"Want: %s, got: %s", expectedErrorMessage, err)
-	}
 }

 func TestNew(t *testing.T) {
-	// Create the root directory for test databases.
-	if !FileExists(testDbRoot) {
-		if err := os.MkdirAll(testDbRoot, 0700); err != nil {
-			t.Fatalf("unable to create test db "+
-				"root: %s", err)
-		}
-	}
+	tempDir := os.TempDir()

-	dbPath := filepath.Join(testDbRoot, "TestNew")
+	dbPath := filepath.Join(tempDir, "TestNew")
 	_ = os.RemoveAll(dbPath)
 	db, err := database.Create(testDbType, dbPath, blockDataNet)
 	if err != nil {
@@ -871,10 +557,9 @@ func TestNew(t *testing.T) {
 	defer func() {
 		db.Close()
 		os.RemoveAll(dbPath)
-		os.RemoveAll(testDbRoot)
 	}()
 	config := &Config{
-		DAGParams:  &dagconfig.SimNetParams,
+		DAGParams:  &dagconfig.SimnetParams,
 		DB:         db,
 		TimeSource: NewMedianTime(),
 		SigCache:   txscript.NewSigCache(1000),
@@ -900,16 +585,10 @@ func TestNew(t *testing.T) {
 // occur when the node shuts down improperly while a block is being
 // validated.
 func TestAcceptingInInit(t *testing.T) {
-	// Create the root directory for test databases.
-	if !FileExists(testDbRoot) {
-		if err := os.MkdirAll(testDbRoot, 0700); err != nil {
-			t.Fatalf("unable to create test db "+
-				"root: %s", err)
-		}
-	}
+	tempDir := os.TempDir()

 	// Create a test database
-	dbPath := filepath.Join(testDbRoot, "TestAcceptingInInit")
+	dbPath := filepath.Join(tempDir, "TestAcceptingInInit")
 	_ = os.RemoveAll(dbPath)
 	db, err := database.Create(testDbType, dbPath, blockDataNet)
 	if err != nil {
@@ -918,12 +597,11 @@ func TestAcceptingInInit(t *testing.T) {
 	defer func() {
 		db.Close()
 		os.RemoveAll(dbPath)
-		os.RemoveAll(testDbRoot)
 	}()

 	// Create a DAG to add the test block into
 	config := &Config{
-		DAGParams:  &dagconfig.SimNetParams,
+		DAGParams:  &dagconfig.SimnetParams,
 		DB:         db,
 		TimeSource: NewMedianTime(),
 		SigCache:   txscript.NewSigCache(1000),
@@ -943,7 +621,7 @@ func TestAcceptingInInit(t *testing.T) {

 	// Create a test blockNode with an unvalidated status
 	genesisNode := dag.index.LookupNode(genesisBlock.Hash())
-	testNode := newBlockNode(&testBlock.MsgBlock().Header, setFromSlice(genesisNode), dag.dagParams.K)
+	testNode, _ := dag.newBlockNode(&testBlock.MsgBlock().Header, blockSetFromSlice(genesisNode))
 	testNode.status = statusDataStored

 	// Manually add the test block to the database
@@ -974,7 +652,7 @@ func TestAcceptingInInit(t *testing.T) {

 func TestConfirmations(t *testing.T) {
 	// Create a new database and DAG instance to run tests against.
-	params := dagconfig.SimNetParams
+	params := dagconfig.SimnetParams
 	params.K = 1
 	dag, teardownFunc, err := DAGSetup("TestConfirmations", Config{
 		DAGParams: &params,
@@ -990,62 +668,55 @@ func TestConfirmations(t *testing.T) {
 	if err != nil {
 		t.Fatalf("TestConfirmations: confirmations for genesis block unexpectedly failed: %s", err)
 	}
-	if genesisConfirmations != 1 {
+	if genesisConfirmations != 0 {
 		t.Fatalf("TestConfirmations: unexpected confirmations for genesis block. Want: 1, got: %d", genesisConfirmations)
 	}

 	// Add a chain of blocks
-	chainBlocks := make([]*blockNode, 5)
-	chainBlocks[0] = dag.genesis
-	buildNode := buildNodeGenerator(dag.dagParams.K, true)
+	chainBlocks := make([]*wire.MsgBlock, 5)
+	chainBlocks[0] = dag.dagParams.GenesisBlock
 	for i := uint32(1); i < 5; i++ {
-		chainBlocks[i] = buildNode(setFromSlice(chainBlocks[i-1]))
-		dag.virtual.AddTip(chainBlocks[i])
+		chainBlocks[i] = prepareAndProcessBlock(t, dag, chainBlocks[i-1])
 	}

 	// Make sure that each one of the chain blocks has the expected confirmations number
-	for i, node := range chainBlocks {
-		confirmations, err := dag.blockConfirmations(node)
+	for i, block := range chainBlocks {
+		confirmations, err := dag.BlockConfirmationsByHash(block.BlockHash())
 		if err != nil {
-			t.Fatalf("TestConfirmations: confirmations for node 1 unexpectedly failed: %s", err)
+			t.Fatalf("TestConfirmations: confirmations for block unexpectedly failed: %s", err)
 		}

-		expectedConfirmations := uint64(len(chainBlocks) - i)
+		expectedConfirmations := uint64(len(chainBlocks) - i - 1)
 		if confirmations != expectedConfirmations {
-			t.Fatalf("TestConfirmations: unexpected confirmations for node 1. "+
+			t.Fatalf("TestConfirmations: unexpected confirmations for block. "+
 				"Want: %d, got: %d", expectedConfirmations, confirmations)
 		}
 	}

-	branchingBlocks := make([]*blockNode, 2)
+	branchingBlocks := make([]*wire.MsgBlock, 2)
 	// Add two branching blocks
-	branchingBlocks[0] = buildNode(setFromSlice(chainBlocks[1]))
-	dag.virtual.AddTip(branchingBlocks[0])
-	branchingBlocks[1] = buildNode(setFromSlice(branchingBlocks[0]))
-	dag.virtual.AddTip(branchingBlocks[1])
+	branchingBlocks[0] = prepareAndProcessBlock(t, dag, chainBlocks[1])
+	branchingBlocks[1] = prepareAndProcessBlock(t, dag, branchingBlocks[0])

 	// Check that the genesis has a confirmations number == len(chainBlocks)
 	genesisConfirmations, err = dag.blockConfirmations(dag.genesis)
 	if err != nil {
 		t.Fatalf("TestConfirmations: confirmations for genesis block unexpectedly failed: %s", err)
 	}
-	expectedGenesisConfirmations := uint64(len(chainBlocks))
+	expectedGenesisConfirmations := uint64(len(chainBlocks)) - 1
 	if genesisConfirmations != expectedGenesisConfirmations {
 		t.Fatalf("TestConfirmations: unexpected confirmations for genesis block. "+
 			"Want: %d, got: %d", expectedGenesisConfirmations, genesisConfirmations)
 	}

-	// Check that each of the blue tips has a confirmation number of 1, and each of the red tips has 0 confirmations.
+	// Check that each of the tips has a 0 confirmations
 	tips := dag.virtual.tips()
-	for _, tip := range tips {
+	for tip := range tips {
 		tipConfirmations, err := dag.blockConfirmations(tip)
 		if err != nil {
 			t.Fatalf("TestConfirmations: confirmations for tip unexpectedly failed: %s", err)
 		}
 		expectedConfirmations := uint64(0)
-		if tip == dag.selectedTip() {
-			expectedConfirmations = 1
-		}
 		if tipConfirmations != expectedConfirmations {
 			t.Fatalf("TestConfirmations: unexpected confirmations for tip. "+
 				"Want: %d, got: %d", expectedConfirmations, tipConfirmations)
@@ -1055,14 +726,13 @@ func TestConfirmations(t *testing.T) {
 	// Generate 100 blocks to force the "main" chain to become red
 	branchingChainTip := branchingBlocks[1]
 	for i := uint32(0); i < 100; i++ {
-		nextBranchingChainTip := buildNode(setFromSlice(branchingChainTip))
-		dag.virtual.AddTip(nextBranchingChainTip)
+		nextBranchingChainTip := prepareAndProcessBlock(t, dag, branchingChainTip)
 		branchingChainTip = nextBranchingChainTip
 	}

 	// Make sure that a red block has confirmation number = 0
 	redChainBlock := chainBlocks[3]
-	redChainBlockConfirmations, err := dag.blockConfirmations(redChainBlock)
+	redChainBlockConfirmations, err := dag.BlockConfirmationsByHash(redChainBlock.BlockHash())
 	if err != nil {
 		t.Fatalf("TestConfirmations: confirmations for red chain block unexpectedly failed: %s", err)
 	}
@@ -1073,7 +743,7 @@ func TestConfirmations(t *testing.T) {

 	// Make sure that the red tip has confirmation number = 0
 	redChainTip := chainBlocks[len(chainBlocks)-1]
-	redChainTipConfirmations, err := dag.blockConfirmations(redChainTip)
+	redChainTipConfirmations, err := dag.BlockConfirmationsByHash(redChainTip.BlockHash())
 	if err != nil {
 		t.Fatalf("TestConfirmations: confirmations for red chain tip unexpectedly failed: %s", err)
 	}
@@ -1085,7 +755,7 @@ func TestConfirmations(t *testing.T) {

 func TestAcceptingBlock(t *testing.T) {
 	// Create a new database and DAG instance to run tests against.
-	params := dagconfig.SimNetParams
+	params := dagconfig.SimnetParams
 	params.K = 3
 	dag, teardownFunc, err := DAGSetup("TestAcceptingBlock", Config{
 		DAGParams: &params,
@@ -1096,6 +766,11 @@ func TestAcceptingBlock(t *testing.T) {
 	defer teardownFunc()
 	dag.TestSetCoinbaseMaturity(0)

+	acceptingBlockByMsgBlock := func(block *wire.MsgBlock) (*blockNode, error) {
+		node := nodeByMsgBlock(t, dag, block)
+		return dag.acceptingBlock(node)
+	}
+
 	// Check that the genesis block of a DAG with only the genesis block in it is accepted by the virtual.
 	genesisAcceptingBlock, err := dag.acceptingBlock(dag.genesis)
 	if err != nil {
@@ -1107,18 +782,16 @@ func TestAcceptingBlock(t *testing.T) {
 	}

 	numChainBlocks := uint32(10)
-	chainBlocks := make([]*blockNode, numChainBlocks)
-	chainBlocks[0] = dag.genesis
-	buildNode := buildNodeGenerator(dag.dagParams.K, true)
+	chainBlocks := make([]*wire.MsgBlock, numChainBlocks)
+	chainBlocks[0] = dag.dagParams.GenesisBlock
 	for i := uint32(1); i <= numChainBlocks-1; i++ {
-		chainBlocks[i] = buildNode(setFromSlice(chainBlocks[i-1]))
-		dag.virtual.AddTip(chainBlocks[i])
+		chainBlocks[i] = prepareAndProcessBlock(t, dag, chainBlocks[i-1])
 	}

 	// Make sure that each chain block (including the genesis) is accepted by its child
 	for i, chainBlockNode := range chainBlocks[:len(chainBlocks)-1] {
-		expectedAcceptingBlockNode := chainBlocks[i+1]
-		chainAcceptingBlockNode, err := dag.acceptingBlock(chainBlockNode)
+		expectedAcceptingBlockNode := nodeByMsgBlock(t, dag, chainBlocks[i+1])
+		chainAcceptingBlockNode, err := acceptingBlockByMsgBlock(chainBlockNode)
 		if err != nil {
 			t.Fatalf("TestAcceptingBlock: acceptingBlock for chain block %d unexpectedly failed: %s", i, err)
 		}
@@ -1129,7 +802,7 @@ func TestAcceptingBlock(t *testing.T) {
 	}

 	// Make sure that the selected tip doesn't have an accepting
-	tipAcceptingBlock, err := dag.acceptingBlock(chainBlocks[len(chainBlocks)-1])
+	tipAcceptingBlock, err := acceptingBlockByMsgBlock(chainBlocks[len(chainBlocks)-1])
 	if err != nil {
 		t.Fatalf("TestAcceptingBlock: acceptingBlock for tip unexpectedly failed: %s", err)
 	}
@@ -1138,25 +811,23 @@ func TestAcceptingBlock(t *testing.T) {
 			"Want: nil, got: %s", tipAcceptingBlock.hash)
 	}

-	// Generate side-chain of dag.dagParams.K + 1 blocks so its tip
-	// will be in the blues of the virtual but in the anticone of
-	// the selected tip.
-	branchingChainTip := chainBlocks[len(chainBlocks)-2]
-	for i := uint32(0); i < dag.dagParams.K+1; i++ {
-		nextBranchingChainTip := buildNode(setFromSlice(branchingChainTip))
-		dag.virtual.AddTip(nextBranchingChainTip)
-		branchingChainTip = nextBranchingChainTip
-	}
+	// Generate a chain tip that will be in the anticone of the selected tip and
+	// in dag.virtual.blues.
+	branchingChainTip := prepareAndProcessBlock(t, dag, chainBlocks[len(chainBlocks)-3])

 	// Make sure that branchingChainTip is not in the selected parent chain
-	if dag.IsInSelectedParentChain(branchingChainTip.hash) {
+	isBranchingChainTipInSelectedParentChain, err := dag.IsInSelectedParentChain(branchingChainTip.BlockHash())
+	if err != nil {
+		t.Fatalf("TestAcceptingBlock: IsInSelectedParentChain unexpectedly failed: %s", err)
+	}
+	if isBranchingChainTipInSelectedParentChain {
 		t.Fatalf("TestAcceptingBlock: branchingChainTip wasn't expected to be in the selected parent chain")
 	}

 	// Make sure that branchingChainTip is in the virtual blues
 	isVirtualBlue := false
 	for _, virtualBlue := range dag.virtual.blues {
-		if branchingChainTip == virtualBlue {
+		if branchingChainTip.BlockHash().IsEqual(virtualBlue.hash) {
 			isVirtualBlue = true
 			break
 		}
@@ -1167,7 +838,7 @@ func TestAcceptingBlock(t *testing.T) {

 	// Make sure that a block that is in the anticone of the selected tip and
 	// in the blues of the virtual doesn't have an accepting block
-	branchingChainTipAcceptionBlock, err := dag.acceptingBlock(branchingChainTip)
+	branchingChainTipAcceptionBlock, err := acceptingBlockByMsgBlock(branchingChainTip)
 	if err != nil {
 		t.Fatalf("TestAcceptingBlock: acceptingBlock for red chain block unexpectedly failed: %s", err)
 	}
@@ -1176,18 +847,16 @@ func TestAcceptingBlock(t *testing.T) {
 			"Want: nil, got: %s", branchingChainTipAcceptionBlock.hash)
 	}

-	// Add K + 1 branching blocks
+	// Add shorter side-chain
 	intersectionBlock := chainBlocks[1]
-	sideChainTip := buildNode(setFromSlice(intersectionBlock))
-	i := uint32(0)
-	for ; i < dag.dagParams.K+1; sideChainTip = buildNode(setFromSlice(sideChainTip)) {
-		dag.virtual.AddTip(sideChainTip)
-		i++
+	sideChainTip := intersectionBlock
+	for i := 0; i < len(chainBlocks)-3; i++ {
+		sideChainTip = prepareAndProcessBlock(t, dag, sideChainTip)
 	}

 	// Make sure that the accepting block of the parent of the branching block didn't change
-	expectedAcceptingBlock := chainBlocks[2]
-	intersectionAcceptingBlock, err := dag.acceptingBlock(intersectionBlock)
+	expectedAcceptingBlock := nodeByMsgBlock(t, dag, chainBlocks[2])
+	intersectionAcceptingBlock, err := acceptingBlockByMsgBlock(intersectionBlock)
 	if err != nil {
 		t.Fatalf("TestAcceptingBlock: acceptingBlock for intersection block unexpectedly failed: %s", err)
 	}
@@ -1198,10 +867,9 @@ func TestAcceptingBlock(t *testing.T) {

 	// Make sure that a block that is found in the red set of the selected tip
 	// doesn't have an accepting block
-	newTip := buildNode(setFromSlice(sideChainTip, chainBlocks[len(chainBlocks)-1]))
-	dag.virtual.AddTip(newTip)
+	prepareAndProcessBlock(t, dag, sideChainTip, chainBlocks[len(chainBlocks)-1])

-	sideChainTipAcceptingBlock, err := dag.acceptingBlock(sideChainTip)
+	sideChainTipAcceptingBlock, err := acceptingBlockByMsgBlock(sideChainTip)
 	if err != nil {
 		t.Fatalf("TestAcceptingBlock: acceptingBlock for sideChainTip unexpectedly failed: %s", err)
 	}
@@ -1217,7 +885,7 @@ func TestFinalizeNodesBelowFinalityPoint(t *testing.T) {
 }

 func testFinalizeNodesBelowFinalityPoint(t *testing.T, deleteDiffData bool) {
-	params := dagconfig.SimNetParams
+	params := dagconfig.SimnetParams
 	params.K = 1
 	dag, teardownFunc, err := DAGSetup("testFinalizeNodesBelowFinalityPoint", Config{
 		DAGParams: &params,
@@ -1242,7 +910,7 @@ func testFinalizeNodesBelowFinalityPoint(t *testing.T, deleteDiffData bool) {

 	addNode := func(parent *blockNode) *blockNode {
 		blockTime = blockTime.Add(time.Second)
-		node := newTestNode(setFromSlice(parent), blockVersion, 0, blockTime, dag.dagParams.K)
+		node := newTestNode(dag, blockSetFromSlice(parent), blockVersion, 0, blockTime)
 		node.updateParentsChildren()
 		dag.index.AddNode(node)

@@ -1258,7 +926,7 @@ func testFinalizeNodesBelowFinalityPoint(t *testing.T, deleteDiffData bool) {
 	nodes := make([]*blockNode, 0, finalityInterval)
 	currentNode := dag.genesis
 	nodes = append(nodes, currentNode)
-	for i := 0; i <= finalityInterval*2; i++ {
+	for i := uint64(0); i <= finalityInterval*2; i++ {
 		currentNode = addNode(currentNode)
 		nodes = append(nodes, currentNode)
 	}
@@ -1303,7 +971,7 @@ func testFinalizeNodesBelowFinalityPoint(t *testing.T, deleteDiffData bool) {
 }

 func TestDAGIndexFailedStatus(t *testing.T) {
-	params := dagconfig.SimNetParams
+	params := dagconfig.SimnetParams
 	dag, teardownFunc, err := DAGSetup("TestDAGIndexFailedStatus", Config{
 		DAGParams: &params,
 	})
@@ -1326,12 +994,12 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 	)
 	invalidMsgBlock.AddTransaction(invalidCbTx)
 	invalidBlock := util.NewBlock(invalidMsgBlock)
-	isOrphan, delay, err := dag.ProcessBlock(invalidBlock, BFNoPoWCheck)
+	isOrphan, isDelayed, err := dag.ProcessBlock(invalidBlock, BFNoPoWCheck)

-	if _, ok := err.(RuleError); !ok {
+	if !errors.As(err, &RuleError{}) {
 		t.Fatalf("ProcessBlock: expected a rule error but got %s instead", err)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: invalidBlock " +
 			"is too far in the future")
 	}
@@ -1356,11 +1024,12 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 	invalidMsgBlockChild.AddTransaction(invalidCbTx)
 	invalidBlockChild := util.NewBlock(invalidMsgBlockChild)

-	isOrphan, delay, err = dag.ProcessBlock(invalidBlockChild, BFNoPoWCheck)
-	if rErr, ok := err.(RuleError); !ok || rErr.ErrorCode != ErrInvalidAncestorBlock {
+	isOrphan, isDelayed, err = dag.ProcessBlock(invalidBlockChild, BFNoPoWCheck)
+	var ruleErr RuleError
+	if ok := errors.As(err, &ruleErr); !ok || ruleErr.ErrorCode != ErrInvalidAncestorBlock {
 		t.Fatalf("ProcessBlock: expected a rule error but got %s instead", err)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: invalidBlockChild " +
 			"is too far in the future")
 	}
@@ -1384,11 +1053,11 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 	invalidMsgBlockGrandChild.AddTransaction(invalidCbTx)
 	invalidBlockGrandChild := util.NewBlock(invalidMsgBlockGrandChild)

-	isOrphan, delay, err = dag.ProcessBlock(invalidBlockGrandChild, BFNoPoWCheck)
-	if rErr, ok := err.(RuleError); !ok || rErr.ErrorCode != ErrInvalidAncestorBlock {
+	isOrphan, isDelayed, err = dag.ProcessBlock(invalidBlockGrandChild, BFNoPoWCheck)
+	if ok := errors.As(err, &ruleErr); !ok || ruleErr.ErrorCode != ErrInvalidAncestorBlock {
 		t.Fatalf("ProcessBlock: expected a rule error but got %s instead", err)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: invalidBlockGrandChild " +
 			"is too far in the future")
 	}
@@ -1404,3 +1073,18 @@ func TestDAGIndexFailedStatus(t *testing.T) {
 		t.Fatalf("invalidBlockGrandChildNode status to have %b flags raised (got %b)", statusInvalidAncestor, invalidBlockGrandChildNode.status)
 	}
 }
+
+func TestIsDAGCurrentMaxDiff(t *testing.T) {
+	netParams := []*dagconfig.Params{
+		&dagconfig.MainnetParams,
+		&dagconfig.TestnetParams,
+		&dagconfig.DevnetParams,
+		&dagconfig.RegressionNetParams,
+		&dagconfig.SimnetParams,
+	}
+	for _, params := range netParams {
+		if params.TargetTimePerBlock*time.Duration(params.FinalityInterval) < isDAGCurrentMaxDiff {
+			t.Errorf("in %s, a DAG can be considered current even if it's below the finality point", params.Name)
+		}
+	}
+}
--- a/blockdag/dagio.go
+++ b/blockdag/dagio.go
@@ -9,6 +9,7 @@ import (
 	"encoding/binary"
 	"encoding/json"
 	"fmt"
+	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/pkg/errors"
 	"io"
 	"sync"
@@ -33,7 +34,7 @@ const (
 )

 var (
-	// blockIndexBucketName is the name of the db bucket used to house to the
+	// blockIndexBucketName is the name of the database bucket used to house the
 	// block headers and contextual information.
 	blockIndexBucketName = []byte("blockheaderidx")

@@ -45,15 +46,19 @@ var (
 	// version of the utxo set currently in the database.
 	utxoSetVersionKeyName = []byte("utxosetversion")

-	// utxoSetBucketName is the name of the db bucket used to house the
+	// utxoSetBucketName is the name of the database bucket used to house the
 	// unspent transaction output set.
 	utxoSetBucketName = []byte("utxoset")

-	// utxoDiffsBucketName is the name of the db bucket used to house the
+	// utxoDiffsBucketName is the name of the database bucket used to house the
 	// diffs and diff children of blocks.
 	utxoDiffsBucketName = []byte("utxodiffs")

-	// subnetworksBucketName is the name of the db bucket used to store the
+	// reachabilityDataBucketName is the name of the database bucket used to house the
+	// reachability tree nodes and future covering sets of blocks.
+	reachabilityDataBucketName = []byte("reachability")
+
+	// subnetworksBucketName is the name of the database bucket used to store the
 	// subnetwork registry.
 	subnetworksBucketName = []byte("subnetworks")

@@ -78,8 +83,8 @@ func (e errNotInDAG) Error() string {
 // isNotInDAGErr returns whether or not the passed error is an
 // errNotInDAG error.
 func isNotInDAGErr(err error) bool {
-	_, ok := err.(errNotInDAG)
-	return ok
+	var notInDAGErr errNotInDAG
+	return errors.As(err, &notInDAGErr)
 }

 // errDeserialize signifies that a problem was encountered when deserializing
@@ -94,8 +99,8 @@ func (e errDeserialize) Error() string {
 // isDeserializeErr returns whether or not the passed error is an errDeserialize
 // error.
 func isDeserializeErr(err error) bool {
-	_, ok := err.(errDeserialize)
-	return ok
+	var deserializeErr errDeserialize
+	return errors.As(err, &deserializeErr)
 }

 // dbPutVersion uses an existing database transaction to update the provided
@@ -317,6 +322,11 @@ func (dag *BlockDAG) createDAGState() error {
 			return err
 		}

+		_, err = meta.CreateBucket(reachabilityDataBucketName)
+		if err != nil {
+			return err
+		}
+
 		err = dbPutVersion(dbTx, utxoSetVersionKeyName,
 			latestUTXOSetBucketVersion)
 		if err != nil {
@@ -367,6 +377,11 @@ func (dag *BlockDAG) removeDAGState() error {
 			return err
 		}

+		err = meta.DeleteBucket(reachabilityDataBucketName)
+		if err != nil {
+			return err
+		}
+
 		err = dbTx.Metadata().Delete(utxoSetVersionKeyName)
 		if err != nil {
 			return err
@@ -455,8 +470,6 @@ func (dag *BlockDAG) initDAGState() error {

 		blockIndexBucket := dbTx.Metadata().Bucket(blockIndexBucketName)

-		var i int32
-		var lastNode *blockNode
 		var unprocessedBlockNodes []*blockNode
 		cursor := blockIndexBucket.Cursor()
 		for ok := cursor.First(); ok; ok = cursor.Next() {
@@ -472,7 +485,14 @@ func (dag *BlockDAG) initDAGState() error {
 				continue
 			}

-			if lastNode == nil {
+			// If the node is known to be invalid add it as-is to the block
+			// index and continue.
+			if node.status.KnownInvalid() {
+				dag.index.addNode(node)
+				continue
+			}
+
+			if dag.blockCount == 0 {
 				if !node.hash.IsEqual(dag.dagParams.GenesisHash) {
 					return AssertError(fmt.Sprintf("initDAGState: Expected "+
 						"first entry in block index to be genesis block, "+
@@ -490,12 +510,7 @@ func (dag *BlockDAG) initDAGState() error {
 			node.updateParentsChildren()
 			dag.index.addNode(node)

-			if node.status.KnownValid() {
-				dag.blockCount++
-			}
-
-			lastNode = node
-			i++
+			dag.blockCount++
 		}

 		// Load all of the known UTXO entries and construct the full
@@ -549,6 +564,12 @@ func (dag *BlockDAG) initDAGState() error {
 			fullUTXOCollection[*outpoint] = entry
 		}

+		// Initialize the reachability store
+		err = dag.reachabilityStore.init(dbTx)
+		if err != nil {
+			return err
+		}
+
 		// Apply the loaded utxoCollection to the virtual block.
 		dag.virtual.utxoSet, err = newFullUTXOSetFromUTXOCollection(fullUTXOCollection)
 		if err != nil {
@@ -556,7 +577,7 @@ func (dag *BlockDAG) initDAGState() error {
 		}

 		// Apply the stored tips to the virtual block.
-		tips := newSet()
+		tips := newBlockSet()
 		for _, tipHash := range state.TipHashes {
 			tip := dag.index.LookupNode(tipHash)
 			if tip == nil {
@@ -587,7 +608,10 @@ func (dag *BlockDAG) initDAGState() error {

 			// Attempt to accept the block.
 			block, err := dbFetchBlockByNode(dbTx, node)
-			isOrphan, delay, err := dag.ProcessBlock(block, BFWasStored)
+			if err != nil {
+				return err
+			}
+			isOrphan, isDelayed, err := dag.ProcessBlock(block, BFWasStored)
 			if err != nil {
 				log.Warnf("Block %s, which was not previously processed, "+
 					"failed to be accepted to the DAG: %s", node.hash, err)
@@ -601,7 +625,7 @@ func (dag *BlockDAG) initDAGState() error {
 					"previously processed, turned out to be an orphan, which is "+
 					"impossible.", node.hash))
 			}
-			if delay != 0 {
+			if isDelayed {
 				return AssertError(fmt.Sprintf("Block %s, which was not "+
 					"previously processed, turned out to be delayed, which is "+
 					"impossible.", node.hash))
@@ -633,8 +657,8 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 		utxoCommitment:       header.UTXOCommitment,
 	}

-	node.children = newSet()
-	node.parents = newSet()
+	node.children = newBlockSet()
+	node.parents = newBlockSet()

 	for _, hash := range header.ParentHashes {
 		parent := dag.index.LookupNode(hash)
@@ -680,7 +704,27 @@ func (dag *BlockDAG) deserializeBlockNode(blockRow []byte) (*blockNode, error) {
 		node.blues[i] = dag.index.LookupNode(hash)
 	}

-	node.chainHeight = calculateChainHeight(node)
+	bluesAnticoneSizesLen, err := wire.ReadVarInt(buffer)
+	if err != nil {
+		return nil, err
+	}
+
+	node.bluesAnticoneSizes = make(map[*blockNode]dagconfig.KType)
+	for i := uint64(0); i < bluesAnticoneSizesLen; i++ {
+		hash := &daghash.Hash{}
+		if _, err := io.ReadFull(buffer, hash[:]); err != nil {
+			return nil, err
+		}
+		bluesAnticoneSize, err := binaryserializer.Uint8(buffer)
+		if err != nil {
+			return nil, err
+		}
+		blue := dag.index.LookupNode(hash)
+		if blue == nil {
+			return nil, errors.Errorf("couldn't find block with hash %s", hash)
+		}
+		node.bluesAnticoneSizes[blue] = dagconfig.KType(bluesAnticoneSize)
+	}

 	return node, nil
 }
@@ -703,20 +747,17 @@ func dbFetchBlockByNode(dbTx database.Tx, node *blockNode) (*util.Block, error)
 	return block, nil
 }

-// dbStoreBlockNode stores the block node data into the block
-// index bucket. This overwrites the current entry if there exists one.
-func dbStoreBlockNode(dbTx database.Tx, node *blockNode) error {
-	// Serialize block data to be stored.
+func serializeBlockNode(node *blockNode) ([]byte, error) {
 	w := bytes.NewBuffer(make([]byte, 0, blockHdrSize+1))
 	header := node.Header()
 	err := header.Serialize(w)
 	if err != nil {
-		return err
+		return nil, err
 	}

 	err = w.WriteByte(byte(node.status))
 	if err != nil {
-		return err
+		return nil, err
 	}

 	// Because genesis doesn't have selected parent, it's serialized as zero hash
@@ -726,32 +767,55 @@ func dbStoreBlockNode(dbTx database.Tx, node *blockNode) error {
 	}
 	_, err = w.Write(selectedParentHash[:])
 	if err != nil {
-		return err
+		return nil, err
 	}

 	err = binaryserializer.PutUint64(w, byteOrder, node.blueScore)
 	if err != nil {
-		return err
+		return nil, err
 	}

 	err = wire.WriteVarInt(w, uint64(len(node.blues)))
 	if err != nil {
-		return err
+		return nil, err
 	}

 	for _, blue := range node.blues {
 		_, err = w.Write(blue.hash[:])
 		if err != nil {
-			return err
+			return nil, err
 		}
 	}

-	value := w.Bytes()
+	err = wire.WriteVarInt(w, uint64(len(node.bluesAnticoneSizes)))
+	if err != nil {
+		return nil, err
+	}
+	for blue, blueAnticoneSize := range node.bluesAnticoneSizes {
+		_, err = w.Write(blue.hash[:])
+		if err != nil {
+			return nil, err
+		}

+		err = binaryserializer.PutUint8(w, uint8(blueAnticoneSize))
+		if err != nil {
+			return nil, err
+		}
+	}
+	return w.Bytes(), nil
+}
+
+// dbStoreBlockNode stores the block node data into the block
+// index bucket. This overwrites the current entry if there exists one.
+func dbStoreBlockNode(dbTx database.Tx, node *blockNode) error {
+	serializedNode, err := serializeBlockNode(node)
+	if err != nil {
+		return err
+	}
 	// Write block header data to block index bucket.
 	blockIndexBucket := dbTx.Metadata().Bucket(blockIndexBucketName)
 	key := BlockIndexKey(node.hash, node.blueScore)
-	return blockIndexBucket.Put(key, value)
+	return blockIndexBucket.Put(key, serializedNode)
 }

 // dbStoreBlock stores the provided block in the database if it is not already
@@ -803,33 +867,33 @@ func (dag *BlockDAG) BlockByHash(hash *daghash.Hash) (*util.Block, error) {
 	return block, err
 }

-// BlockHashesFrom returns a slice of blocks starting from startHash
-// ordered by blueScore. If startHash is nil then the genesis block is used.
+// BlockHashesFrom returns a slice of blocks starting from lowHash
+// ordered by blueScore. If lowHash is nil then the genesis block is used.
 //
 // This method MUST be called with the DAG lock held
-func (dag *BlockDAG) BlockHashesFrom(startHash *daghash.Hash, limit int) ([]*daghash.Hash, error) {
+func (dag *BlockDAG) BlockHashesFrom(lowHash *daghash.Hash, limit int) ([]*daghash.Hash, error) {
 	blockHashes := make([]*daghash.Hash, 0, limit)
-	if startHash == nil {
-		startHash = dag.genesis.hash
+	if lowHash == nil {
+		lowHash = dag.genesis.hash

 		// If we're starting from the beginning we should include the
 		// genesis hash in the result
 		blockHashes = append(blockHashes, dag.genesis.hash)
 	}
-	if !dag.BlockExists(startHash) {
-		return nil, errors.Errorf("block %s not found", startHash)
+	if !dag.IsInDAG(lowHash) {
+		return nil, errors.Errorf("block %s not found", lowHash)
 	}
-	blueScore, err := dag.BlueScoreByBlockHash(startHash)
+	blueScore, err := dag.BlueScoreByBlockHash(lowHash)
 	if err != nil {
 		return nil, err
 	}

 	err = dag.index.db.View(func(dbTx database.Tx) error {
 		blockIndexBucket := dbTx.Metadata().Bucket(blockIndexBucketName)
-		startKey := BlockIndexKey(startHash, blueScore)
+		lowKey := BlockIndexKey(lowHash, blueScore)

 		cursor := blockIndexBucket.Cursor()
-		cursor.Seek(startKey)
+		cursor.Seek(lowKey)
 		for ok := cursor.Next(); ok; ok = cursor.Next() {
 			key := cursor.Key()
 			blockHash, err := blockHashFromBlockIndexKey(key)
--- a/blockdag/dagio_test.go
+++ b/blockdag/dagio_test.go
@@ -248,12 +248,13 @@ func TestDAGStateDeserializeErrors(t *testing.T) {
 				test.name, err, test.errType)
 			continue
 		}
-		if derr, ok := err.(database.Error); ok {
+		var dbErr database.Error
+		if ok := errors.As(err, &dbErr); ok {
 			tderr := test.errType.(database.Error)
-			if derr.ErrorCode != tderr.ErrorCode {
+			if dbErr.ErrorCode != tderr.ErrorCode {
 				t.Errorf("deserializeDAGState (%s): "+
 					"wrong error code got: %v, want: %v",
-					test.name, derr.ErrorCode,
+					test.name, dbErr.ErrorCode,
 					tderr.ErrorCode)
 				continue
 			}
--- a/blockdag/delayedblockheap.go
+++ b/blockdag/delayedblockheap.go
@@ -0,0 +1,73 @@
+package blockdag
+
+import (
+	"container/heap"
+)
+
+type baseDelayedBlocksHeap []*delayedBlock
+
+func (h baseDelayedBlocksHeap) Len() int {
+	return len(h)
+}
+func (h baseDelayedBlocksHeap) Swap(i, j int) {
+	h[i], h[j] = h[j], h[i]
+}
+
+func (h *baseDelayedBlocksHeap) Push(x interface{}) {
+	*h = append(*h, x.(*delayedBlock))
+}
+
+func (h *baseDelayedBlocksHeap) Pop() interface{} {
+	oldHeap := *h
+	oldLength := len(oldHeap)
+	popped := oldHeap[oldLength-1]
+	*h = oldHeap[0 : oldLength-1]
+	return popped
+}
+
+func (h baseDelayedBlocksHeap) peek() interface{} {
+	if h.Len() > 0 {
+		return h[h.Len()-1]
+	}
+	return nil
+}
+
+func (h baseDelayedBlocksHeap) Less(i, j int) bool {
+	return h[j].processTime.After(h[i].processTime)
+}
+
+type delayedBlocksHeap struct {
+	baseDelayedBlocksHeap *baseDelayedBlocksHeap
+	impl                  heap.Interface
+}
+
+// newDelayedBlocksHeap initializes and returns a new delayedBlocksHeap
+func newDelayedBlocksHeap() delayedBlocksHeap {
+	baseHeap := &baseDelayedBlocksHeap{}
+	h := delayedBlocksHeap{impl: baseHeap, baseDelayedBlocksHeap: baseHeap}
+	heap.Init(h.impl)
+	return h
+}
+
+// pop removes the block with lowest height from this heap and returns it
+func (dbh delayedBlocksHeap) pop() *delayedBlock {
+	return heap.Pop(dbh.impl).(*delayedBlock)
+}
+
+// Push pushes the block onto the heap
+func (dbh delayedBlocksHeap) Push(block *delayedBlock) {
+	heap.Push(dbh.impl, block)
+}
+
+// Len returns the length of this heap
+func (dbh delayedBlocksHeap) Len() int {
+	return dbh.impl.Len()
+}
+
+// peek returns the topmost element in the queue without poping it
+func (dbh delayedBlocksHeap) peek() *delayedBlock {
+	if dbh.baseDelayedBlocksHeap.peek() == nil {
+		return nil
+	}
+	return dbh.baseDelayedBlocksHeap.peek().(*delayedBlock)
+}
--- a/blockdag/difficulty_test.go
+++ b/blockdag/difficulty_test.go
@@ -6,8 +6,6 @@ package blockdag

 import (
 	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
 	"math/big"
 	"testing"
 	"time"
@@ -81,65 +79,77 @@ func TestCalcWork(t *testing.T) {
 }

 func TestDifficulty(t *testing.T) {
-	params := dagconfig.SimNetParams
+	params := dagconfig.SimnetParams
 	params.K = 1
-	dag := newTestDAG(&params)
-	nonce := uint64(0)
+	params.DifficultyAdjustmentWindowSize = 264
+	dag, teardownFunc, err := DAGSetup("TestDifficulty", Config{
+		DAGParams: &params,
+	})
+	if err != nil {
+		t.Fatalf("Failed to setup DAG instance: %v", err)
+	}
+	defer teardownFunc()
+
 	zeroTime := time.Unix(0, 0)
 	addNode := func(parents blockSet, blockTime time.Time) *blockNode {
 		bluestParent := parents.bluest()
 		if blockTime == zeroTime {
 			blockTime = time.Unix(bluestParent.timestamp+1, 0)
 		}
-		header := &wire.BlockHeader{
-			ParentHashes:         parents.hashes(),
-			Bits:                 dag.requiredDifficulty(bluestParent, blockTime),
-			Nonce:                nonce,
-			Timestamp:            blockTime,
-			HashMerkleRoot:       &daghash.ZeroHash,
-			AcceptedIDMerkleRoot: &daghash.ZeroHash,
-			UTXOCommitment:       &daghash.ZeroHash,
+		block, err := PrepareBlockForTest(dag, parents.hashes(), nil)
+		if err != nil {
+			t.Fatalf("unexpected error in PrepareBlockForTest: %s", err)
 		}
-		node := newBlockNode(header, parents, dag.dagParams.K)
-		node.updateParentsChildren()
-		nonce++
-		return node
+		block.Header.Timestamp = blockTime
+		block.Header.Bits = dag.requiredDifficulty(bluestParent, blockTime)
+
+		isOrphan, isDelayed, err := dag.ProcessBlock(util.NewBlock(block), BFNoPoWCheck)
+		if err != nil {
+			t.Fatalf("unexpected error in ProcessBlock: %s", err)
+		}
+		if isDelayed {
+			t.Fatalf("block is too far in the future")
+		}
+		if isOrphan {
+			t.Fatalf("block was unexpectedly orphan")
+		}
+		return dag.index.LookupNode(block.BlockHash())
 	}
 	tip := dag.genesis
 	for i := uint64(0); i < dag.difficultyAdjustmentWindowSize; i++ {
-		tip = addNode(setFromSlice(tip), zeroTime)
+		tip = addNode(blockSetFromSlice(tip), zeroTime)
 		if tip.bits != dag.genesis.bits {
 			t.Fatalf("As long as the bluest parent's blue score is less then the difficulty adjustment window size, the difficulty should be the same as genesis'")
 		}
 	}
-	for i := uint64(0); i < dag.difficultyAdjustmentWindowSize+1000; i++ {
-		tip = addNode(setFromSlice(tip), zeroTime)
+	for i := uint64(0); i < dag.difficultyAdjustmentWindowSize+100; i++ {
+		tip = addNode(blockSetFromSlice(tip), zeroTime)
 		if tip.bits != dag.genesis.bits {
 			t.Fatalf("As long as the block rate remains the same, the difficulty shouldn't change")
 		}
 	}
-	nodeInThePast := addNode(setFromSlice(tip), tip.PastMedianTime(dag))
+	nodeInThePast := addNode(blockSetFromSlice(tip), tip.PastMedianTime(dag))
 	if nodeInThePast.bits != tip.bits {
 		t.Fatalf("The difficulty should only change when nodeInThePast is in the past of a block bluest parent")
 	}
 	tip = nodeInThePast

-	tip = addNode(setFromSlice(tip), zeroTime)
+	tip = addNode(blockSetFromSlice(tip), zeroTime)
 	if tip.bits != nodeInThePast.bits {
 		t.Fatalf("The difficulty should only change when nodeInThePast is in the past of a block bluest parent")
 	}
-	tip = addNode(setFromSlice(tip), zeroTime)
+	tip = addNode(blockSetFromSlice(tip), zeroTime)
 	if compareBits(tip.bits, nodeInThePast.bits) >= 0 {
 		t.Fatalf("tip.bits should be smaller than nodeInThePast.bits because nodeInThePast increased the block rate, so the difficulty should increase as well")
 	}
-	expectedBits := uint32(0x207ff395)
+	expectedBits := uint32(0x207f83df)
 	if tip.bits != expectedBits {
 		t.Errorf("tip.bits was expected to be %x but got %x", expectedBits, tip.bits)
 	}

 	// Increase block rate to increase difficulty
 	for i := uint64(0); i < dag.difficultyAdjustmentWindowSize; i++ {
-		tip = addNode(setFromSlice(tip), tip.PastMedianTime(dag))
+		tip = addNode(blockSetFromSlice(tip), tip.PastMedianTime(dag))
 		if compareBits(tip.bits, tip.parents.bluest().bits) > 0 {
 			t.Fatalf("Because we're increasing the block rate, the difficulty can't decrease")
 		}
@@ -149,7 +159,7 @@ func TestDifficulty(t *testing.T) {
 	lastBits := tip.bits
 	sameBitsCount := uint64(0)
 	for sameBitsCount < dag.difficultyAdjustmentWindowSize+1 {
-		tip = addNode(setFromSlice(tip), zeroTime)
+		tip = addNode(blockSetFromSlice(tip), zeroTime)
 		if tip.bits == lastBits {
 			sameBitsCount++
 		} else {
@@ -157,35 +167,35 @@ func TestDifficulty(t *testing.T) {
 			sameBitsCount = 0
 		}
 	}
-	slowNode := addNode(setFromSlice(tip), time.Unix(tip.timestamp+2, 0))
+	slowNode := addNode(blockSetFromSlice(tip), time.Unix(tip.timestamp+2, 0))
 	if slowNode.bits != tip.bits {
 		t.Fatalf("The difficulty should only change when slowNode is in the past of a block bluest parent")
 	}

 	tip = slowNode

-	tip = addNode(setFromSlice(tip), zeroTime)
+	tip = addNode(blockSetFromSlice(tip), zeroTime)
 	if tip.bits != slowNode.bits {
 		t.Fatalf("The difficulty should only change when slowNode is in the past of a block bluest parent")
 	}
-	tip = addNode(setFromSlice(tip), zeroTime)
+	tip = addNode(blockSetFromSlice(tip), zeroTime)
 	if compareBits(tip.bits, slowNode.bits) <= 0 {
 		t.Fatalf("tip.bits should be smaller than slowNode.bits because slowNode decreased the block rate, so the difficulty should decrease as well")
 	}

-	splitNode := addNode(setFromSlice(tip), zeroTime)
+	splitNode := addNode(blockSetFromSlice(tip), zeroTime)
 	tip = splitNode
 	for i := 0; i < 100; i++ {
-		tip = addNode(setFromSlice(tip), zeroTime)
+		tip = addNode(blockSetFromSlice(tip), zeroTime)
 	}
 	blueTip := tip

 	redChainTip := splitNode
 	for i := 0; i < 10; i++ {
-		redChainTip = addNode(setFromSlice(redChainTip), redChainTip.PastMedianTime(dag))
+		redChainTip = addNode(blockSetFromSlice(redChainTip), redChainTip.PastMedianTime(dag))
 	}
-	tipWithRedPast := addNode(setFromSlice(redChainTip, blueTip), zeroTime)
-	tipWithoutRedPast := addNode(setFromSlice(blueTip), zeroTime)
+	tipWithRedPast := addNode(blockSetFromSlice(redChainTip, blueTip), zeroTime)
+	tipWithoutRedPast := addNode(blockSetFromSlice(blueTip), zeroTime)
 	if tipWithoutRedPast.bits != tipWithRedPast.bits {
 		t.Fatalf("tipWithoutRedPast.bits should be the same as tipWithRedPast.bits because red blocks shouldn't affect the difficulty")
 	}
--- a/blockdag/doc.go
+++ b/blockdag/doc.go
@@ -1,28 +1,21 @@
-// Copyright (c) 2013-2014 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
 /*
 Package blockdag implements kaspa block handling and DAG selection rules.

 The kaspa block handling and DAG selection rules are an integral, and quite
-likely the most important, part of kaspa. At its core, kaspa is a
-distributed consensus of which blocks are valid and which ones will comprise the
-DAG (public ledger) that ultimately determines accepted
-transactions, so it is extremely important that fully validating nodes agree on
-all rules.
+likely the most important, part of kaspa. At its core, kaspa is a distributed
+consensus of which blocks are valid and which ones will comprise the DAG
+(public ledger) that ultimately determines accepted transactions, so it is
+extremely important that fully validating nodes agree on all rules.

 At a high level, this package provides support for inserting new blocks into
-the block DAG according to the aforementioned rules. It includes
-functionality such as rejecting duplicate blocks, ensuring blocks and
-transactions follow all rules, orphan handling, and DAG order along
-with reorganization.
+the block DAG according to the aforementioned rules. It includes functionality
+such as rejecting duplicate blocks, ensuring blocks and transactions follow all
+rules, orphan handling, and DAG order along with reorganization.

 Since this package does not deal with other kaspa specifics such as network
-communication or wallets, it provides a notification system which gives the
-caller a high level of flexibility in how they want to react to certain events
-such as orphan blocks which need their parents requested and newly connected
-DAG blocks which might result in wallet updates.
+communication, it provides a notification system which gives the caller a high
+level of flexibility in how they want to react to certain events such as orphan
+blocks which need their parents requested and newly connected DAG blocks.

 Kaspa DAG Processing Overview

--- a/blockdag/error.go
+++ b/blockdag/error.go
@@ -217,6 +217,10 @@ const (
 	// ErrInvalidParentsRelation indicates that one of the parents of a block
 	// is also an ancestor of another parent
 	ErrInvalidParentsRelation
+
+	// ErrDelayedBlockIsNotAllowed indicates that a block with a delayed timestamp was
+	// submitted with BFDisallowDelay flag raised.
+	ErrDelayedBlockIsNotAllowed
 )

 // Map of ErrorCode values back to their constant names for pretty printing.
@@ -264,6 +268,7 @@ var errorCodeStrings = map[ErrorCode]string{
 	ErrInvalidPayload:            "ErrInvalidPayload",
 	ErrInvalidPayloadHash:        "ErrInvalidPayloadHash",
 	ErrInvalidParentsRelation:    "ErrInvalidParentsRelation",
+	ErrDelayedBlockIsNotAllowed:  "ErrDelayedBlockIsNotAllowed",
 }

 // String returns the ErrorCode as a human-readable name.
--- a/blockdag/error_test.go
+++ b/blockdag/error_test.go
@@ -58,6 +58,7 @@ func TestErrorCodeStringer(t *testing.T) {
 		{ErrInvalidPayload, "ErrInvalidPayload"},
 		{ErrInvalidPayloadHash, "ErrInvalidPayloadHash"},
 		{ErrInvalidParentsRelation, "ErrInvalidParentsRelation"},
+		{ErrDelayedBlockIsNotAllowed, "ErrDelayedBlockIsNotAllowed"},
 		{0xffff, "Unknown ErrorCode (65535)"},
 	}

--- a/blockdag/external_dag_test.go
+++ b/blockdag/external_dag_test.go
@@ -37,7 +37,7 @@ import (
 // gets rejected because it doesn't have the last finality point in
 // its selected parent chain.
 func TestFinality(t *testing.T) {
-	params := dagconfig.SimNetParams
+	params := dagconfig.SimnetParams
 	params.K = 1
 	params.FinalityInterval = 100
 	dag, teardownFunc, err := blockdag.DAGSetup("TestFinality", blockdag.Config{
@@ -54,11 +54,11 @@ func TestFinality(t *testing.T) {
 		}
 		block := util.NewBlock(msgBlock)

-		isOrphan, delay, err := dag.ProcessBlock(block, blockdag.BFNoPoWCheck)
+		isOrphan, isDelayed, err := dag.ProcessBlock(block, blockdag.BFNoPoWCheck)
 		if err != nil {
 			return nil, err
 		}
-		if delay != 0 {
+		if isDelayed {
 			return nil, errors.Errorf("ProcessBlock: block " +
 				"is too far in the future")
 		}
@@ -73,7 +73,7 @@ func TestFinality(t *testing.T) {
 	currentNode := genesis

 	// First we build a chain of params.FinalityInterval blocks for future use
-	for i := 0; i < params.FinalityInterval; i++ {
+	for i := uint64(0); i < params.FinalityInterval; i++ {
 		currentNode, err = buildNodeToDag([]*daghash.Hash{currentNode.Hash()})
 		if err != nil {
 			t.Fatalf("TestFinality: buildNodeToDag unexpectedly returned an error: %v", err)
@@ -85,7 +85,7 @@ func TestFinality(t *testing.T) {
 	// Now we build a new chain of 2 * params.FinalityInterval blocks, pointed to genesis, and
 	// we expect the block with height 1 * params.FinalityInterval to be the last finality point
 	currentNode = genesis
-	for i := 0; i < params.FinalityInterval; i++ {
+	for i := uint64(0); i < params.FinalityInterval; i++ {
 		currentNode, err = buildNodeToDag([]*daghash.Hash{currentNode.Hash()})
 		if err != nil {
 			t.Fatalf("TestFinality: buildNodeToDag unexpectedly returned an error: %v", err)
@@ -94,7 +94,7 @@ func TestFinality(t *testing.T) {

 	expectedFinalityPoint := currentNode

-	for i := 0; i < params.FinalityInterval; i++ {
+	for i := uint64(0); i < params.FinalityInterval; i++ {
 		currentNode, err = buildNodeToDag([]*daghash.Hash{currentNode.Hash()})
 		if err != nil {
 			t.Fatalf("TestFinality: buildNodeToDag unexpectedly returned an error: %v", err)
@@ -137,10 +137,10 @@ func TestFinality(t *testing.T) {
 	if err == nil {
 		t.Errorf("TestFinality: buildNodeToDag expected an error but got <nil>")
 	}
-	rErr, ok := err.(blockdag.RuleError)
-	if ok {
-		if rErr.ErrorCode != blockdag.ErrFinality {
-			t.Errorf("TestFinality: buildNodeToDag expected an error with code %v but instead got %v", blockdag.ErrFinality, rErr.ErrorCode)
+	var ruleErr blockdag.RuleError
+	if errors.As(err, &ruleErr) {
+		if ruleErr.ErrorCode != blockdag.ErrFinality {
+			t.Errorf("TestFinality: buildNodeToDag expected an error with code %v but instead got %v", blockdag.ErrFinality, ruleErr.ErrorCode)
 		}
 	} else {
 		t.Errorf("TestFinality: buildNodeToDag got unexpected error: %v", err)
@@ -152,13 +152,12 @@ func TestFinality(t *testing.T) {
 	if err == nil {
 		t.Errorf("TestFinality: buildNodeToDag expected an error but got <nil>")
 	}
-	rErr, ok = err.(blockdag.RuleError)
-	if ok {
-		if rErr.ErrorCode != blockdag.ErrFinality {
-			t.Errorf("TestFinality: buildNodeToDag expected an error with code %v but instead got %v", blockdag.ErrFinality, rErr.ErrorCode)
+	if errors.As(err, &ruleErr) {
+		if ruleErr.ErrorCode != blockdag.ErrFinality {
+			t.Errorf("TestFinality: buildNodeToDag expected an error with code %v but instead got %v", blockdag.ErrFinality, ruleErr.ErrorCode)
 		}
 	} else {
-		t.Errorf("TestFinality: buildNodeToDag got unexpected error: %v", rErr)
+		t.Errorf("TestFinality: buildNodeToDag got unexpected error: %v", ruleErr)
 	}
 }

@@ -167,15 +166,23 @@ func TestFinality(t *testing.T) {
 // a getblocks message it should always be able to send
 // all the necessary invs.
 func TestFinalityInterval(t *testing.T) {
-	params := dagconfig.SimNetParams
-	if params.FinalityInterval > wire.MaxInvPerMsg {
-		t.Errorf("dagconfig.SimNetParams.FinalityInterval should be lower or equal to wire.MaxInvPerMsg")
+	netParams := []*dagconfig.Params{
+		&dagconfig.MainnetParams,
+		&dagconfig.TestnetParams,
+		&dagconfig.DevnetParams,
+		&dagconfig.RegressionNetParams,
+		&dagconfig.SimnetParams,
+	}
+	for _, params := range netParams {
+		if params.FinalityInterval > wire.MaxInvPerMsg {
+			t.Errorf("FinalityInterval in %s should be lower or equal to wire.MaxInvPerMsg", params.Name)
+		}
 	}
 }

 // TestSubnetworkRegistry tests the full subnetwork registry flow
 func TestSubnetworkRegistry(t *testing.T) {
-	params := dagconfig.SimNetParams
+	params := dagconfig.SimnetParams
 	params.K = 1
 	params.BlockCoinbaseMaturity = 0
 	dag, teardownFunc, err := blockdag.DAGSetup("TestSubnetworkRegistry", blockdag.Config{
@@ -201,7 +208,7 @@ func TestSubnetworkRegistry(t *testing.T) {
 }

 func TestChainedTransactions(t *testing.T) {
-	params := dagconfig.SimNetParams
+	params := dagconfig.SimnetParams
 	params.BlockCoinbaseMaturity = 0
 	// Create a new database and dag instance to run tests against.
 	dag, teardownFunc, err := blockdag.DAGSetup("TestChainedTransactions", blockdag.Config{
@@ -216,11 +223,11 @@ func TestChainedTransactions(t *testing.T) {
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
-	isOrphan, delay, err := dag.ProcessBlock(util.NewBlock(block1), blockdag.BFNoPoWCheck)
+	isOrphan, isDelayed, err := dag.ProcessBlock(util.NewBlock(block1), blockdag.BFNoPoWCheck)
 	if err != nil {
 		t.Fatalf("ProcessBlock: %v", err)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: block1 " +
 			"is too far in the future")
 	}
@@ -266,17 +273,20 @@ func TestChainedTransactions(t *testing.T) {
 	}

 	//Checks that dag.ProcessBlock fails because we don't allow a transaction to spend another transaction from the same block
-	isOrphan, delay, err = dag.ProcessBlock(util.NewBlock(block2), blockdag.BFNoPoWCheck)
+	isOrphan, isDelayed, err = dag.ProcessBlock(util.NewBlock(block2), blockdag.BFNoPoWCheck)
 	if err == nil {
 		t.Errorf("ProcessBlock expected an error")
-	} else if rErr, ok := err.(blockdag.RuleError); ok {
-		if rErr.ErrorCode != blockdag.ErrMissingTxOut {
-			t.Errorf("ProcessBlock expected an %v error code but got %v", blockdag.ErrMissingTxOut, rErr.ErrorCode)
-		}
 	} else {
-		t.Errorf("ProcessBlock expected a blockdag.RuleError but got %v", err)
+		var ruleErr blockdag.RuleError
+		if ok := errors.As(err, &ruleErr); ok {
+			if ruleErr.ErrorCode != blockdag.ErrMissingTxOut {
+				t.Errorf("ProcessBlock expected an %v error code but got %v", blockdag.ErrMissingTxOut, ruleErr.ErrorCode)
+			}
+		} else {
+			t.Errorf("ProcessBlock expected a blockdag.RuleError but got %v", err)
+		}
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: block2 " +
 			"is too far in the future")
 	}
@@ -301,11 +311,11 @@ func TestChainedTransactions(t *testing.T) {
 	}

 	//Checks that dag.ProcessBlock doesn't fail because all of its transaction are dependant on transactions from previous blocks
-	isOrphan, delay, err = dag.ProcessBlock(util.NewBlock(block3), blockdag.BFNoPoWCheck)
+	isOrphan, isDelayed, err = dag.ProcessBlock(util.NewBlock(block3), blockdag.BFNoPoWCheck)
 	if err != nil {
 		t.Errorf("ProcessBlock: %v", err)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: block3 " +
 			"is too far in the future")
 	}
@@ -319,8 +329,8 @@ func TestChainedTransactions(t *testing.T) {
 // before txB.
 func TestOrderInDiffFromAcceptanceData(t *testing.T) {
 	// Create a new database and DAG instance to run tests against.
-	params := dagconfig.SimNetParams
-	params.K = math.MaxUint32
+	params := dagconfig.SimnetParams
+	params.K = math.MaxUint8
 	dag, teardownFunc, err := blockdag.DAGSetup("TestOrderInDiffFromAcceptanceData", blockdag.Config{
 		DAGParams: &params,
 	})
@@ -359,11 +369,11 @@ func TestOrderInDiffFromAcceptanceData(t *testing.T) {

 		// Add the block to the DAG
 		newBlock := util.NewBlock(msgBlock)
-		isOrphan, delay, err := dag.ProcessBlock(newBlock, blockdag.BFNoPoWCheck)
+		isOrphan, isDelayed, err := dag.ProcessBlock(newBlock, blockdag.BFNoPoWCheck)
 		if err != nil {
 			t.Errorf("TestOrderInDiffFromAcceptanceData: %s", err)
 		}
-		if delay != 0 {
+		if isDelayed {
 			t.Fatalf("TestOrderInDiffFromAcceptanceData: block is too far in the future")
 		}
 		if isOrphan {
@@ -388,7 +398,7 @@ func TestOrderInDiffFromAcceptanceData(t *testing.T) {

 // TestGasLimit tests the gas limit rules
 func TestGasLimit(t *testing.T) {
-	params := dagconfig.SimNetParams
+	params := dagconfig.SimnetParams
 	params.K = 1
 	params.BlockCoinbaseMaturity = 0
 	dag, teardownFunc, err := blockdag.DAGSetup("TestSubnetworkRegistry", blockdag.Config{
@@ -412,11 +422,11 @@ func TestGasLimit(t *testing.T) {
 		if err != nil {
 			t.Fatalf("PrepareBlockForTest: %v", err)
 		}
-		isOrphan, delay, err := dag.ProcessBlock(util.NewBlock(fundsBlock), blockdag.BFNoPoWCheck)
+		isOrphan, isDelayed, err := dag.ProcessBlock(util.NewBlock(fundsBlock), blockdag.BFNoPoWCheck)
 		if err != nil {
 			t.Fatalf("ProcessBlock: %v", err)
 		}
-		if delay != 0 {
+		if isDelayed {
 			t.Fatalf("ProcessBlock: the funds block " +
 				"is too far in the future")
 		}
@@ -464,17 +474,17 @@ func TestGasLimit(t *testing.T) {
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
-	isOrphan, delay, err := dag.ProcessBlock(util.NewBlock(overLimitBlock), blockdag.BFNoPoWCheck)
+	isOrphan, isDelayed, err := dag.ProcessBlock(util.NewBlock(overLimitBlock), blockdag.BFNoPoWCheck)
 	if err == nil {
 		t.Fatalf("ProcessBlock expected to have an error in block that exceeds gas limit")
 	}
-	rErr, ok := err.(blockdag.RuleError)
-	if !ok {
+	var ruleErr blockdag.RuleError
+	if !errors.As(err, &ruleErr) {
 		t.Fatalf("ProcessBlock expected a RuleError, but got %v", err)
-	} else if rErr.ErrorCode != blockdag.ErrInvalidGas {
-		t.Fatalf("ProcessBlock expected error code %s but got %s", blockdag.ErrInvalidGas, rErr.ErrorCode)
+	} else if ruleErr.ErrorCode != blockdag.ErrInvalidGas {
+		t.Fatalf("ProcessBlock expected error code %s but got %s", blockdag.ErrInvalidGas, ruleErr.ErrorCode)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: overLimitBlock " +
 			"is too far in the future")
 	}
@@ -499,19 +509,22 @@ func TestGasLimit(t *testing.T) {
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
-	isOrphan, delay, err = dag.ProcessBlock(util.NewBlock(overflowGasBlock), blockdag.BFNoPoWCheck)
+	isOrphan, isDelayed, err = dag.ProcessBlock(util.NewBlock(overflowGasBlock), blockdag.BFNoPoWCheck)
 	if err == nil {
 		t.Fatalf("ProcessBlock expected to have an error")
 	}
-	rErr, ok = err.(blockdag.RuleError)
-	if !ok {
+	if !errors.As(err, &ruleErr) {
 		t.Fatalf("ProcessBlock expected a RuleError, but got %v", err)
-	} else if rErr.ErrorCode != blockdag.ErrInvalidGas {
-		t.Fatalf("ProcessBlock expected error code %s but got %s", blockdag.ErrInvalidGas, rErr.ErrorCode)
+	} else if ruleErr.ErrorCode != blockdag.ErrInvalidGas {
+		t.Fatalf("ProcessBlock expected error code %s but got %s", blockdag.ErrInvalidGas, ruleErr.ErrorCode)
 	}
 	if isOrphan {
 		t.Fatalf("ProcessBlock: overLimitBlock got unexpectedly orphan")
 	}
+	if isDelayed {
+		t.Fatalf("ProcessBlock: overflowGasBlock " +
+			"is too far in the future")
+	}

 	nonExistentSubnetwork := &subnetworkid.SubnetworkID{123}
 	nonExistentSubnetworkTxIn := &wire.TxIn{
@@ -532,23 +545,30 @@ func TestGasLimit(t *testing.T) {
 	}

 	// Here we check that we can't process a block with a transaction from a non-existent subnetwork
-	isOrphan, delay, err = dag.ProcessBlock(util.NewBlock(nonExistentSubnetworkBlock), blockdag.BFNoPoWCheck)
+	isOrphan, isDelayed, err = dag.ProcessBlock(util.NewBlock(nonExistentSubnetworkBlock), blockdag.BFNoPoWCheck)
 	expectedErrStr := fmt.Sprintf("Error getting gas limit for subnetworkID '%s': subnetwork '%s' not found",
 		nonExistentSubnetwork, nonExistentSubnetwork)
 	if err.Error() != expectedErrStr {
 		t.Fatalf("ProcessBlock expected error \"%v\" but got \"%v\"", expectedErrStr, err)
 	}
+	if isDelayed {
+		t.Fatalf("ProcessBlock: nonExistentSubnetworkBlock " +
+			"is too far in the future")
+	}
+	if isOrphan {
+		t.Fatalf("ProcessBlock: nonExistentSubnetworkBlock got unexpectedly orphan")
+	}

 	// Here we check that we can process a block with a transaction that doesn't exceed the gas limit
 	validBlock, err := mining.PrepareBlockForTest(dag, &params, dag.TipHashes(), []*wire.MsgTx{tx1}, true)
 	if err != nil {
 		t.Fatalf("PrepareBlockForTest: %v", err)
 	}
-	isOrphan, delay, err = dag.ProcessBlock(util.NewBlock(validBlock), blockdag.BFNoPoWCheck)
+	isOrphan, isDelayed, err = dag.ProcessBlock(util.NewBlock(validBlock), blockdag.BFNoPoWCheck)
 	if err != nil {
 		t.Fatalf("ProcessBlock: %v", err)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: overLimitBlock " +
 			"is too far in the future")
 	}
--- a/blockdag/fullblocks_test.go
+++ b/blockdag/fullblocks_test.go
@@ -1,317 +0,0 @@
-// Copyright (c) 2016 The Decred developers
-// Copyright (c) 2016-2017 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package blockdag_test
-
-import (
-	"bytes"
-	"github.com/pkg/errors"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/blockdag/fullblocktests"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
-	_ "github.com/kaspanet/kaspad/database/ffldb"
-	"github.com/kaspanet/kaspad/txscript"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-const (
-	// testDbType is the database backend type to use for the tests.
-	testDbType = "ffldb"
-
-	// testDbRoot is the root directory used to create all test databases.
-	testDbRoot = "testdbs"
-
-	// blockDataNet is the expected network in the test block data.
-	blockDataNet = wire.MainNet
-)
-
-// filesExists returns whether or not the named file or directory exists.
-func fileExists(name string) bool {
-	if _, err := os.Stat(name); err != nil {
-		if os.IsNotExist(err) {
-			return false
-		}
-	}
-	return true
-}
-
-// isSupportedDbType returns whether or not the passed database type is
-// currently supported.
-func isSupportedDbType(dbType string) bool {
-	supportedDrivers := database.SupportedDrivers()
-	for _, driver := range supportedDrivers {
-		if dbType == driver {
-			return true
-		}
-	}
-
-	return false
-}
-
-// DAGSetup is used to create a new db and DAG instance with the genesis
-// block already inserted. In addition to the new DAG instance, it returns
-// a teardown function the caller should invoke when done testing to clean up.
-func DAGSetup(dbName string, params *dagconfig.Params) (*blockdag.BlockDAG, func(), error) {
-	if !isSupportedDbType(testDbType) {
-		return nil, nil, errors.Errorf("unsupported db type %v", testDbType)
-	}
-
-	// Handle memory database specially since it doesn't need the disk
-	// specific handling.
-	var db database.DB
-	var teardown func()
-	if testDbType == "memdb" {
-		ndb, err := database.Create(testDbType)
-		if err != nil {
-			return nil, nil, errors.Errorf("error creating db: %v", err)
-		}
-		db = ndb
-
-		// Setup a teardown function for cleaning up. This function is
-		// returned to the caller to be invoked when it is done testing.
-		teardown = func() {
-			db.Close()
-		}
-	} else {
-		// Create the root directory for test databases.
-		if !fileExists(testDbRoot) {
-			if err := os.MkdirAll(testDbRoot, 0700); err != nil {
-				err := errors.Errorf("unable to create test db "+
-					"root: %v", err)
-				return nil, nil, err
-			}
-		}
-
-		// Create a new database to store the accepted blocks into.
-		dbPath := filepath.Join(testDbRoot, dbName)
-		_ = os.RemoveAll(dbPath)
-		ndb, err := database.Create(testDbType, dbPath, blockDataNet)
-		if err != nil {
-			return nil, nil, errors.Errorf("error creating db: %v", err)
-		}
-		db = ndb
-
-		// Setup a teardown function for cleaning up. This function is
-		// returned to the caller to be invoked when it is done testing.
-		teardown = func() {
-			db.Close()
-			os.RemoveAll(dbPath)
-			os.RemoveAll(testDbRoot)
-		}
-	}
-
-	// Copy the DAG params to ensure any modifications the tests do to
-	// the DAG parameters do not affect the global instance.
-	paramsCopy := *params
-
-	// Create the DAG instance.
-	dag, err := blockdag.New(&blockdag.Config{
-		DB:         db,
-		DAGParams:  &paramsCopy,
-		TimeSource: blockdag.NewMedianTime(),
-		SigCache:   txscript.NewSigCache(1000),
-	})
-	if err != nil {
-		teardown()
-		err := errors.Errorf("failed to create DAG instance: %v", err)
-		return nil, nil, err
-	}
-	return dag, teardown, nil
-}
-
-// TestFullBlocks ensures all tests generated by the fullblocktests package
-// have the expected result when processed via ProcessBlock.
-func TestFullBlocks(t *testing.T) {
-	// TODO: (Stas) This test was disabled for until we have implemented Phantom
-	// Ticket: https://daglabs.atlassian.net/browse/DEV-60
-	t.SkipNow()
-
-	tests, err := fullblocktests.Generate(false)
-	if err != nil {
-		t.Fatalf("failed to generate tests: %v", err)
-	}
-
-	// Create a new database and DAG instance to run tests against.
-	dag, teardownFunc, err := DAGSetup("fullblocktest",
-		&dagconfig.RegressionNetParams)
-	if err != nil {
-		t.Errorf("Failed to setup chain instance: %v", err)
-		return
-	}
-	defer teardownFunc()
-
-	// testAcceptedBlock attempts to process the block in the provided test
-	// instance and ensures that it was accepted according to the flags
-	// specified in the test.
-	testAcceptedBlock := func(item fullblocktests.AcceptedBlock) {
-		blockHeight := item.Height
-		block := util.NewBlock(item.Block)
-		block.SetChainHeight(blockHeight)
-		t.Logf("Testing block %s (hash %s, height %d)",
-			item.Name, block.Hash(), blockHeight)
-
-		isOrphan, delay, err := dag.ProcessBlock(block,
-			blockdag.BFNone)
-		if err != nil {
-			t.Fatalf("block %q (hash %s, height %d) should "+
-				"have been accepted: %v", item.Name,
-				block.Hash(), blockHeight, err)
-		}
-
-		if delay != item.Delay {
-			t.Fatalf("block %q (hash %s, height %d) unexpected "+
-				"delay -- got %v, want %v", item.Name,
-				block.Hash(), blockHeight, delay,
-				item.Delay)
-		}
-
-		if isOrphan != item.IsOrphan {
-			t.Fatalf("block %q (hash %s, height %d) unexpected "+
-				"orphan flag -- got %v, want %v", item.Name,
-				block.Hash(), blockHeight, isOrphan,
-				item.IsOrphan)
-		}
-	}
-
-	// testRejectedBlock attempts to process the block in the provided test
-	// instance and ensures that it was rejected with the reject code
-	// specified in the test.
-	testRejectedBlock := func(item fullblocktests.RejectedBlock) {
-		blockHeight := item.Height
-		block := util.NewBlock(item.Block)
-		block.SetChainHeight(blockHeight)
-		t.Logf("Testing block %s (hash %s, height %d)",
-			item.Name, block.Hash(), blockHeight)
-
-		_, _, err := dag.ProcessBlock(block, blockdag.BFNone)
-		if err == nil {
-			t.Fatalf("block %q (hash %s, height %d) should not "+
-				"have been accepted", item.Name, block.Hash(),
-				blockHeight)
-		}
-
-		// Ensure the error code is of the expected type and the reject
-		// code matches the value specified in the test instance.
-		rerr, ok := err.(blockdag.RuleError)
-		if !ok {
-			t.Fatalf("block %q (hash %s, height %d) returned "+
-				"unexpected error type -- got %T, want "+
-				"blockchain.RuleError", item.Name, block.Hash(),
-				blockHeight, err)
-		}
-		if rerr.ErrorCode != item.RejectCode {
-			t.Fatalf("block %q (hash %s, height %d) does not have "+
-				"expected reject code -- got %v, want %v",
-				item.Name, block.Hash(), blockHeight,
-				rerr.ErrorCode, item.RejectCode)
-		}
-	}
-
-	// testRejectedNonCanonicalBlock attempts to decode the block in the
-	// provided test instance and ensures that it failed to decode with a
-	// message error.
-	testRejectedNonCanonicalBlock := func(item fullblocktests.RejectedNonCanonicalBlock) {
-		headerLen := len(item.RawBlock)
-		if headerLen > 80 {
-			headerLen = 80
-		}
-		blockHash := daghash.DoubleHashH(item.RawBlock[0:headerLen])
-		blockHeight := item.Height
-		t.Logf("Testing block %s (hash %s, height %d)", item.Name,
-			blockHash, blockHeight)
-
-		// Ensure there is an error due to deserializing the block.
-		var msgBlock wire.MsgBlock
-		err := msgBlock.KaspaDecode(bytes.NewReader(item.RawBlock), 0)
-		if _, ok := err.(*wire.MessageError); !ok {
-			t.Fatalf("block %q (hash %s, height %d) should have "+
-				"failed to decode", item.Name, blockHash,
-				blockHeight)
-		}
-	}
-
-	// testOrphanOrRejectedBlock attempts to process the block in the
-	// provided test instance and ensures that it was either accepted as an
-	// orphan or rejected with a rule violation.
-	testOrphanOrRejectedBlock := func(item fullblocktests.OrphanOrRejectedBlock) {
-		blockHeight := item.Height
-		block := util.NewBlock(item.Block)
-		block.SetChainHeight(blockHeight)
-		t.Logf("Testing block %s (hash %s, height %d)",
-			item.Name, block.Hash(), blockHeight)
-
-		isOrphan, delay, err := dag.ProcessBlock(block, blockdag.BFNone)
-		if err != nil {
-			// Ensure the error code is of the expected type.
-			if _, ok := err.(blockdag.RuleError); !ok {
-				t.Fatalf("block %q (hash %s, height %d) "+
-					"returned unexpected error type -- "+
-					"got %T, want blockdag.RuleError",
-					item.Name, block.Hash(), blockHeight,
-					err)
-			}
-		}
-
-		if delay != 0 {
-			t.Fatalf("block %q (hash %s, height %d) "+
-				"is too far in the future",
-				item.Name, block.Hash(), blockHeight)
-		}
-
-		if !isOrphan {
-			t.Fatalf("block %q (hash %s, height %d) was accepted, "+
-				"but is not considered an orphan", item.Name,
-				block.Hash(), blockHeight)
-		}
-	}
-
-	// testExpectedTip ensures the current tip of the blockDAG is the
-	// block specified in the provided test instance.
-	testExpectedTip := func(item fullblocktests.ExpectedTip) {
-		blockHeight := item.Height
-		block := util.NewBlock(item.Block)
-		block.SetChainHeight(blockHeight)
-		t.Logf("Testing tip for block %s (hash %s, height %d)",
-			item.Name, block.Hash(), blockHeight)
-
-		// Ensure hash and height match.
-		if dag.SelectedTipHash() != item.Block.BlockHash() ||
-			dag.ChainHeight() != blockHeight { //TODO: (Ori) the use of dag.ChainHeight() and virtualBlock.HighestTipHash() is wrong, and was done only for compilation
-
-			t.Fatalf("block %q (hash %s, height %d) should be "+
-				"the current tip -- got (hash %s, height %d)",
-				item.Name, block.Hash(), blockHeight, dag.SelectedTipHash(),
-				dag.ChainHeight()) //TODO: (Ori) the use of dag.ChainHeight() and virtualBlock.HighestTipHash() is wrong, and was done only for compilation
-		}
-	}
-
-	for testNum, test := range tests {
-		for itemNum, item := range test {
-			switch item := item.(type) {
-			case fullblocktests.AcceptedBlock:
-				testAcceptedBlock(item)
-			case fullblocktests.RejectedBlock:
-				testRejectedBlock(item)
-			case fullblocktests.RejectedNonCanonicalBlock:
-				testRejectedNonCanonicalBlock(item)
-			case fullblocktests.OrphanOrRejectedBlock:
-				testOrphanOrRejectedBlock(item)
-			case fullblocktests.ExpectedTip:
-				testExpectedTip(item)
-			default:
-				t.Fatalf("test #%d, item #%d is not one of "+
-					"the supported test instance types -- "+
-					"got type: %T", testNum, itemNum, item)
-			}
-		}
-	}
-}
--- a/blockdag/fullblocktests/README.md
+++ b/blockdag/fullblocktests/README.md
@@ -1,29 +0,0 @@
-fullblocktests
-==============
-
-[![Build Status](http://img.shields.io/travis/btcsuite/btcd.svg)](https://travis-ci.org/btcsuite/btcd)
-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
-[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/kaspanet/kaspad/blockchain/fullblocktests)
-
-Package fullblocktests provides a set of full block tests to be used for testing
-the consensus validation rules. The tests are intended to be flexible enough to
-allow both unit-style tests directly against the blockchain code as well as
-integration style tests over the peer-to-peer network. To achieve that goal,
-each test contains additional information about the expected result, however
-that information can be ignored when doing comparison tests between two
-independent versions over the peer-to-peer network.
-
-This package has intentionally been designed so it can be used as a standalone
-package for any projects needing to test their implementation against a full set
-of blocks that exercise the consensus validation rules.
-
-## Installation and Updating
-
-```bash
-$ go get -u github.com/kaspanet/kaspad/blockchain/fullblocktests
-```
-
-## License
-
-Package fullblocktests is licensed under the [copyfree](http://copyfree.org) ISC
-License.
--- a/blockdag/fullblocktests/doc.go
+++ b/blockdag/fullblocktests/doc.go
@@ -1,20 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-/*
-Package fullblocktests provides a set of block consensus validation tests.
-
-All of the generated test instances involve full blocks that are to be used for
-testing the consensus validation rules. The tests are intended to be flexible
-enough to allow both unit-style tests directly against the blockchain code as
-well as integration style tests over the peer-to-peer network. To achieve that
-goal, each test contains additional information about the expected result,
-however that information can be ignored when doing comparison tests between two
-independent versions over the peer-to-peer network.
-
-This package has intentionally been designed so it can be used as a standalone
-package for any projects needing to test their implementation against a full set
-of blocks that exercise the consensus validation rules.
-*/
-package fullblocktests
--- a/blockdag/fullblocktests/generate.go
+++ b/blockdag/fullblocktests/generate.go
--- a/blockdag/fullblocktests/params.go
+++ b/blockdag/fullblocktests/params.go
@@ -1,140 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package fullblocktests
-
-import (
-	"encoding/hex"
-	"math"
-	"math/big"
-	"time"
-
-	"github.com/kaspanet/kaspad/util/hdkeychain"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
-
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-// newHashFromStr converts the passed big-endian hex string into a
-// wire.Hash. It only differs from the one available in daghash in that
-// it panics on an error since it will only (and must only) be called with
-// hard-coded, and therefore known good, hashes.
-func newHashFromStr(hexStr string) *daghash.Hash {
-	hash, err := daghash.NewHashFromStr(hexStr)
-	if err != nil {
-		panic(err)
-	}
-	return hash
-}
-
-// newTxIDFromStr converts the passed big-endian hex string into a
-// wire.TxID. It only differs from the one available in daghash in that
-// it panics on an error since it will only (and must only) be called with
-// hard-coded, and therefore known good, hashes.
-func newTxIDFromStr(hexStr string) *daghash.TxID {
-	txID, err := daghash.NewTxIDFromStr(hexStr)
-	if err != nil {
-		panic(err)
-	}
-	return txID
-}
-
-// fromHex converts the passed hex string into a byte slice and will panic if
-// there is an error. This is only provided for the hard-coded constants so
-// errors in the source code can be detected. It will only (and must only) be
-// called for initialization purposes.
-func fromHex(s string) []byte {
-	r, err := hex.DecodeString(s)
-	if err != nil {
-		panic("invalid hex in source file: " + s)
-	}
-	return r
-}
-
-var (
-	// bigOne is 1 represented as a big.Int. It is defined here to avoid
-	// the overhead of creating it multiple times.
-	bigOne = big.NewInt(1)
-
-	// regressionPowLimit is the highest proof of work value a Bitcoin block
-	// can have for the regression test network. It is the value 2^255 - 1.
-	regressionPowLimit = new(big.Int).Sub(new(big.Int).Lsh(bigOne, 255), bigOne)
-
-	// regTestGenesisBlock defines the genesis block of the block chain which serves
-	// as the public transaction ledger for the regression test network.
-	regTestGenesisBlock = wire.MsgBlock{
-		Header: wire.BlockHeader{
-			Version:        1,
-			ParentHashes:   []*daghash.Hash{},
-			HashMerkleRoot: newHashFromStr("4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"),
-			Timestamp:      time.Unix(0x5b28c636, 0), // 2018-06-19 09:00:38 +0000 UTC
-			Bits:           0x207fffff,               // 545259519 [7fffff0000000000000000000000000000000000000000000000000000000000]
-			Nonce:          1,
-		},
-		Transactions: []*wire.MsgTx{{
-			Version: 1,
-			TxIn: []*wire.TxIn{{
-				PreviousOutpoint: wire.Outpoint{
-					TxID:  daghash.TxID{},
-					Index: 0xffffffff,
-				},
-				SignatureScript: fromHex("04ffff001d010445" +
-					"5468652054696d65732030332f4a616e2f" +
-					"32303039204368616e63656c6c6f72206f" +
-					"6e206272696e6b206f66207365636f6e64" +
-					"206261696c6f757420666f72206261686b73"),
-				Sequence: math.MaxUint64,
-			}},
-			TxOut: []*wire.TxOut{{
-				Value: 0,
-				ScriptPubKey: fromHex("4104678afdb0fe5548271967f1" +
-					"a67130b7105cd6a828e03909a67962e0ea1f" +
-					"61deb649f6bc3f4cef38c4f35504e51ec138" +
-					"c4f35504e51ec112de5c384df7ba0b8d578a" +
-					"4c702b6bf11d5fac"),
-			}},
-			LockTime:     0,
-			SubnetworkID: *subnetworkid.SubnetworkIDNative,
-		}},
-	}
-)
-
-// regressionNetParams defines the network parameters for the regression test
-// network.
-//
-// NOTE: The test generator intentionally does not use the existing definitions
-// in the dagconfig package since the intent is to be able to generate known
-// good tests which exercise that code. Using the dagconfig parameters would
-// allow them to change out from under the tests potentially invalidating them.
-var regressionNetParams = &dagconfig.Params{
-	Name:        "regtest",
-	Net:         wire.RegTest,
-	DefaultPort: "18444",
-
-	// DAG parameters
-	GenesisBlock:                   &regTestGenesisBlock,
-	GenesisHash:                    newHashFromStr("5bec7567af40504e0994db3b573c186fffcc4edefe096ff2e58d00523bd7e8a6"),
-	PowMax:                         regressionPowLimit,
-	BlockCoinbaseMaturity:          100,
-	SubsidyReductionInterval:       150,
-	TargetTimePerBlock:             time.Second * 10, // 10 seconds
-	DifficultyAdjustmentWindowSize: 2640,
-	TimestampDeviationTolerance:    132,
-	GenerateSupported:              true,
-
-	// Mempool parameters
-	RelayNonStdTxs: true,
-
-	// Address encoding magics
-	PrivateKeyID: 0xef, // starts with 9 (uncompressed) or c (compressed)
-
-	// BIP32 hierarchical deterministic extended key magics
-	HDKeyIDPair: hdkeychain.HDKeyPairRegressionNet,
-
-	// BIP44 coin type used in the hierarchical deterministic path for
-	// address generation.
-	HDCoinType: 1,
-}
--- a/blockdag/ghostdag.go
+++ b/blockdag/ghostdag.go
@@ -0,0 +1,176 @@
+package blockdag
+
+import (
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/pkg/errors"
+	"sort"
+)
+
+// ghostdag runs the GHOSTDAG protocol and updates newNode.blues,
+// newNode.selectedParent and newNode.bluesAnticoneSizes accordingly.
+// The function updates newNode.blues by iterating over the blocks in
+// the anticone of newNode.selectedParent (which is the parent with the
+// highest blue score) and adds any block to newNode.blues if by adding
+// it to newNode.blues these conditions will not be violated:
+//
+// 1) |anticone-of-candidate-block ∩ blue-set-of-newNode| ≤ K
+//
+// 2) For every blue block in blue-set-of-newNode:
+//    |(anticone-of-blue-block ∩ blue-set-newNode) ∪ {candidate-block}| ≤ K.
+//    We validate this condition by maintaining a map bluesAnticoneSizes for
+//    each block which holds all the blue anticone sizes that were affected by
+//    the new added blue blocks.
+//    So to find out what is |anticone-of-blue ∩ blue-set-of-newNode| we just iterate in
+//    the selected parent chain of newNode until we find an existing entry in
+//    bluesAnticoneSizes.
+//
+// For further details see the article https://eprint.iacr.org/2018/104.pdf
+func (dag *BlockDAG) ghostdag(newNode *blockNode) (selectedParentAnticone []*blockNode, err error) {
+	newNode.selectedParent = newNode.parents.bluest()
+	newNode.bluesAnticoneSizes[newNode.selectedParent] = 0
+	newNode.blues = []*blockNode{newNode.selectedParent}
+	selectedParentAnticone, err = dag.selectedParentAnticone(newNode)
+	if err != nil {
+		return nil, err
+	}
+
+	sort.Slice(selectedParentAnticone, func(i, j int) bool {
+		return selectedParentAnticone[i].less(selectedParentAnticone[j])
+	})
+
+	for _, blueCandidate := range selectedParentAnticone {
+		candidateBluesAnticoneSizes := make(map[*blockNode]dagconfig.KType)
+		var candidateAnticoneSize dagconfig.KType
+		possiblyBlue := true
+
+		// Iterate over all blocks in the blue set of newNode that are not in the past
+		// of blueCandidate, and check for each one of them if blueCandidate potentially
+		// enlarges their blue anticone to be over K, or that they enlarge the blue anticone
+		// of blueCandidate to be over K.
+		for chainBlock := newNode; possiblyBlue; chainBlock = chainBlock.selectedParent {
+			// If blueCandidate is in the future of chainBlock, it means
+			// that all remaining blues are in the past of chainBlock and thus
+			// in the past of blueCandidate. In this case we know for sure that
+			// the anticone of blueCandidate will not exceed K, and we can mark
+			// it as blue.
+			//
+			// newNode is always in the future of blueCandidate, so there's
+			// no point in checking it.
+			if chainBlock != newNode {
+				if isAncestorOfBlueCandidate, err := dag.isAncestorOf(chainBlock, blueCandidate); err != nil {
+					return nil, err
+				} else if isAncestorOfBlueCandidate {
+					break
+				}
+			}
+
+			for _, block := range chainBlock.blues {
+				// Skip blocks that exist in the past of blueCandidate.
+				if isAncestorOfBlueCandidate, err := dag.isAncestorOf(block, blueCandidate); err != nil {
+					return nil, err
+				} else if isAncestorOfBlueCandidate {
+					continue
+				}
+
+				candidateBluesAnticoneSizes[block], err = dag.blueAnticoneSize(block, newNode)
+				if err != nil {
+					return nil, err
+				}
+				candidateAnticoneSize++
+
+				if candidateAnticoneSize > dag.dagParams.K {
+					// k-cluster violation: The candidate's blue anticone exceeded k
+					possiblyBlue = false
+					break
+				}
+
+				if candidateBluesAnticoneSizes[block] == dag.dagParams.K {
+					// k-cluster violation: A block in candidate's blue anticone already
+					// has k blue blocks in its own anticone
+					possiblyBlue = false
+					break
+				}
+
+				// This is a sanity check that validates that a blue
+				// block's blue anticone is not already larger than K.
+				if candidateBluesAnticoneSizes[block] > dag.dagParams.K {
+					return nil, errors.New("found blue anticone size larger than k")
+				}
+			}
+		}
+
+		if possiblyBlue {
+			// No k-cluster violation found, we can now set the candidate block as blue
+			newNode.blues = append(newNode.blues, blueCandidate)
+			newNode.bluesAnticoneSizes[blueCandidate] = candidateAnticoneSize
+			for blue, blueAnticoneSize := range candidateBluesAnticoneSizes {
+				newNode.bluesAnticoneSizes[blue] = blueAnticoneSize + 1
+			}
+
+			// The maximum length of node.blues can be K+1 because
+			// it contains the selected parent.
+			if dagconfig.KType(len(newNode.blues)) == dag.dagParams.K+1 {
+				break
+			}
+		}
+	}
+
+	newNode.blueScore = newNode.selectedParent.blueScore + uint64(len(newNode.blues))
+	return selectedParentAnticone, nil
+}
+
+// selectedParentAnticone returns the blocks in the anticone of the selected parent of the given node.
+// The function work as follows.
+// We start by adding all parents of the node (other than the selected parent) to a process queue.
+// For each node in the queue:
+//   we check whether it is in the past of the selected parent.
+//   If not, we add the node to the resulting anticone-set and queue it for processing.
+func (dag *BlockDAG) selectedParentAnticone(node *blockNode) ([]*blockNode, error) {
+	anticoneSet := newBlockSet()
+	var anticoneSlice []*blockNode
+	selectedParentPast := newBlockSet()
+	var queue []*blockNode
+	// Queueing all parents (other than the selected parent itself) for processing.
+	for parent := range node.parents {
+		if parent == node.selectedParent {
+			continue
+		}
+		anticoneSet.add(parent)
+		anticoneSlice = append(anticoneSlice, parent)
+		queue = append(queue, parent)
+	}
+	for len(queue) > 0 {
+		var current *blockNode
+		current, queue = queue[0], queue[1:]
+		// For each parent of a the current node we check whether it is in the past of the selected parent. If not,
+		// we add the it to the resulting anticone-set and queue it for further processing.
+		for parent := range current.parents {
+			if anticoneSet.contains(parent) || selectedParentPast.contains(parent) {
+				continue
+			}
+			isAncestorOfSelectedParent, err := dag.isAncestorOf(parent, node.selectedParent)
+			if err != nil {
+				return nil, err
+			}
+			if isAncestorOfSelectedParent {
+				selectedParentPast.add(parent)
+				continue
+			}
+			anticoneSet.add(parent)
+			anticoneSlice = append(anticoneSlice, parent)
+			queue = append(queue, parent)
+		}
+	}
+	return anticoneSlice, nil
+}
+
+// blueAnticoneSize returns the blue anticone size of 'block' from the worldview of 'context'.
+// Expects 'block' to be in the blue set of 'context'
+func (dag *BlockDAG) blueAnticoneSize(block, context *blockNode) (dagconfig.KType, error) {
+	for current := context; current != nil; current = current.selectedParent {
+		if blueAnticoneSize, ok := current.bluesAnticoneSizes[block]; ok {
+			return blueAnticoneSize, nil
+		}
+	}
+	return 0, errors.Errorf("block %s is not in blue set of %s", block.hash, context.hash)
+}
--- a/blockdag/ghostdag_test.go
+++ b/blockdag/ghostdag_test.go
@@ -0,0 +1,370 @@
+package blockdag
+
+import (
+	"fmt"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/database"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+type testBlockData struct {
+	parents                []string
+	id                     string // id is a virtual entity that is used only for tests so we can define relations between blocks without knowing their hash
+	expectedScore          uint64
+	expectedSelectedParent string
+	expectedBlues          []string
+}
+
+// TestGHOSTDAG iterates over several dag simulations, and checks
+// that the blue score, blue set and selected parent of each
+// block are calculated as expected.
+func TestGHOSTDAG(t *testing.T) {
+	dagParams := dagconfig.SimnetParams
+
+	tests := []struct {
+		k            dagconfig.KType
+		expectedReds []string
+		dagData      []*testBlockData
+	}{
+		{
+			k:            3,
+			expectedReds: []string{"F", "G", "H", "I", "O", "P"},
+			dagData: []*testBlockData{
+				{
+					parents:                []string{"A"},
+					id:                     "B",
+					expectedScore:          1,
+					expectedSelectedParent: "A",
+					expectedBlues:          []string{"A"},
+				},
+				{
+					parents:                []string{"B"},
+					id:                     "C",
+					expectedScore:          2,
+					expectedSelectedParent: "B",
+					expectedBlues:          []string{"B"},
+				},
+				{
+					parents:                []string{"A"},
+					id:                     "D",
+					expectedScore:          1,
+					expectedSelectedParent: "A",
+					expectedBlues:          []string{"A"},
+				},
+				{
+					parents:                []string{"C", "D"},
+					id:                     "E",
+					expectedScore:          4,
+					expectedSelectedParent: "C",
+					expectedBlues:          []string{"C", "D"},
+				},
+				{
+					parents:                []string{"A"},
+					id:                     "F",
+					expectedScore:          1,
+					expectedSelectedParent: "A",
+					expectedBlues:          []string{"A"},
+				},
+				{
+					parents:                []string{"F"},
+					id:                     "G",
+					expectedScore:          2,
+					expectedSelectedParent: "F",
+					expectedBlues:          []string{"F"},
+				},
+				{
+					parents:                []string{"A"},
+					id:                     "H",
+					expectedScore:          1,
+					expectedSelectedParent: "A",
+					expectedBlues:          []string{"A"},
+				},
+				{
+					parents:                []string{"A"},
+					id:                     "I",
+					expectedScore:          1,
+					expectedSelectedParent: "A",
+					expectedBlues:          []string{"A"},
+				},
+				{
+					parents:                []string{"E", "G"},
+					id:                     "J",
+					expectedScore:          5,
+					expectedSelectedParent: "E",
+					expectedBlues:          []string{"E"},
+				},
+				{
+					parents:                []string{"J"},
+					id:                     "K",
+					expectedScore:          6,
+					expectedSelectedParent: "J",
+					expectedBlues:          []string{"J"},
+				},
+				{
+					parents:                []string{"I", "K"},
+					id:                     "L",
+					expectedScore:          7,
+					expectedSelectedParent: "K",
+					expectedBlues:          []string{"K"},
+				},
+				{
+					parents:                []string{"L"},
+					id:                     "M",
+					expectedScore:          8,
+					expectedSelectedParent: "L",
+					expectedBlues:          []string{"L"},
+				},
+				{
+					parents:                []string{"M"},
+					id:                     "N",
+					expectedScore:          9,
+					expectedSelectedParent: "M",
+					expectedBlues:          []string{"M"},
+				},
+				{
+					parents:                []string{"M"},
+					id:                     "O",
+					expectedScore:          9,
+					expectedSelectedParent: "M",
+					expectedBlues:          []string{"M"},
+				},
+				{
+					parents:                []string{"M"},
+					id:                     "P",
+					expectedScore:          9,
+					expectedSelectedParent: "M",
+					expectedBlues:          []string{"M"},
+				},
+				{
+					parents:                []string{"M"},
+					id:                     "Q",
+					expectedScore:          9,
+					expectedSelectedParent: "M",
+					expectedBlues:          []string{"M"},
+				},
+				{
+					parents:                []string{"M"},
+					id:                     "R",
+					expectedScore:          9,
+					expectedSelectedParent: "M",
+					expectedBlues:          []string{"M"},
+				},
+				{
+					parents:                []string{"R"},
+					id:                     "S",
+					expectedScore:          10,
+					expectedSelectedParent: "R",
+					expectedBlues:          []string{"R"},
+				},
+				{
+					parents:                []string{"N", "O", "P", "Q", "S"},
+					id:                     "T",
+					expectedScore:          13,
+					expectedSelectedParent: "S",
+					expectedBlues:          []string{"S", "N", "Q"},
+				},
+			},
+		},
+	}
+
+	for i, test := range tests {
+		func() {
+			resetExtraNonceForTest()
+			dagParams.K = test.k
+			dag, teardownFunc, err := DAGSetup(fmt.Sprintf("TestGHOSTDAG%d", i), Config{
+				DAGParams: &dagParams,
+			})
+			if err != nil {
+				t.Fatalf("Failed to setup dag instance: %v", err)
+			}
+			defer teardownFunc()
+
+			genesisNode := dag.genesis
+			blockByIDMap := make(map[string]*blockNode)
+			idByBlockMap := make(map[*blockNode]string)
+			blockByIDMap["A"] = genesisNode
+			idByBlockMap[genesisNode] = "A"
+
+			for _, blockData := range test.dagData {
+				parents := blockSet{}
+				for _, parentID := range blockData.parents {
+					parent := blockByIDMap[parentID]
+					parents.add(parent)
+				}
+
+				block, err := PrepareBlockForTest(dag, parents.hashes(), nil)
+				if err != nil {
+					t.Fatalf("TestGHOSTDAG: block %v got unexpected error from PrepareBlockForTest: %v", blockData.id, err)
+				}
+
+				utilBlock := util.NewBlock(block)
+				isOrphan, isDelayed, err := dag.ProcessBlock(utilBlock, BFNoPoWCheck)
+				if err != nil {
+					t.Fatalf("TestGHOSTDAG: dag.ProcessBlock got unexpected error for block %v: %v", blockData.id, err)
+				}
+				if isDelayed {
+					t.Fatalf("TestGHOSTDAG: block %s "+
+						"is too far in the future", blockData.id)
+				}
+				if isOrphan {
+					t.Fatalf("TestGHOSTDAG: block %v was unexpectedly orphan", blockData.id)
+				}
+
+				node := dag.index.LookupNode(utilBlock.Hash())
+
+				blockByIDMap[blockData.id] = node
+				idByBlockMap[node] = blockData.id
+
+				bluesIDs := make([]string, 0, len(node.blues))
+				for _, blue := range node.blues {
+					bluesIDs = append(bluesIDs, idByBlockMap[blue])
+				}
+				selectedParentID := idByBlockMap[node.selectedParent]
+				fullDataStr := fmt.Sprintf("blues: %v, selectedParent: %v, score: %v",
+					bluesIDs, selectedParentID, node.blueScore)
+				if blockData.expectedScore != node.blueScore {
+					t.Errorf("Test %d: Block %v expected to have score %v but got %v (fulldata: %v)",
+						i, blockData.id, blockData.expectedScore, node.blueScore, fullDataStr)
+				}
+				if blockData.expectedSelectedParent != selectedParentID {
+					t.Errorf("Test %d: Block %v expected to have selected parent %v but got %v (fulldata: %v)",
+						i, blockData.id, blockData.expectedSelectedParent, selectedParentID, fullDataStr)
+				}
+				if !reflect.DeepEqual(blockData.expectedBlues, bluesIDs) {
+					t.Errorf("Test %d: Block %v expected to have blues %v but got %v (fulldata: %v)",
+						i, blockData.id, blockData.expectedBlues, bluesIDs, fullDataStr)
+				}
+			}
+
+			reds := make(map[string]bool)
+
+			for id := range blockByIDMap {
+				reds[id] = true
+			}
+
+			for tip := &dag.virtual.blockNode; tip.selectedParent != nil; tip = tip.selectedParent {
+				tipID := idByBlockMap[tip]
+				delete(reds, tipID)
+				for _, blue := range tip.blues {
+					blueID := idByBlockMap[blue]
+					delete(reds, blueID)
+				}
+			}
+			if !checkReds(test.expectedReds, reds) {
+				redsIDs := make([]string, 0, len(reds))
+				for id := range reds {
+					redsIDs = append(redsIDs, id)
+				}
+				sort.Strings(redsIDs)
+				sort.Strings(test.expectedReds)
+				t.Errorf("Test %d: Expected reds %v but got %v", i, test.expectedReds, redsIDs)
+			}
+		}()
+	}
+}
+
+func checkReds(expectedReds []string, reds map[string]bool) bool {
+	if len(expectedReds) != len(reds) {
+		return false
+	}
+	for _, redID := range expectedReds {
+		if !reds[redID] {
+			return false
+		}
+	}
+	return true
+}
+
+func TestBlueAnticoneSizeErrors(t *testing.T) {
+	// Create a new database and DAG instance to run tests against.
+	dag, teardownFunc, err := DAGSetup("TestBlueAnticoneSizeErrors", Config{
+		DAGParams: &dagconfig.SimnetParams,
+	})
+	if err != nil {
+		t.Fatalf("TestBlueAnticoneSizeErrors: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()
+
+	// Prepare a block chain with size K beginning with the genesis block
+	currentBlockA := dag.dagParams.GenesisBlock
+	for i := dagconfig.KType(0); i < dag.dagParams.K; i++ {
+		newBlock := prepareAndProcessBlock(t, dag, currentBlockA)
+		currentBlockA = newBlock
+	}
+
+	// Prepare another block chain with size K beginning with the genesis block
+	currentBlockB := dag.dagParams.GenesisBlock
+	for i := dagconfig.KType(0); i < dag.dagParams.K; i++ {
+		newBlock := prepareAndProcessBlock(t, dag, currentBlockB)
+		currentBlockB = newBlock
+	}
+
+	// Get references to the tips of the two chains
+	blockNodeA := dag.index.LookupNode(currentBlockA.BlockHash())
+	blockNodeB := dag.index.LookupNode(currentBlockB.BlockHash())
+
+	// Try getting the blueAnticoneSize between them. Since the two
+	// blocks are not in the anticones of eachother, this should fail.
+	_, err = dag.blueAnticoneSize(blockNodeA, blockNodeB)
+	if err == nil {
+		t.Fatalf("TestBlueAnticoneSizeErrors: blueAnticoneSize unexpectedly succeeded")
+	}
+	expectedErrSubstring := "is not in blue set of"
+	if !strings.Contains(err.Error(), expectedErrSubstring) {
+		t.Fatalf("TestBlueAnticoneSizeErrors: blueAnticoneSize returned wrong error. "+
+			"Want: %s, got: %s", expectedErrSubstring, err)
+	}
+}
+
+func TestGHOSTDAGErrors(t *testing.T) {
+	// Create a new database and DAG instance to run tests against.
+	dag, teardownFunc, err := DAGSetup("TestGHOSTDAGErrors", Config{
+		DAGParams: &dagconfig.SimnetParams,
+	})
+	if err != nil {
+		t.Fatalf("TestGHOSTDAGErrors: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()
+
+	// Add two child blocks to the genesis
+	block1 := prepareAndProcessBlock(t, dag, dag.dagParams.GenesisBlock)
+	block2 := prepareAndProcessBlock(t, dag, dag.dagParams.GenesisBlock)
+
+	// Add a child block to the previous two blocks
+	block3 := prepareAndProcessBlock(t, dag, block1, block2)
+
+	// Clear the reachability store
+	dag.reachabilityStore.loaded = map[daghash.Hash]*reachabilityData{}
+	err = dag.db.Update(func(dbTx database.Tx) error {
+		bucket := dbTx.Metadata().Bucket(reachabilityDataBucketName)
+		cursor := bucket.Cursor()
+		for ok := cursor.First(); ok; ok = cursor.Next() {
+			err := bucket.Delete(cursor.Key())
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("TestGHOSTDAGErrors: db.Update failed: %s", err)
+	}
+
+	// Try to rerun GHOSTDAG on the last block. GHOSTDAG uses
+	// reachability data, so we expect it to fail.
+	blockNode3 := dag.index.LookupNode(block3.BlockHash())
+	_, err = dag.ghostdag(blockNode3)
+	if err == nil {
+		t.Fatalf("TestGHOSTDAGErrors: ghostdag unexpectedly succeeded")
+	}
+	expectedErrSubstring := "Couldn't find reachability data"
+	if !strings.Contains(err.Error(), expectedErrSubstring) {
+		t.Fatalf("TestGHOSTDAGErrors: ghostdag returned wrong error. "+
+			"Want: %s, got: %s", expectedErrSubstring, err)
+	}
+}
--- a/blockdag/indexers/README.md
+++ b/blockdag/indexers/README.md
@@ -1,7 +1,7 @@
 indexers
 ========

-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](https://choosealicense.com/licenses/isc/)
 [![GoDoc](https://godoc.org/github.com/kaspanet/kaspad/blockdag/indexers?status.png)](http://godoc.org/github.com/kaspanet/kaspad/blockdag/indexers)

 Package indexers implements optional block chain indexes.
--- a/blockdag/indexers/acceptanceindex_test.go
+++ b/blockdag/indexers/acceptanceindex_test.go
@@ -71,7 +71,7 @@ func TestAcceptanceIndexSerializationAndDeserialization(t *testing.T) {
 //   comparing dag1's last block acceptance data and dag3's last block acceptance
 //   data.
 func TestAcceptanceIndexRecover(t *testing.T) {
-	params := &dagconfig.SimNetParams
+	params := &dagconfig.SimnetParams
 	params.BlockCoinbaseMaturity = 0

 	testFiles := []string{
@@ -116,11 +116,11 @@ func TestAcceptanceIndexRecover(t *testing.T) {
 	}

 	for i := 1; i < len(blocks)-2; i++ {
-		isOrphan, delay, err := db1DAG.ProcessBlock(blocks[i], blockdag.BFNone)
+		isOrphan, isDelayed, err := db1DAG.ProcessBlock(blocks[i], blockdag.BFNone)
 		if err != nil {
 			t.Fatalf("ProcessBlock fail on block %v: %v\n", i, err)
 		}
-		if delay != 0 {
+		if isDelayed {
 			t.Fatalf("ProcessBlock: block %d "+
 				"is too far in the future", i)
 		}
@@ -147,11 +147,11 @@ func TestAcceptanceIndexRecover(t *testing.T) {
 	}

 	for i := len(blocks) - 2; i < len(blocks); i++ {
-		isOrphan, delay, err := db1DAG.ProcessBlock(blocks[i], blockdag.BFNone)
+		isOrphan, isDelayed, err := db1DAG.ProcessBlock(blocks[i], blockdag.BFNone)
 		if err != nil {
 			t.Fatalf("ProcessBlock fail on block %v: %v\n", i, err)
 		}
-		if delay != 0 {
+		if isDelayed {
 			t.Fatalf("ProcessBlock: block %d "+
 				"is too far in the future", i)
 		}
@@ -185,11 +185,11 @@ func TestAcceptanceIndexRecover(t *testing.T) {
 	}

 	for i := len(blocks) - 2; i < len(blocks); i++ {
-		isOrphan, delay, err := db2DAG.ProcessBlock(blocks[i], blockdag.BFNone)
+		isOrphan, isDelayed, err := db2DAG.ProcessBlock(blocks[i], blockdag.BFNone)
 		if err != nil {
 			t.Fatalf("ProcessBlock fail on block %v: %v\n", i, err)
 		}
-		if delay != 0 {
+		if isDelayed {
 			t.Fatalf("ProcessBlock: block %d "+
 				"is too far in the future", i)
 		}
@@ -298,16 +298,16 @@ func copyDirectory(scrDir, dest string) error {
 // This function is copied and modified from this stackoverflow answer: https://stackoverflow.com/a/56314145/2413761
 func copyFile(srcFile, dstFile string) error {
 	out, err := os.Create(dstFile)
-	defer out.Close()
 	if err != nil {
 		return err
 	}
+	defer out.Close()

 	in, err := os.Open(srcFile)
-	defer in.Close()
 	if err != nil {
 		return err
 	}
+	defer in.Close()

 	_, err = io.Copy(out, in)
 	if err != nil {
--- a/blockdag/indexers/addrindex.go
+++ b/blockdag/indexers/addrindex.go
@@ -1,902 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package indexers
-
-import (
-	"fmt"
-	"github.com/pkg/errors"
-	"sync"
-
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/txscript"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-const (
-	// addrIndexName is the human-readable name for the index.
-	addrIndexName = "address index"
-
-	// level0MaxEntries is the maximum number of transactions that are
-	// stored in level 0 of an address index entry. Subsequent levels store
-	// 2^n * level0MaxEntries entries, or in words, double the maximum of
-	// the previous level.
-	level0MaxEntries = 8
-
-	// addrKeySize is the number of bytes an address key consumes in the
-	// index. It consists of 1 byte address type + 20 bytes hash160.
-	addrKeySize = 1 + 20
-
-	// levelKeySize is the number of bytes a level key in the address index
-	// consumes. It consists of the address key + 1 byte for the level.
-	levelKeySize = addrKeySize + 1
-
-	// levelOffset is the offset in the level key which identifes the level.
-	levelOffset = levelKeySize - 1
-
-	// addrKeyTypePubKeyHash is the address type in an address key which
-	// represents both a pay-to-pubkey-hash and a pay-to-pubkey address.
-	// This is done because both are identical for the purposes of the
-	// address index.
-	addrKeyTypePubKeyHash = 0
-
-	// addrKeyTypeScriptHash is the address type in an address key which
-	// represents a pay-to-script-hash address. This is necessary because
-	// the hash of a pubkey address might be the same as that of a script
-	// hash.
-	addrKeyTypeScriptHash = 1
-
-	// Size of a transaction entry. It consists of 8 bytes block id + 4
-	// bytes offset + 4 bytes length.
-	txEntrySize = 8 + 4 + 4
-)
-
-var (
-	// addrIndexKey is the key of the address index and the db bucket used
-	// to house it.
-	addrIndexKey = []byte("txbyaddridx")
-
-	// errUnsupportedAddressType is an error that is used to signal an
-	// unsupported address type has been used.
-	errUnsupportedAddressType = errors.New("address type is not supported " +
-		"by the address index")
-)
-
-// -----------------------------------------------------------------------------
-// The address index maps addresses referenced in the blockDAG to a list of
-// all the transactions involving that address. Transactions are stored
-// according to their order of appearance in the blockDAG. That is to say
-// first by block height and then by offset inside the block. It is also
-// important to note that this implementation requires the transaction index
-// since it is needed in order to catch up old blocks due to the fact the spent
-// outputs will already be pruned from the utxo set.
-//
-// The approach used to store the index is similar to a log-structured merge
-// tree (LSM tree) and is thus similar to how leveldb works internally.
-//
-// Every address consists of one or more entries identified by a level starting
-// from 0 where each level holds a maximum number of entries such that each
-// subsequent level holds double the maximum of the previous one. In equation
-// form, the number of entries each level holds is 2^n * firstLevelMaxSize.
-//
-// New transactions are appended to level 0 until it becomes full at which point
-// the entire level 0 entry is appended to the level 1 entry and level 0 is
-// cleared. This process continues until level 1 becomes full at which point it
-// will be appended to level 2 and cleared and so on.
-//
-// The result of this is the lower levels contain newer transactions and the
-// transactions within each level are ordered from oldest to newest.
-//
-// The intent of this approach is to provide a balance between space efficiency
-// and indexing cost. Storing one entry per transaction would have the lowest
-// indexing cost, but would waste a lot of space because the same address hash
-// would be duplicated for every transaction key. On the other hand, storing a
-// single entry with all transactions would be the most space efficient, but
-// would cause indexing cost to grow quadratically with the number of
-// transactions involving the same address. The approach used here provides
-// logarithmic insertion and retrieval.
-//
-// The serialized key format is:
-//
-//   <addr type><addr hash><level>
-//
-//   Field           Type      Size
-//   addr type       uint8     1 byte
-//   addr hash       hash160   20 bytes
-//   level           uint8     1 byte
-//   -----
-//   Total: 22 bytes
-//
-// The serialized value format is:
-//
-//   [<block id><start offset><tx length>,...]
-//
-//   Field           Type      Size
-//   block id        uint64    8 bytes
-//   start offset    uint32    4 bytes
-//   tx length       uint32    4 bytes
-//   -----
-//   Total: 16 bytes per indexed tx
-// -----------------------------------------------------------------------------
-
-// fetchBlockHashFunc defines a callback function to use in order to convert a
-// serialized block ID to an associated block hash.
-type fetchBlockHashFunc func(serializedID []byte) (*daghash.Hash, error)
-
-// serializeAddrIndexEntry serializes the provided block id and transaction
-// location according to the format described in detail above.
-func serializeAddrIndexEntry(blockID uint64, txLoc wire.TxLoc) []byte {
-	// Serialize the entry.
-	serialized := make([]byte, 16)
-	byteOrder.PutUint64(serialized, blockID)
-	byteOrder.PutUint32(serialized[8:], uint32(txLoc.TxStart))
-	byteOrder.PutUint32(serialized[12:], uint32(txLoc.TxLen))
-	return serialized
-}
-
-// deserializeAddrIndexEntry decodes the passed serialized byte slice into the
-// provided region struct according to the format described in detail above and
-// uses the passed block hash fetching function in order to conver the block ID
-// to the associated block hash.
-func deserializeAddrIndexEntry(serialized []byte, region *database.BlockRegion, fetchBlockHash fetchBlockHashFunc) error {
-	// Ensure there are enough bytes to decode.
-	if len(serialized) < txEntrySize {
-		return errDeserialize("unexpected end of data")
-	}
-
-	hash, err := fetchBlockHash(serialized[0:8])
-	if err != nil {
-		return err
-	}
-	region.Hash = hash
-	region.Offset = byteOrder.Uint32(serialized[8:12])
-	region.Len = byteOrder.Uint32(serialized[12:16])
-	return nil
-}
-
-// keyForLevel returns the key for a specific address and level in the address
-// index entry.
-func keyForLevel(addrKey [addrKeySize]byte, level uint8) [levelKeySize]byte {
-	var key [levelKeySize]byte
-	copy(key[:], addrKey[:])
-	key[levelOffset] = level
-	return key
-}
-
-// dbPutAddrIndexEntry updates the address index to include the provided entry
-// according to the level-based scheme described in detail above.
-func dbPutAddrIndexEntry(bucket internalBucket, addrKey [addrKeySize]byte, blockID uint64, txLoc wire.TxLoc) error {
-	// Start with level 0 and its initial max number of entries.
-	curLevel := uint8(0)
-	maxLevelBytes := level0MaxEntries * txEntrySize
-
-	// Simply append the new entry to level 0 and return now when it will
-	// fit. This is the most common path.
-	newData := serializeAddrIndexEntry(blockID, txLoc)
-	level0Key := keyForLevel(addrKey, 0)
-	level0Data := bucket.Get(level0Key[:])
-	if len(level0Data)+len(newData) <= maxLevelBytes {
-		mergedData := newData
-		if len(level0Data) > 0 {
-			mergedData = make([]byte, len(level0Data)+len(newData))
-			copy(mergedData, level0Data)
-			copy(mergedData[len(level0Data):], newData)
-		}
-		return bucket.Put(level0Key[:], mergedData)
-	}
-
-	// At this point, level 0 is full, so merge each level into higher
-	// levels as many times as needed to free up level 0.
-	prevLevelData := level0Data
-	for {
-		// Each new level holds twice as much as the previous one.
-		curLevel++
-		maxLevelBytes *= 2
-
-		// Move to the next level as long as the current level is full.
-		curLevelKey := keyForLevel(addrKey, curLevel)
-		curLevelData := bucket.Get(curLevelKey[:])
-		if len(curLevelData) == maxLevelBytes {
-			prevLevelData = curLevelData
-			continue
-		}
-
-		// The current level has room for the data in the previous one,
-		// so merge the data from previous level into it.
-		mergedData := prevLevelData
-		if len(curLevelData) > 0 {
-			mergedData = make([]byte, len(curLevelData)+
-				len(prevLevelData))
-			copy(mergedData, curLevelData)
-			copy(mergedData[len(curLevelData):], prevLevelData)
-		}
-		err := bucket.Put(curLevelKey[:], mergedData)
-		if err != nil {
-			return err
-		}
-
-		// Move all of the levels before the previous one up a level.
-		for mergeLevel := curLevel - 1; mergeLevel > 0; mergeLevel-- {
-			mergeLevelKey := keyForLevel(addrKey, mergeLevel)
-			prevLevelKey := keyForLevel(addrKey, mergeLevel-1)
-			prevData := bucket.Get(prevLevelKey[:])
-			err := bucket.Put(mergeLevelKey[:], prevData)
-			if err != nil {
-				return err
-			}
-		}
-		break
-	}
-
-	// Finally, insert the new entry into level 0 now that it is empty.
-	return bucket.Put(level0Key[:], newData)
-}
-
-// dbFetchAddrIndexEntries returns block regions for transactions referenced by
-// the given address key and the number of entries skipped since it could have
-// been less in the case where there are less total entries than the requested
-// number of entries to skip.
-func dbFetchAddrIndexEntries(bucket internalBucket, addrKey [addrKeySize]byte, numToSkip, numRequested uint32, reverse bool, fetchBlockHash fetchBlockHashFunc) ([]database.BlockRegion, uint32, error) {
-	// When the reverse flag is not set, all levels need to be fetched
-	// because numToSkip and numRequested are counted from the oldest
-	// transactions (highest level) and thus the total count is needed.
-	// However, when the reverse flag is set, only enough records to satisfy
-	// the requested amount are needed.
-	var level uint8
-	var serialized []byte
-	for !reverse || len(serialized) < int(numToSkip+numRequested)*txEntrySize {
-		curLevelKey := keyForLevel(addrKey, level)
-		levelData := bucket.Get(curLevelKey[:])
-		if levelData == nil {
-			// Stop when there are no more levels.
-			break
-		}
-
-		// Higher levels contain older transactions, so prepend them.
-		prepended := make([]byte, len(serialized)+len(levelData))
-		copy(prepended, levelData)
-		copy(prepended[len(levelData):], serialized)
-		serialized = prepended
-		level++
-	}
-
-	// When the requested number of entries to skip is larger than the
-	// number available, skip them all and return now with the actual number
-	// skipped.
-	numEntries := uint32(len(serialized) / txEntrySize)
-	if numToSkip >= numEntries {
-		return nil, numEntries, nil
-	}
-
-	// Nothing more to do when there are no requested entries.
-	if numRequested == 0 {
-		return nil, numToSkip, nil
-	}
-
-	// Limit the number to load based on the number of available entries,
-	// the number to skip, and the number requested.
-	numToLoad := numEntries - numToSkip
-	if numToLoad > numRequested {
-		numToLoad = numRequested
-	}
-
-	// Start the offset after all skipped entries and load the calculated
-	// number.
-	results := make([]database.BlockRegion, numToLoad)
-	for i := uint32(0); i < numToLoad; i++ {
-		// Calculate the read offset according to the reverse flag.
-		var offset uint32
-		if reverse {
-			offset = (numEntries - numToSkip - i - 1) * txEntrySize
-		} else {
-			offset = (numToSkip + i) * txEntrySize
-		}
-
-		// Deserialize and populate the result.
-		err := deserializeAddrIndexEntry(serialized[offset:],
-			&results[i], fetchBlockHash)
-		if err != nil {
-			// Ensure any deserialization errors are returned as
-			// database corruption errors.
-			if isDeserializeErr(err) {
-				err = database.Error{
-					ErrorCode: database.ErrCorruption,
-					Description: fmt.Sprintf("failed to "+
-						"deserialized address index "+
-						"for key %x: %s", addrKey, err),
-				}
-			}
-
-			return nil, 0, err
-		}
-	}
-
-	return results, numToSkip, nil
-}
-
-// minEntriesToReachLevel returns the minimum number of entries that are
-// required to reach the given address index level.
-func minEntriesToReachLevel(level uint8) int {
-	maxEntriesForLevel := level0MaxEntries
-	minRequired := 1
-	for l := uint8(1); l <= level; l++ {
-		minRequired += maxEntriesForLevel
-		maxEntriesForLevel *= 2
-	}
-	return minRequired
-}
-
-// maxEntriesForLevel returns the maximum number of entries allowed for the
-// given address index level.
-func maxEntriesForLevel(level uint8) int {
-	numEntries := level0MaxEntries
-	for l := level; l > 0; l-- {
-		numEntries *= 2
-	}
-	return numEntries
-}
-
-// dbRemoveAddrIndexEntries removes the specified number of entries from from
-// the address index for the provided key. An assertion error will be returned
-// if the count exceeds the total number of entries in the index.
-func dbRemoveAddrIndexEntries(bucket internalBucket, addrKey [addrKeySize]byte, count int) error {
-	// Nothing to do if no entries are being deleted.
-	if count <= 0 {
-		return nil
-	}
-
-	// Make use of a local map to track pending updates and define a closure
-	// to apply it to the database. This is done in order to reduce the
-	// number of database reads and because there is more than one exit
-	// path that needs to apply the updates.
-	pendingUpdates := make(map[uint8][]byte)
-	applyPending := func() error {
-		for level, data := range pendingUpdates {
-			curLevelKey := keyForLevel(addrKey, level)
-			if len(data) == 0 {
-				err := bucket.Delete(curLevelKey[:])
-				if err != nil {
-					return err
-				}
-				continue
-			}
-			err := bucket.Put(curLevelKey[:], data)
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	}
-
-	// Loop forwards through the levels while removing entries until the
-	// specified number has been removed. This will potentially result in
-	// entirely empty lower levels which will be backfilled below.
-	var highestLoadedLevel uint8
-	numRemaining := count
-	for level := uint8(0); numRemaining > 0; level++ {
-		// Load the data for the level from the database.
-		curLevelKey := keyForLevel(addrKey, level)
-		curLevelData := bucket.Get(curLevelKey[:])
-		if len(curLevelData) == 0 && numRemaining > 0 {
-			return AssertError(fmt.Sprintf("dbRemoveAddrIndexEntries "+
-				"not enough entries for address key %x to "+
-				"delete %d entries", addrKey, count))
-		}
-		pendingUpdates[level] = curLevelData
-		highestLoadedLevel = level
-
-		// Delete the entire level as needed.
-		numEntries := len(curLevelData) / txEntrySize
-		if numRemaining >= numEntries {
-			pendingUpdates[level] = nil
-			numRemaining -= numEntries
-			continue
-		}
-
-		// Remove remaining entries to delete from the level.
-		offsetEnd := len(curLevelData) - (numRemaining * txEntrySize)
-		pendingUpdates[level] = curLevelData[:offsetEnd]
-		break
-	}
-
-	// When all elements in level 0 were not removed there is nothing left
-	// to do other than updating the database.
-	if len(pendingUpdates[0]) != 0 {
-		return applyPending()
-	}
-
-	// At this point there are one or more empty levels before the current
-	// level which need to be backfilled and the current level might have
-	// had some entries deleted from it as well. Since all levels after
-	// level 0 are required to either be empty, half full, or completely
-	// full, the current level must be adjusted accordingly by backfilling
-	// each previous levels in a way which satisfies the requirements. Any
-	// entries that are left are assigned to level 0 after the loop as they
-	// are guaranteed to fit by the logic in the loop. In other words, this
-	// effectively squashes all remaining entries in the current level into
-	// the lowest possible levels while following the level rules.
-	//
-	// Note that the level after the current level might also have entries
-	// and gaps are not allowed, so this also keeps track of the lowest
-	// empty level so the code below knows how far to backfill in case it is
-	// required.
-	lowestEmptyLevel := uint8(255)
-	curLevelData := pendingUpdates[highestLoadedLevel]
-	curLevelMaxEntries := maxEntriesForLevel(highestLoadedLevel)
-	for level := highestLoadedLevel; level > 0; level-- {
-		// When there are not enough entries left in the current level
-		// for the number that would be required to reach it, clear the
-		// the current level which effectively moves them all up to the
-		// previous level on the next iteration. Otherwise, there are
-		// are sufficient entries, so update the current level to
-		// contain as many entries as possible while still leaving
-		// enough remaining entries required to reach the level.
-		numEntries := len(curLevelData) / txEntrySize
-		prevLevelMaxEntries := curLevelMaxEntries / 2
-		minPrevRequired := minEntriesToReachLevel(level - 1)
-		if numEntries < prevLevelMaxEntries+minPrevRequired {
-			lowestEmptyLevel = level
-			pendingUpdates[level] = nil
-		} else {
-			// This level can only be completely full or half full,
-			// so choose the appropriate offset to ensure enough
-			// entries remain to reach the level.
-			var offset int
-			if numEntries-curLevelMaxEntries >= minPrevRequired {
-				offset = curLevelMaxEntries * txEntrySize
-			} else {
-				offset = prevLevelMaxEntries * txEntrySize
-			}
-			pendingUpdates[level] = curLevelData[:offset]
-			curLevelData = curLevelData[offset:]
-		}
-
-		curLevelMaxEntries = prevLevelMaxEntries
-	}
-	pendingUpdates[0] = curLevelData
-	if len(curLevelData) == 0 {
-		lowestEmptyLevel = 0
-	}
-
-	// When the highest loaded level is empty, it's possible the level after
-	// it still has data and thus that data needs to be backfilled as well.
-	for len(pendingUpdates[highestLoadedLevel]) == 0 {
-		// When the next level is empty too, the is no data left to
-		// continue backfilling, so there is nothing left to do.
-		// Otherwise, populate the pending updates map with the newly
-		// loaded data and update the highest loaded level accordingly.
-		level := highestLoadedLevel + 1
-		curLevelKey := keyForLevel(addrKey, level)
-		levelData := bucket.Get(curLevelKey[:])
-		if len(levelData) == 0 {
-			break
-		}
-		pendingUpdates[level] = levelData
-		highestLoadedLevel = level
-
-		// At this point the highest level is not empty, but it might
-		// be half full. When that is the case, move it up a level to
-		// simplify the code below which backfills all lower levels that
-		// are still empty. This also means the current level will be
-		// empty, so the loop will perform another another iteration to
-		// potentially backfill this level with data from the next one.
-		curLevelMaxEntries := maxEntriesForLevel(level)
-		if len(levelData)/txEntrySize != curLevelMaxEntries {
-			pendingUpdates[level] = nil
-			pendingUpdates[level-1] = levelData
-			level--
-			curLevelMaxEntries /= 2
-		}
-
-		// Backfill all lower levels that are still empty by iteratively
-		// halfing the data until the lowest empty level is filled.
-		for level > lowestEmptyLevel {
-			offset := (curLevelMaxEntries / 2) * txEntrySize
-			pendingUpdates[level] = levelData[:offset]
-			levelData = levelData[offset:]
-			pendingUpdates[level-1] = levelData
-			level--
-			curLevelMaxEntries /= 2
-		}
-
-		// The lowest possible empty level is now the highest loaded
-		// level.
-		lowestEmptyLevel = highestLoadedLevel
-	}
-
-	// Apply the pending updates.
-	return applyPending()
-}
-
-// addrToKey converts known address types to an addrindex key. An error is
-// returned for unsupported types.
-func addrToKey(addr util.Address) ([addrKeySize]byte, error) {
-	switch addr := addr.(type) {
-	case *util.AddressPubKeyHash:
-		var result [addrKeySize]byte
-		result[0] = addrKeyTypePubKeyHash
-		copy(result[1:], addr.Hash160()[:])
-		return result, nil
-
-	case *util.AddressScriptHash:
-		var result [addrKeySize]byte
-		result[0] = addrKeyTypeScriptHash
-		copy(result[1:], addr.Hash160()[:])
-		return result, nil
-	}
-
-	return [addrKeySize]byte{}, errUnsupportedAddressType
-}
-
-// AddrIndex implements a transaction by address index. That is to say, it
-// supports querying all transactions that reference a given address because
-// they are either crediting or debiting the address. The returned transactions
-// are ordered according to their order of appearance in the blockDAG. In
-// other words, first by block height and then by offset inside the block.
-//
-// In addition, support is provided for a memory-only index of unconfirmed
-// transactions such as those which are kept in the memory pool before inclusion
-// in a block.
-type AddrIndex struct {
-	// The following fields are set when the instance is created and can't
-	// be changed afterwards, so there is no need to protect them with a
-	// separate mutex.
-	db        database.DB
-	dagParams *dagconfig.Params
-
-	// The following fields are used to quickly link transactions and
-	// addresses that have not been included into a block yet when an
-	// address index is being maintained. The are protected by the
-	// unconfirmedLock field.
-	//
-	// The txnsByAddr field is used to keep an index of all transactions
-	// which either create an output to a given address or spend from a
-	// previous output to it keyed by the address.
-	//
-	// The addrsByTx field is essentially the reverse and is used to
-	// keep an index of all addresses which a given transaction involves.
-	// This allows fairly efficient updates when transactions are removed
-	// once they are included into a block.
-	unconfirmedLock sync.RWMutex
-	txnsByAddr      map[[addrKeySize]byte]map[daghash.TxID]*util.Tx
-	addrsByTx       map[daghash.TxID]map[[addrKeySize]byte]struct{}
-}
-
-// Ensure the AddrIndex type implements the Indexer interface.
-var _ Indexer = (*AddrIndex)(nil)
-
-// Ensure the AddrIndex type implements the NeedsInputser interface.
-var _ NeedsInputser = (*AddrIndex)(nil)
-
-// NeedsInputs signals that the index requires the referenced inputs in order
-// to properly create the index.
-//
-// This implements the NeedsInputser interface.
-func (idx *AddrIndex) NeedsInputs() bool {
-	return true
-}
-
-// Init is only provided to satisfy the Indexer interface as there is nothing to
-// initialize for this index.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) Init(db database.DB, _ *blockdag.BlockDAG) error {
-	idx.db = db
-	return nil
-}
-
-// Key returns the database key to use for the index as a byte slice.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) Key() []byte {
-	return addrIndexKey
-}
-
-// Name returns the human-readable name of the index.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) Name() string {
-	return addrIndexName
-}
-
-// Create is invoked when the indexer manager determines the index needs
-// to be created for the first time. It creates the bucket for the address
-// index.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) Create(dbTx database.Tx) error {
-	_, err := dbTx.Metadata().CreateBucket(addrIndexKey)
-	return err
-}
-
-// writeIndexData represents the address index data to be written for one block.
-// It consists of the address mapped to an ordered list of the transactions
-// that involve the address in block. It is ordered so the transactions can be
-// stored in the order they appear in the block.
-type writeIndexData map[[addrKeySize]byte][]int
-
-// indexScriptPubKey extracts all standard addresses from the passed public key
-// script and maps each of them to the associated transaction using the passed
-// map.
-func (idx *AddrIndex) indexScriptPubKey(data writeIndexData, scriptPubKey []byte, txIdx int) {
-	// Nothing to index if the script is non-standard or otherwise doesn't
-	// contain any addresses.
-	_, addr, err := txscript.ExtractScriptPubKeyAddress(scriptPubKey,
-		idx.dagParams)
-	if err != nil || addr == nil {
-		return
-	}
-
-	addrKey, err := addrToKey(addr)
-	if err != nil {
-		// Ignore unsupported address types.
-		return
-	}
-
-	// Avoid inserting the transaction more than once. Since the
-	// transactions are indexed serially any duplicates will be
-	// indexed in a row, so checking the most recent entry for the
-	// address is enough to detect duplicates.
-	indexedTxns := data[addrKey]
-	numTxns := len(indexedTxns)
-	if numTxns > 0 && indexedTxns[numTxns-1] == txIdx {
-		return
-	}
-	indexedTxns = append(indexedTxns, txIdx)
-	data[addrKey] = indexedTxns
-}
-
-// indexBlock extract all of the standard addresses from all of the transactions
-// in the passed block and maps each of them to the associated transaction using
-// the passed map.
-func (idx *AddrIndex) indexBlock(data writeIndexData, block *util.Block, dag *blockdag.BlockDAG) {
-	for txIdx, tx := range block.Transactions() {
-		// Coinbases do not reference any inputs. Since the block is
-		// required to have already gone through full validation, it has
-		// already been proven on the first transaction in the block is
-		// a coinbase.
-		if txIdx > util.CoinbaseTransactionIndex {
-			for _, txIn := range tx.MsgTx().TxIn {
-				// The UTXO should always have the input since
-				// the index contract requires it, however, be
-				// safe and simply ignore any missing entries.
-				entry, ok := dag.GetUTXOEntry(txIn.PreviousOutpoint)
-				if !ok {
-					continue
-				}
-
-				idx.indexScriptPubKey(data, entry.ScriptPubKey(), txIdx)
-			}
-		}
-
-		for _, txOut := range tx.MsgTx().TxOut {
-			idx.indexScriptPubKey(data, txOut.ScriptPubKey, txIdx)
-		}
-	}
-}
-
-// ConnectBlock is invoked by the index manager when a new block has been
-// connected to the DAG. This indexer adds a mapping for each address
-// the transactions in the block involve.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) ConnectBlock(dbTx database.Tx, block *util.Block, blockID uint64, dag *blockdag.BlockDAG,
-	_ blockdag.MultiBlockTxsAcceptanceData, _ blockdag.MultiBlockTxsAcceptanceData) error {
-
-	// The offset and length of the transactions within the serialized
-	// block.
-	txLocs, err := block.TxLoc()
-	if err != nil {
-		return err
-	}
-
-	// Build all of the address to transaction mappings in a local map.
-	addrsToTxns := make(writeIndexData)
-	idx.indexBlock(addrsToTxns, block, dag)
-
-	// Add all of the index entries for each address.
-	addrIdxBucket := dbTx.Metadata().Bucket(addrIndexKey)
-	for addrKey, txIdxs := range addrsToTxns {
-		for _, txIdx := range txIdxs {
-			err := dbPutAddrIndexEntry(addrIdxBucket, addrKey,
-				blockID, txLocs[txIdx])
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-// TxRegionsForAddress returns a slice of block regions which identify each
-// transaction that involves the passed address according to the specified
-// number to skip, number requested, and whether or not the results should be
-// reversed. It also returns the number actually skipped since it could be less
-// in the case where there are not enough entries.
-//
-// NOTE: These results only include transactions confirmed in blocks. See the
-// UnconfirmedTxnsForAddress method for obtaining unconfirmed transactions
-// that involve a given address.
-//
-// This function is safe for concurrent access.
-func (idx *AddrIndex) TxRegionsForAddress(dbTx database.Tx, addr util.Address, numToSkip, numRequested uint32, reverse bool) ([]database.BlockRegion, uint32, error) {
-	addrKey, err := addrToKey(addr)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	var regions []database.BlockRegion
-	var skipped uint32
-	err = idx.db.View(func(dbTx database.Tx) error {
-		// Create closure to lookup the block hash given the ID using
-		// the database transaction.
-		fetchBlockHash := func(id []byte) (*daghash.Hash, error) {
-			// Deserialize and populate the result.
-			return blockdag.DBFetchBlockHashBySerializedID(dbTx, id)
-		}
-
-		var err error
-		addrIdxBucket := dbTx.Metadata().Bucket(addrIndexKey)
-		regions, skipped, err = dbFetchAddrIndexEntries(addrIdxBucket,
-			addrKey, numToSkip, numRequested, reverse,
-			fetchBlockHash)
-		return err
-	})
-
-	return regions, skipped, err
-}
-
-// indexUnconfirmedAddresses modifies the unconfirmed (memory-only) address
-// index to include mappings for the addresses encoded by the passed public key
-// script to the transaction.
-//
-// This function is safe for concurrent access.
-func (idx *AddrIndex) indexUnconfirmedAddresses(scriptPubKey []byte, tx *util.Tx) {
-	// The error is ignored here since the only reason it can fail is if the
-	// script fails to parse and it was already validated before being
-	// admitted to the mempool.
-	_, addr, _ := txscript.ExtractScriptPubKeyAddress(scriptPubKey,
-		idx.dagParams)
-	// Ignore unsupported address types.
-	addrKey, err := addrToKey(addr)
-	if err != nil {
-		return
-	}
-
-	// Add a mapping from the address to the transaction.
-	idx.unconfirmedLock.Lock()
-	addrIndexEntry := idx.txnsByAddr[addrKey]
-	if addrIndexEntry == nil {
-		addrIndexEntry = make(map[daghash.TxID]*util.Tx)
-		idx.txnsByAddr[addrKey] = addrIndexEntry
-	}
-	addrIndexEntry[*tx.ID()] = tx
-
-	// Add a mapping from the transaction to the address.
-	addrsByTxEntry := idx.addrsByTx[*tx.ID()]
-	if addrsByTxEntry == nil {
-		addrsByTxEntry = make(map[[addrKeySize]byte]struct{})
-		idx.addrsByTx[*tx.ID()] = addrsByTxEntry
-	}
-	addrsByTxEntry[addrKey] = struct{}{}
-	idx.unconfirmedLock.Unlock()
-}
-
-// AddUnconfirmedTx adds all addresses related to the transaction to the
-// unconfirmed (memory-only) address index.
-//
-// NOTE: This transaction MUST have already been validated by the memory pool
-// before calling this function with it and have all of the inputs available in
-// the provided utxo view. Failure to do so could result in some or all
-// addresses not being indexed.
-//
-// This function is safe for concurrent access.
-func (idx *AddrIndex) AddUnconfirmedTx(tx *util.Tx, utxoSet blockdag.UTXOSet) {
-	// Index addresses of all referenced previous transaction outputs.
-	//
-	// The existence checks are elided since this is only called after the
-	// transaction has already been validated and thus all inputs are
-	// already known to exist.
-	for _, txIn := range tx.MsgTx().TxIn {
-		entry, ok := utxoSet.Get(txIn.PreviousOutpoint)
-		if !ok {
-			// Ignore missing entries. This should never happen
-			// in practice since the function comments specifically
-			// call out all inputs must be available.
-			continue
-		}
-		idx.indexUnconfirmedAddresses(entry.ScriptPubKey(), tx)
-	}
-
-	// Index addresses of all created outputs.
-	for _, txOut := range tx.MsgTx().TxOut {
-		idx.indexUnconfirmedAddresses(txOut.ScriptPubKey, tx)
-	}
-}
-
-// RemoveUnconfirmedTx removes the passed transaction from the unconfirmed
-// (memory-only) address index.
-//
-// This function is safe for concurrent access.
-func (idx *AddrIndex) RemoveUnconfirmedTx(txID *daghash.TxID) {
-	idx.unconfirmedLock.Lock()
-	defer idx.unconfirmedLock.Unlock()
-
-	// Remove all address references to the transaction from the address
-	// index and remove the entry for the address altogether if it no longer
-	// references any transactions.
-	for addrKey := range idx.addrsByTx[*txID] {
-		delete(idx.txnsByAddr[addrKey], *txID)
-		if len(idx.txnsByAddr[addrKey]) == 0 {
-			delete(idx.txnsByAddr, addrKey)
-		}
-	}
-
-	// Remove the entry from the transaction to address lookup map as well.
-	delete(idx.addrsByTx, *txID)
-}
-
-// UnconfirmedTxnsForAddress returns all transactions currently in the
-// unconfirmed (memory-only) address index that involve the passed address.
-// Unsupported address types are ignored and will result in no results.
-//
-// This function is safe for concurrent access.
-func (idx *AddrIndex) UnconfirmedTxnsForAddress(addr util.Address) []*util.Tx {
-	// Ignore unsupported address types.
-	addrKey, err := addrToKey(addr)
-	if err != nil {
-		return nil
-	}
-
-	// Protect concurrent access.
-	idx.unconfirmedLock.RLock()
-	defer idx.unconfirmedLock.RUnlock()
-
-	// Return a new slice with the results if there are any. This ensures
-	// safe concurrency.
-	if txns, exists := idx.txnsByAddr[addrKey]; exists {
-		addressTxns := make([]*util.Tx, 0, len(txns))
-		for _, tx := range txns {
-			addressTxns = append(addressTxns, tx)
-		}
-		return addressTxns
-	}
-
-	return nil
-}
-
-// Recover is invoked when the indexer wasn't turned on for several blocks
-// and the indexer needs to close the gaps.
-//
-// This is part of the Indexer interface.
-func (idx *AddrIndex) Recover(dbTx database.Tx, currentBlockID, lastKnownBlockID uint64) error {
-	return errors.Errorf("addrindex was turned off for %d blocks and can't be recovered."+
-		" To resume working drop the addrindex with --dropaddrindex", lastKnownBlockID-currentBlockID)
-}
-
-// NewAddrIndex returns a new instance of an indexer that is used to create a
-// mapping of all addresses in the blockDAG to the respective transactions
-// that involve them.
-//
-// It implements the Indexer interface which plugs into the IndexManager that in
-// turn is used by the blockDAG package. This allows the index to be
-// seamlessly maintained along with the DAG.
-func NewAddrIndex(dagParams *dagconfig.Params) *AddrIndex {
-	return &AddrIndex{
-		dagParams:  dagParams,
-		txnsByAddr: make(map[[addrKeySize]byte]map[daghash.TxID]*util.Tx),
-		addrsByTx:  make(map[daghash.TxID]map[[addrKeySize]byte]struct{}),
-	}
-}
-
-// DropAddrIndex drops the address index from the provided database if it
-// exists.
-func DropAddrIndex(db database.DB, interrupt <-chan struct{}) error {
-	return dropIndex(db, addrIndexKey, addrIndexName, interrupt)
-}
--- a/blockdag/indexers/addrindex_test.go
+++ b/blockdag/indexers/addrindex_test.go
@@ -1,277 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package indexers
-
-import (
-	"bytes"
-	"fmt"
-	"github.com/pkg/errors"
-	"testing"
-
-	"github.com/kaspanet/kaspad/wire"
-)
-
-// addrIndexBucket provides a mock address index database bucket by implementing
-// the internalBucket interface.
-type addrIndexBucket struct {
-	levels map[[levelKeySize]byte][]byte
-}
-
-// Clone returns a deep copy of the mock address index bucket.
-func (b *addrIndexBucket) Clone() *addrIndexBucket {
-	levels := make(map[[levelKeySize]byte][]byte)
-	for k, v := range b.levels {
-		vCopy := make([]byte, len(v))
-		copy(vCopy, v)
-		levels[k] = vCopy
-	}
-	return &addrIndexBucket{levels: levels}
-}
-
-// Get returns the value associated with the key from the mock address index
-// bucket.
-//
-// This is part of the internalBucket interface.
-func (b *addrIndexBucket) Get(key []byte) []byte {
-	var levelKey [levelKeySize]byte
-	copy(levelKey[:], key)
-	return b.levels[levelKey]
-}
-
-// Put stores the provided key/value pair to the mock address index bucket.
-//
-// This is part of the internalBucket interface.
-func (b *addrIndexBucket) Put(key []byte, value []byte) error {
-	var levelKey [levelKeySize]byte
-	copy(levelKey[:], key)
-	b.levels[levelKey] = value
-	return nil
-}
-
-// Delete removes the provided key from the mock address index bucket.
-//
-// This is part of the internalBucket interface.
-func (b *addrIndexBucket) Delete(key []byte) error {
-	var levelKey [levelKeySize]byte
-	copy(levelKey[:], key)
-	delete(b.levels, levelKey)
-	return nil
-}
-
-// printLevels returns a string with a visual representation of the provided
-// address key taking into account the max size of each level. It is useful
-// when creating and debugging test cases.
-func (b *addrIndexBucket) printLevels(addrKey [addrKeySize]byte) string {
-	highestLevel := uint8(0)
-	for k := range b.levels {
-		if !bytes.Equal(k[:levelOffset], addrKey[:]) {
-			continue
-		}
-		level := uint8(k[levelOffset])
-		if level > highestLevel {
-			highestLevel = level
-		}
-	}
-
-	var levelBuf bytes.Buffer
-	_, _ = levelBuf.WriteString("\n")
-	maxEntries := level0MaxEntries
-	for level := uint8(0); level <= highestLevel; level++ {
-		data := b.levels[keyForLevel(addrKey, level)]
-		numEntries := len(data) / txEntrySize
-		for i := 0; i < numEntries; i++ {
-			start := i * txEntrySize
-			num := byteOrder.Uint32(data[start:])
-			_, _ = levelBuf.WriteString(fmt.Sprintf("%02d ", num))
-		}
-		for i := numEntries; i < maxEntries; i++ {
-			_, _ = levelBuf.WriteString("_  ")
-		}
-		_, _ = levelBuf.WriteString("\n")
-		maxEntries *= 2
-	}
-
-	return levelBuf.String()
-}
-
-// sanityCheck ensures that all data stored in the bucket for the given address
-// adheres to the level-based rules described by the address index
-// documentation.
-func (b *addrIndexBucket) sanityCheck(addrKey [addrKeySize]byte, expectedTotal int) error {
-	// Find the highest level for the key.
-	highestLevel := uint8(0)
-	for k := range b.levels {
-		if !bytes.Equal(k[:levelOffset], addrKey[:]) {
-			continue
-		}
-		level := uint8(k[levelOffset])
-		if level > highestLevel {
-			highestLevel = level
-		}
-	}
-
-	// Ensure the expected total number of entries are present and that
-	// all levels adhere to the rules described in the address index
-	// documentation.
-	var totalEntries int
-	maxEntries := level0MaxEntries
-	for level := uint8(0); level <= highestLevel; level++ {
-		// Level 0 can'have more entries than the max allowed if the
-		// levels after it have data and it can't be empty. All other
-		// levels must either be half full or full.
-		data := b.levels[keyForLevel(addrKey, level)]
-		numEntries := len(data) / txEntrySize
-		totalEntries += numEntries
-		if level == 0 {
-			if (highestLevel != 0 && numEntries == 0) ||
-				numEntries > maxEntries {
-
-				return errors.Errorf("level %d has %d entries",
-					level, numEntries)
-			}
-		} else if numEntries != maxEntries && numEntries != maxEntries/2 {
-			return errors.Errorf("level %d has %d entries", level,
-				numEntries)
-		}
-		maxEntries *= 2
-	}
-	if totalEntries != expectedTotal {
-		return errors.Errorf("expected %d entries - got %d", expectedTotal,
-			totalEntries)
-	}
-
-	// Ensure all of the numbers are in order starting from the highest
-	// level moving to the lowest level.
-	expectedNum := uint32(0)
-	for level := highestLevel + 1; level > 0; level-- {
-		data := b.levels[keyForLevel(addrKey, level)]
-		numEntries := len(data) / txEntrySize
-		for i := 0; i < numEntries; i++ {
-			start := i * txEntrySize
-			num := byteOrder.Uint32(data[start:])
-			if num != expectedNum {
-				return errors.Errorf("level %d offset %d does "+
-					"not contain the expected number of "+
-					"%d - got %d", level, i, num,
-					expectedNum)
-			}
-			expectedNum++
-		}
-	}
-
-	return nil
-}
-
-// TestAddrIndexLevels ensures that adding and deleting entries to the address
-// index creates multiple levels as described by the address index
-// documentation.
-func TestAddrIndexLevels(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		key         [addrKeySize]byte
-		numInsert   int
-		printLevels bool // Set to help debug a specific test.
-	}{
-		{
-			name:      "level 0 not full",
-			numInsert: level0MaxEntries - 1,
-		},
-		{
-			name:      "level 1 half",
-			numInsert: level0MaxEntries + 1,
-		},
-		{
-			name:      "level 1 full",
-			numInsert: level0MaxEntries*2 + 1,
-		},
-		{
-			name:      "level 2 half, level 1 half",
-			numInsert: level0MaxEntries*3 + 1,
-		},
-		{
-			name:      "level 2 half, level 1 full",
-			numInsert: level0MaxEntries*4 + 1,
-		},
-		{
-			name:      "level 2 full, level 1 half",
-			numInsert: level0MaxEntries*5 + 1,
-		},
-		{
-			name:      "level 2 full, level 1 full",
-			numInsert: level0MaxEntries*6 + 1,
-		},
-		{
-			name:      "level 3 half, level 2 half, level 1 half",
-			numInsert: level0MaxEntries*7 + 1,
-		},
-		{
-			name:      "level 3 full, level 2 half, level 1 full",
-			numInsert: level0MaxEntries*12 + 1,
-		},
-	}
-
-nextTest:
-	for testNum, test := range tests {
-		// Insert entries in order.
-		populatedBucket := &addrIndexBucket{
-			levels: make(map[[levelKeySize]byte][]byte),
-		}
-		for i := 0; i < test.numInsert; i++ {
-			txLoc := wire.TxLoc{TxStart: i * 2}
-			err := dbPutAddrIndexEntry(populatedBucket, test.key,
-				uint64(i), txLoc)
-			if err != nil {
-				t.Errorf("dbPutAddrIndexEntry #%d (%s) - "+
-					"unexpected error: %v", testNum,
-					test.name, err)
-				continue nextTest
-			}
-		}
-		if test.printLevels {
-			t.Log(populatedBucket.printLevels(test.key))
-		}
-
-		// Delete entries from the populated bucket until all entries
-		// have been deleted. The bucket is reset to the fully
-		// populated bucket on each iteration so every combination is
-		// tested. Notice the upper limit purposes exceeds the number
-		// of entries to ensure attempting to delete more entries than
-		// there are works correctly.
-		for numDelete := 0; numDelete <= test.numInsert+1; numDelete++ {
-			// Clone populated bucket to run each delete against.
-			bucket := populatedBucket.Clone()
-
-			// Remove the number of entries for this iteration.
-			err := dbRemoveAddrIndexEntries(bucket, test.key,
-				numDelete)
-			if err != nil {
-				if numDelete <= test.numInsert {
-					t.Errorf("dbRemoveAddrIndexEntries (%s) "+
-						" delete %d - unexpected error: "+
-						"%v", test.name, numDelete, err)
-					continue nextTest
-				}
-			}
-			if test.printLevels {
-				t.Log(bucket.printLevels(test.key))
-			}
-
-			// Sanity check the levels to ensure the adhere to all
-			// rules.
-			numExpected := test.numInsert
-			if numDelete <= test.numInsert {
-				numExpected -= numDelete
-			}
-			err = bucket.sanityCheck(test.key, numExpected)
-			if err != nil {
-				t.Errorf("sanity check fail (%s) delete %d: %v",
-					test.name, numDelete, err)
-				continue nextTest
-			}
-		}
-	}
-}
--- a/blockdag/indexers/common.go
+++ b/blockdag/indexers/common.go
@@ -85,8 +85,8 @@ func (e errDeserialize) Error() string {
 // isDeserializeErr returns whether or not the passed error is an errDeserialize
 // error.
 func isDeserializeErr(err error) bool {
-	_, ok := err.(errDeserialize)
-	return ok
+	var deserializeErr errDeserialize
+	return errors.As(err, &deserializeErr)
 }

 // internalBucket is an abstraction over a database bucket. It is used to make
--- a/blockdag/indexers/log.go
+++ b/blockdag/indexers/log.go
@@ -6,8 +6,6 @@ package indexers

 import (
 	"github.com/kaspanet/kaspad/logger"
-	"github.com/kaspanet/kaspad/util/panics"
 )

 var log, _ = logger.Get(logger.SubsystemTags.INDX)
-var spawn = panics.GoroutineWrapperFunc(log)
--- a/blockdag/indexers/manager.go
+++ b/blockdag/indexers/manager.go
@@ -363,6 +363,9 @@ func dropIndex(db database.DB, idxKey []byte, idxName string, interrupt <-chan s
 			}
 			return bucket.DeleteBucket(bucketName[len(bucketName)-1])
 		})
+		if err != nil {
+			return err
+		}
 	}

 	// Remove the index tip, index bucket, and in-progress drop flag now
--- a/blockdag/indexers/txindex.go
+++ b/blockdag/indexers/txindex.go
@@ -1,431 +0,0 @@
-// Copyright (c) 2016 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package indexers
-
-import (
-	"fmt"
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/database"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-	"github.com/pkg/errors"
-)
-
-const (
-	// txIndexName is the human-readable name for the index.
-	txIndexName = "transaction index"
-
-	includingBlocksIndexKeyEntrySize = 8 // 4 bytes for offset + 4 bytes for transaction length
-)
-
-var (
-	includingBlocksIndexKey = []byte("includingblocksidx")
-
-	acceptingBlocksIndexKey = []byte("acceptingblocksidx")
-)
-
-// txsAcceptedByVirtual is the in-memory index of txIDs that were accepted
-// by the current virtual
-var txsAcceptedByVirtual map[daghash.TxID]bool
-
-// -----------------------------------------------------------------------------
-// The transaction index consists of an entry for every transaction in the DAG.
-//
-// There are two buckets used in total. The first bucket maps the hash of
-// each transaction to its location in each block it's included in. The second bucket
-// contains all of the blocks that from their viewpoint the transaction has been
-// accepted (i.e. the transaction is found in their blue set without double spends),
-// and their blue block (or themselves) that included the transaction.
-//
-// NOTE: Although it is technically possible for multiple transactions to have
-// the same hash as long as the previous transaction with the same hash is fully
-// spent, this code only stores the most recent one because doing otherwise
-// would add a non-trivial amount of space and overhead for something that will
-// realistically never happen per the probability and even if it did, the old
-// one must be fully spent and so the most likely transaction a caller would
-// want for a given hash is the most recent one anyways.
-//
-// The including blocks index contains a sub bucket for each transaction hash (32 byte each), that its serialized format is:
-//
-//   <block id> = <start offset><tx length>
-//
-//   Field           Type              Size
-//   block id        uint64          8 bytes
-//   start offset    uint32          4 bytes
-//   tx length       uint32          4 bytes
-//   -----
-//   Total: 16 bytes
-//
-// The accepting blocks index contains a sub bucket for each transaction hash (32 byte each), that its serialized format is:
-//
-//   <accepting block id> = <including block id>
-//
-//   Field           Type              Size
-//   accepting block id        uint64          8 bytes
-//   including block id        uint64          8 bytes
-//   -----
-//   Total: 16 bytes
-//
-// -----------------------------------------------------------------------------
-
-func putIncludingBlocksEntry(target []byte, txLoc wire.TxLoc) {
-	byteOrder.PutUint32(target, uint32(txLoc.TxStart))
-	byteOrder.PutUint32(target[4:], uint32(txLoc.TxLen))
-}
-
-func dbPutIncludingBlocksEntry(dbTx database.Tx, txID *daghash.TxID, blockID uint64, serializedData []byte) error {
-	bucket, err := dbTx.Metadata().Bucket(includingBlocksIndexKey).CreateBucketIfNotExists(txID[:])
-	if err != nil {
-		return err
-	}
-	return bucket.Put(blockdag.SerializeBlockID(blockID), serializedData)
-}
-
-func dbPutAcceptingBlocksEntry(dbTx database.Tx, txID *daghash.TxID, blockID uint64, serializedData []byte) error {
-	bucket, err := dbTx.Metadata().Bucket(acceptingBlocksIndexKey).CreateBucketIfNotExists(txID[:])
-	if err != nil {
-		return err
-	}
-	return bucket.Put(blockdag.SerializeBlockID(blockID), serializedData)
-}
-
-// dbFetchFirstTxRegion uses an existing database transaction to fetch the block
-// region for the provided transaction hash from the transaction index. When
-// there is no entry for the provided hash, nil will be returned for the both
-// the region and the error.
-//
-// P.S Because the transaction can be found in multiple blocks, this function arbitarily
-// returns the first block region that is stored in the txindex.
-func dbFetchFirstTxRegion(dbTx database.Tx, txID *daghash.TxID) (*database.BlockRegion, error) {
-	// Load the record from the database and return now if it doesn't exist.
-	txBucket := dbTx.Metadata().Bucket(includingBlocksIndexKey).Bucket(txID[:])
-	if txBucket == nil {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("No block region "+
-				"was found for %s", txID),
-		}
-	}
-	cursor := txBucket.Cursor()
-	if ok := cursor.First(); !ok {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("No block region "+
-				"was found for %s", txID),
-		}
-	}
-	serializedBlockID := cursor.Key()
-	serializedData := cursor.Value()
-	if len(serializedData) == 0 {
-		return nil, nil
-	}
-
-	// Ensure the serialized data has enough bytes to properly deserialize.
-	if len(serializedData) < includingBlocksIndexKeyEntrySize {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("corrupt transaction index "+
-				"entry for %s", txID),
-		}
-	}
-
-	// Load the block hash associated with the block ID.
-	hash, err := blockdag.DBFetchBlockHashBySerializedID(dbTx, serializedBlockID)
-	if err != nil {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("corrupt transaction index "+
-				"entry for %s: %s", txID, err),
-		}
-	}
-
-	// Deserialize the final entry.
-	region := database.BlockRegion{Hash: &daghash.Hash{}}
-	copy(region.Hash[:], hash[:])
-	region.Offset = byteOrder.Uint32(serializedData[:4])
-	region.Len = byteOrder.Uint32(serializedData[4:])
-
-	return &region, nil
-}
-
-// dbAddTxIndexEntries uses an existing database transaction to add a
-// transaction index entry for every transaction in the passed block.
-func dbAddTxIndexEntries(dbTx database.Tx, block *util.Block, blockID uint64, multiBlockTxsAcceptanceData blockdag.MultiBlockTxsAcceptanceData) error {
-	// The offset and length of the transactions within the serialized
-	// block.
-	txLocs, err := block.TxLoc()
-	if err != nil {
-		return err
-	}
-
-	// As an optimization, allocate a single slice big enough to hold all
-	// of the serialized transaction index entries for the block and
-	// serialize them directly into the slice. Then, pass the appropriate
-	// subslice to the database to be written. This approach significantly
-	// cuts down on the number of required allocations.
-	includingBlocksOffset := 0
-	serializedIncludingBlocksValues := make([]byte, len(block.Transactions())*includingBlocksIndexKeyEntrySize)
-	for i, tx := range block.Transactions() {
-		putIncludingBlocksEntry(serializedIncludingBlocksValues[includingBlocksOffset:], txLocs[i])
-		endOffset := includingBlocksOffset + includingBlocksIndexKeyEntrySize
-		err := dbPutIncludingBlocksEntry(dbTx, tx.ID(), blockID,
-			serializedIncludingBlocksValues[includingBlocksOffset:endOffset:endOffset])
-		if err != nil {
-			return err
-		}
-		includingBlocksOffset += includingBlocksIndexKeyEntrySize
-	}
-
-	for _, blockTxsAcceptanceData := range multiBlockTxsAcceptanceData {
-		var includingBlockID uint64
-		if blockTxsAcceptanceData.BlockHash.IsEqual(block.Hash()) {
-			includingBlockID = blockID
-		} else {
-			includingBlockID, err = blockdag.DBFetchBlockIDByHash(dbTx, &blockTxsAcceptanceData.BlockHash)
-			if err != nil {
-				return err
-			}
-		}
-
-		serializedIncludingBlockID := blockdag.SerializeBlockID(includingBlockID)
-
-		for _, txAcceptanceData := range blockTxsAcceptanceData.TxAcceptanceData {
-			err = dbPutAcceptingBlocksEntry(dbTx, txAcceptanceData.Tx.ID(), blockID, serializedIncludingBlockID)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func updateTxsAcceptedByVirtual(virtualTxsAcceptanceData blockdag.MultiBlockTxsAcceptanceData) error {
-	// Initialize a new txsAcceptedByVirtual
-	entries := 0
-	for _, blockTxsAcceptanceData := range virtualTxsAcceptanceData {
-		entries += len(blockTxsAcceptanceData.TxAcceptanceData)
-	}
-	txsAcceptedByVirtual = make(map[daghash.TxID]bool, entries)
-
-	// Copy virtualTxsAcceptanceData to txsAcceptedByVirtual
-	for _, blockTxsAcceptanceData := range virtualTxsAcceptanceData {
-		for _, txAcceptanceData := range blockTxsAcceptanceData.TxAcceptanceData {
-			txsAcceptedByVirtual[*txAcceptanceData.Tx.ID()] = true
-		}
-	}
-
-	return nil
-}
-
-// TxIndex implements a transaction by hash index. That is to say, it supports
-// querying all transactions by their hash.
-type TxIndex struct {
-	db database.DB
-}
-
-// Ensure the TxIndex type implements the Indexer interface.
-var _ Indexer = (*TxIndex)(nil)
-
-// Init initializes the hash-based transaction index. In particular, it finds
-// the highest used block ID and stores it for later use when connecting or
-// disconnecting blocks.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) Init(db database.DB, dag *blockdag.BlockDAG) error {
-	idx.db = db
-
-	// Initialize the txsAcceptedByVirtual index
-	virtualTxsAcceptanceData, err := dag.TxsAcceptedByVirtual()
-	if err != nil {
-		return err
-	}
-	err = updateTxsAcceptedByVirtual(virtualTxsAcceptanceData)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// Key returns the database key to use for the index as a byte slice.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) Key() []byte {
-	return includingBlocksIndexKey
-}
-
-// Name returns the human-readable name of the index.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) Name() string {
-	return txIndexName
-}
-
-// Create is invoked when the indexer manager determines the index needs
-// to be created for the first time. It creates the buckets for the hash-based
-// transaction index and the internal block ID indexes.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) Create(dbTx database.Tx) error {
-	meta := dbTx.Metadata()
-	if _, err := meta.CreateBucket(includingBlocksIndexKey); err != nil {
-		return err
-	}
-	_, err := meta.CreateBucket(acceptingBlocksIndexKey)
-	return err
-
-}
-
-// ConnectBlock is invoked by the index manager when a new block has been
-// connected to the DAG. This indexer adds a hash-to-transaction mapping
-// for every transaction in the passed block.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) ConnectBlock(dbTx database.Tx, block *util.Block, blockID uint64, dag *blockdag.BlockDAG,
-	acceptedTxsData blockdag.MultiBlockTxsAcceptanceData, virtualTxsAcceptanceData blockdag.MultiBlockTxsAcceptanceData) error {
-	if err := dbAddTxIndexEntries(dbTx, block, blockID, acceptedTxsData); err != nil {
-		return err
-	}
-
-	err := updateTxsAcceptedByVirtual(virtualTxsAcceptanceData)
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// TxFirstBlockRegion returns the first block region for the provided transaction hash
-// from the transaction index. The block region can in turn be used to load the
-// raw transaction bytes. When there is no entry for the provided hash, nil
-// will be returned for the both the entry and the error.
-//
-// This function is safe for concurrent access.
-func (idx *TxIndex) TxFirstBlockRegion(txID *daghash.TxID) (*database.BlockRegion, error) {
-	var region *database.BlockRegion
-	err := idx.db.View(func(dbTx database.Tx) error {
-		var err error
-		region, err = dbFetchFirstTxRegion(dbTx, txID)
-		return err
-	})
-	return region, err
-}
-
-// TxBlocks returns the hashes of the blocks where the transaction exists
-func (idx *TxIndex) TxBlocks(txHash *daghash.Hash) ([]*daghash.Hash, error) {
-	blockHashes := make([]*daghash.Hash, 0)
-	err := idx.db.View(func(dbTx database.Tx) error {
-		var err error
-		blockHashes, err = dbFetchTxBlocks(dbTx, txHash)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-	return blockHashes, err
-}
-
-func dbFetchTxBlocks(dbTx database.Tx, txHash *daghash.Hash) ([]*daghash.Hash, error) {
-	blockHashes := make([]*daghash.Hash, 0)
-	bucket := dbTx.Metadata().Bucket(includingBlocksIndexKey).Bucket(txHash[:])
-	if bucket == nil {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("No including blocks "+
-				"were found for %s", txHash),
-		}
-	}
-	err := bucket.ForEach(func(serializedBlockID, _ []byte) error {
-		blockHash, err := blockdag.DBFetchBlockHashBySerializedID(dbTx, serializedBlockID)
-		if err != nil {
-			return err
-		}
-		blockHashes = append(blockHashes, blockHash)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return blockHashes, nil
-}
-
-// BlockThatAcceptedTx returns the hash of the block where the transaction got accepted (from the virtual block point of view)
-func (idx *TxIndex) BlockThatAcceptedTx(dag *blockdag.BlockDAG, txID *daghash.TxID) (*daghash.Hash, error) {
-	var acceptingBlock *daghash.Hash
-	err := idx.db.View(func(dbTx database.Tx) error {
-		var err error
-		acceptingBlock, err = dbFetchTxAcceptingBlock(dbTx, txID, dag)
-		return err
-	})
-	return acceptingBlock, err
-}
-
-func dbFetchTxAcceptingBlock(dbTx database.Tx, txID *daghash.TxID, dag *blockdag.BlockDAG) (*daghash.Hash, error) {
-	// If the transaction was accepted by the current virtual,
-	// return the zeroHash immediately
-	if _, ok := txsAcceptedByVirtual[*txID]; ok {
-		return &daghash.ZeroHash, nil
-	}
-
-	bucket := dbTx.Metadata().Bucket(acceptingBlocksIndexKey).Bucket(txID[:])
-	if bucket == nil {
-		return nil, nil
-	}
-	cursor := bucket.Cursor()
-	if !cursor.First() {
-		return nil, database.Error{
-			ErrorCode: database.ErrCorruption,
-			Description: fmt.Sprintf("Accepting blocks bucket is "+
-				"empty for %s", txID),
-		}
-	}
-	for ; cursor.Key() != nil; cursor.Next() {
-		blockHash, err := blockdag.DBFetchBlockHashBySerializedID(dbTx, cursor.Key())
-		if err != nil {
-			return nil, err
-		}
-		if dag.IsInSelectedParentChain(blockHash) {
-			return blockHash, nil
-		}
-	}
-	return nil, nil
-}
-
-// NewTxIndex returns a new instance of an indexer that is used to create a
-// mapping of the hashes of all transactions in the blockDAG to the respective
-// block, location within the block, and size of the transaction.
-//
-// It implements the Indexer interface which plugs into the IndexManager that in
-// turn is used by the blockdag package. This allows the index to be
-// seamlessly maintained along with the DAG.
-func NewTxIndex() *TxIndex {
-	return &TxIndex{}
-}
-
-// DropTxIndex drops the transaction index from the provided database if it
-// exists. Since the address index relies on it, the address index will also be
-// dropped when it exists.
-func DropTxIndex(db database.DB, interrupt <-chan struct{}) error {
-	err := dropIndex(db, addrIndexKey, addrIndexName, interrupt)
-	if err != nil {
-		return err
-	}
-
-	err = dropIndex(db, includingBlocksIndexKey, addrIndexName, interrupt)
-	if err != nil {
-		return err
-	}
-
-	return dropIndex(db, acceptingBlocksIndexKey, txIndexName, interrupt)
-}
-
-// Recover is invoked when the indexer wasn't turned on for several blocks
-// and the indexer needs to close the gaps.
-//
-// This is part of the Indexer interface.
-func (idx *TxIndex) Recover(dbTx database.Tx, currentBlockID, lastKnownBlockID uint64) error {
-	return errors.Errorf("txindex was turned off for %d blocks and can't be recovered."+
-		" To resume working drop the txindex with --droptxindex", lastKnownBlockID-currentBlockID)
-}
--- a/blockdag/indexers/txindex_test.go
+++ b/blockdag/indexers/txindex_test.go
@@ -1,144 +0,0 @@
-package indexers
-
-import (
-	"bytes"
-	"reflect"
-	"testing"
-
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/mining"
-	"github.com/kaspanet/kaspad/txscript"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
-	"github.com/kaspanet/kaspad/wire"
-)
-
-func createTransaction(t *testing.T, value uint64, originTx *wire.MsgTx, outputIndex uint32) *wire.MsgTx {
-	signatureScript, err := txscript.PayToScriptHashSignatureScript(blockdag.OpTrueScript, nil)
-	if err != nil {
-		t.Fatalf("Error creating signature script: %s", err)
-	}
-	txIn := &wire.TxIn{
-		PreviousOutpoint: wire.Outpoint{
-			TxID:  *originTx.TxID(),
-			Index: outputIndex,
-		},
-		Sequence:        wire.MaxTxInSequenceNum,
-		SignatureScript: signatureScript,
-	}
-	txOut := wire.NewTxOut(value, blockdag.OpTrueScript)
-	tx := wire.NewNativeMsgTx(wire.TxVersion, []*wire.TxIn{txIn}, []*wire.TxOut{txOut})
-
-	return tx
-}
-
-func TestTxIndexConnectBlock(t *testing.T) {
-	blocks := make(map[daghash.Hash]*util.Block)
-
-	txIndex := NewTxIndex()
-	indexManager := NewManager([]Indexer{txIndex})
-
-	params := dagconfig.SimNetParams
-	params.BlockCoinbaseMaturity = 0
-	params.K = 1
-
-	config := blockdag.Config{
-		IndexManager: indexManager,
-		DAGParams:    &params,
-	}
-
-	dag, teardown, err := blockdag.DAGSetup("TestTxIndexConnectBlock", config)
-	if err != nil {
-		t.Fatalf("TestTxIndexConnectBlock: Failed to setup DAG instance: %v", err)
-	}
-	if teardown != nil {
-		defer teardown()
-	}
-
-	prepareAndProcessBlock := func(parentHashes []*daghash.Hash, transactions []*wire.MsgTx, blockName string) *wire.MsgBlock {
-		block, err := mining.PrepareBlockForTest(dag, &params, parentHashes, transactions, false)
-		if err != nil {
-			t.Fatalf("TestTxIndexConnectBlock: block %v got unexpected error from PrepareBlockForTest: %v", blockName, err)
-		}
-		utilBlock := util.NewBlock(block)
-		blocks[*block.BlockHash()] = utilBlock
-		isOrphan, delay, err := dag.ProcessBlock(utilBlock, blockdag.BFNoPoWCheck)
-		if err != nil {
-			t.Fatalf("TestTxIndexConnectBlock: dag.ProcessBlock got unexpected error for block %v: %v", blockName, err)
-		}
-		if delay != 0 {
-			t.Fatalf("TestTxIndexConnectBlock: block %s "+
-				"is too far in the future", blockName)
-		}
-		if isOrphan {
-			t.Fatalf("TestTxIndexConnectBlock: block %v was unexpectedly orphan", blockName)
-		}
-		return block
-	}
-
-	block1 := prepareAndProcessBlock([]*daghash.Hash{params.GenesisHash}, nil, "1")
-	block2Tx := createTransaction(t, block1.Transactions[0].TxOut[0].Value, block1.Transactions[0], 0)
-	block2 := prepareAndProcessBlock([]*daghash.Hash{block1.BlockHash()}, []*wire.MsgTx{block2Tx}, "2")
-	block3Tx := createTransaction(t, block2.Transactions[0].TxOut[0].Value, block2.Transactions[0], 0)
-	block3 := prepareAndProcessBlock([]*daghash.Hash{block2.BlockHash()}, []*wire.MsgTx{block3Tx}, "3")
-
-	block2TxID := block2Tx.TxID()
-	block2TxNewAcceptedBlock, err := txIndex.BlockThatAcceptedTx(dag, block2TxID)
-	if err != nil {
-		t.Errorf("TestTxIndexConnectBlock: TxAcceptedInBlock: %v", err)
-	}
-	block3Hash := block3.BlockHash()
-	if !block2TxNewAcceptedBlock.IsEqual(block3Hash) {
-		t.Errorf("TestTxIndexConnectBlock: block2Tx should've "+
-			"been accepted in block %v but instead got accepted in block %v", block3Hash, block2TxNewAcceptedBlock)
-	}
-
-	block3TxID := block3Tx.TxID()
-	block3TxNewAcceptedBlock, err := txIndex.BlockThatAcceptedTx(dag, block3TxID)
-	if err != nil {
-		t.Errorf("TestTxIndexConnectBlock: TxAcceptedInBlock: %v", err)
-	}
-	if !block3TxNewAcceptedBlock.IsEqual(&daghash.ZeroHash) {
-		t.Errorf("TestTxIndexConnectBlock: block3Tx should've "+
-			"been accepted by the virtual block but instead got accepted in block %v", block3TxNewAcceptedBlock)
-	}
-
-	block3A := prepareAndProcessBlock([]*daghash.Hash{block2.BlockHash()}, []*wire.MsgTx{block3Tx}, "3A")
-	block4 := prepareAndProcessBlock([]*daghash.Hash{block3.BlockHash()}, nil, "4")
-	prepareAndProcessBlock([]*daghash.Hash{block3A.BlockHash(), block4.BlockHash()}, nil, "5")
-
-	block2TxAcceptedBlock, err := txIndex.BlockThatAcceptedTx(dag, block2TxID)
-	if err != nil {
-		t.Errorf("TestTxIndexConnectBlock: TxAcceptedInBlock: %v", err)
-	}
-	block3AHash := block3A.BlockHash()
-	if !block2TxAcceptedBlock.IsEqual(block3AHash) {
-		t.Errorf("TestTxIndexConnectBlock: block2Tx should've "+
-			"been accepted in block %v but instead got accepted in block %v", block3AHash, block2TxAcceptedBlock)
-	}
-
-	region, err := txIndex.TxFirstBlockRegion(block3TxID)
-	if err != nil {
-		t.Fatalf("TestTxIndexConnectBlock: no block region was found for block3Tx")
-	}
-	regionBlock, ok := blocks[*region.Hash]
-	if !ok {
-		t.Fatalf("TestTxIndexConnectBlock: couldn't find block with hash %v", region.Hash)
-	}
-
-	regionBlockBytes, err := regionBlock.Bytes()
-	if err != nil {
-		t.Fatalf("TestTxIndexConnectBlock: Couldn't serialize block to bytes")
-	}
-	block3TxInBlock := regionBlockBytes[region.Offset : region.Offset+region.Len]
-
-	block3TxBuf := bytes.NewBuffer(make([]byte, 0, block3Tx.SerializeSize()))
-	block3Tx.KaspaEncode(block3TxBuf, 0)
-	blockTxBytes := block3TxBuf.Bytes()
-
-	if !reflect.DeepEqual(blockTxBytes, block3TxInBlock) {
-		t.Errorf("TestTxIndexConnectBlock: the block region that was in the bucket doesn't match block3Tx")
-	}
-
-}
--- a/blockdag/mediantime.go
+++ b/blockdag/mediantime.go
@@ -71,9 +71,6 @@ func (s int64Sorter) Less(i, j int) bool {
 }

 // medianTime provides an implementation of the MedianTimeSource interface.
-// It is limited to maxMedianTimeEntries includes the same buggy behavior as
-// the time offset mechanism in Bitcoin Core. This is necessary because it is
-// used in the consensus code.
 type medianTime struct {
 	mtx                sync.Mutex
 	knownIDs           map[string]struct{}
@@ -137,15 +134,6 @@ func (m *medianTime) AddTimeSample(sourceID string, timeVal time.Time) {
 	log.Debugf("Added time sample of %s (total: %d)", offsetDuration,
 		numOffsets)

-	// NOTE: The following code intentionally has a bug to mirror the
-	// buggy behavior in Bitcoin Core since the median time is used in the
-	// consensus rules.
-	//
-	// In particular, the offset is only updated when the number of entries
-	// is odd, but the max number of entries is 200, an even number. Thus,
-	// the offset will never be updated again once the max number of entries
-	// is reached.
-
 	// The median offset is only updated when there are enough offsets and
 	// the number of offsets is odd so the middle value is the true median.
 	// Thus, there is nothing to do when those conditions are not met.
--- a/blockdag/mediantime_test.go
+++ b/blockdag/mediantime_test.go
@@ -34,9 +34,7 @@ func TestMedianTime(t *testing.T) {
 		{in: []int64{-5, -4, -3, -2, -1}, wantOffset: -3, useDupID: true},

 		// The offset stops being updated once the max number of entries
-		// has been reached. This is actually a bug from Bitcoin Core,
-		// but since the time is ultimately used as a part of the
-		// consensus rules, it must be mirrored.
+		// has been reached.
 		{in: []int64{-67, 67, -50, 24, 63, 17, 58, -14, 5, -32, -52}, wantOffset: 17},
 		{in: []int64{-67, 67, -50, 24, 63, 17, 58, -14, 5, -32, -52, 45}, wantOffset: 17},
 		{in: []int64{-67, 67, -50, 24, 63, 17, 58, -14, 5, -32, -52, 45, 4}, wantOffset: 17},
--- a/blockdag/mining.go
+++ b/blockdag/mining.go
@@ -0,0 +1,111 @@
+package blockdag
+
+import (
+	"bytes"
+	"encoding/binary"
+	"github.com/kaspanet/kaspad/txscript"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/wire"
+	"time"
+)
+
+// BlockForMining returns a block with the given transactions
+// that points to the current DAG tips, that is valid from
+// all aspects except proof of work.
+func (dag *BlockDAG) BlockForMining(transactions []*util.Tx) (*wire.MsgBlock, error) {
+	blockTimestamp := dag.NextBlockTime()
+	requiredDifficulty := dag.NextRequiredDifficulty(blockTimestamp)
+
+	// Calculate the next expected block version based on the state of the
+	// rule change deployments.
+	nextBlockVersion, err := dag.CalcNextBlockVersion()
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a new block ready to be solved.
+	hashMerkleTree := BuildHashMerkleTreeStore(transactions)
+	acceptedIDMerkleRoot, err := dag.NextAcceptedIDMerkleRootNoLock()
+	if err != nil {
+		return nil, err
+	}
+	var msgBlock wire.MsgBlock
+	for _, tx := range transactions {
+		msgBlock.AddTransaction(tx.MsgTx())
+	}
+
+	utxoWithTransactions, err := dag.UTXOSet().WithTransactions(msgBlock.Transactions, UnacceptedBlueScore, false)
+	if err != nil {
+		return nil, err
+	}
+	utxoCommitment := utxoWithTransactions.Multiset().Hash()
+
+	msgBlock.Header = wire.BlockHeader{
+		Version:              nextBlockVersion,
+		ParentHashes:         dag.TipHashes(),
+		HashMerkleRoot:       hashMerkleTree.Root(),
+		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
+		UTXOCommitment:       utxoCommitment,
+		Timestamp:            blockTimestamp,
+		Bits:                 requiredDifficulty,
+	}
+
+	return &msgBlock, nil
+}
+
+// CoinbasePayloadExtraData returns coinbase payload extra data parameter
+// which is built from extra nonce and coinbase flags.
+func CoinbasePayloadExtraData(extraNonce uint64, coinbaseFlags string) ([]byte, error) {
+	extraNonceBytes := make([]byte, 8)
+	binary.LittleEndian.PutUint64(extraNonceBytes, extraNonce)
+	w := &bytes.Buffer{}
+	_, err := w.Write(extraNonceBytes)
+	if err != nil {
+		return nil, err
+	}
+	_, err = w.Write([]byte(coinbaseFlags))
+	if err != nil {
+		return nil, err
+	}
+	return w.Bytes(), nil
+}
+
+// NextCoinbaseFromAddress returns a coinbase transaction for the
+// next block with the given address and extra data in its payload.
+func (dag *BlockDAG) NextCoinbaseFromAddress(payToAddress util.Address, extraData []byte) (*util.Tx, error) {
+	coinbasePayloadScriptPubKey, err := txscript.PayToAddrScript(payToAddress)
+	if err != nil {
+		return nil, err
+	}
+	coinbaseTx, err := dag.NextBlockCoinbaseTransactionNoLock(coinbasePayloadScriptPubKey, extraData)
+	if err != nil {
+		return nil, err
+	}
+	return coinbaseTx, nil
+}
+
+// NextBlockMinimumTime returns the minimum allowed timestamp for a block building
+// on the end of the DAG. In particular, it is one second after
+// the median timestamp of the last several blocks per the DAG consensus
+// rules.
+func (dag *BlockDAG) NextBlockMinimumTime() time.Time {
+	return dag.CalcPastMedianTime().Add(time.Second)
+}
+
+// NextBlockTime returns a valid block time for the
+// next block that will point to the existing DAG tips.
+func (dag *BlockDAG) NextBlockTime() time.Time {
+	// The timestamp for the block must not be before the median timestamp
+	// of the last several blocks. Thus, choose the maximum between the
+	// current time and one second after the past median time. The current
+	// timestamp is truncated to a second boundary before comparison since a
+	// block timestamp does not supported a precision greater than one
+	// second.
+	newTimestamp := dag.AdjustedTime()
+	minTimestamp := dag.NextBlockMinimumTime()
+	if newTimestamp.Before(minTimestamp) {
+		newTimestamp = minTimestamp
+	}
+
+	return newTimestamp
+}
--- a/blockdag/notifications.go
+++ b/blockdag/notifications.go
@@ -57,8 +57,8 @@ type Notification struct {
 // NotificationType for details on the types and contents of notifications.
 func (dag *BlockDAG) Subscribe(callback NotificationCallback) {
 	dag.notificationsLock.Lock()
+	defer dag.notificationsLock.Unlock()
 	dag.notifications = append(dag.notifications, callback)
-	dag.notificationsLock.Unlock()
 }

 // sendNotification sends a notification with the passed type and data if the
@@ -68,10 +68,10 @@ func (dag *BlockDAG) sendNotification(typ NotificationType, data interface{}) {
 	// Generate and send the notification.
 	n := Notification{Type: typ, Data: data}
 	dag.notificationsLock.RLock()
+	defer dag.notificationsLock.RUnlock()
 	for _, callback := range dag.notifications {
 		callback(&n)
 	}
-	dag.notificationsLock.RUnlock()
 }

 // BlockAddedNotificationData defines data to be sent along with a BlockAdded
--- a/blockdag/notifications_test.go
+++ b/blockdag/notifications_test.go
@@ -20,7 +20,7 @@ func TestNotifications(t *testing.T) {

 	// Create a new database and dag instance to run tests against.
 	dag, teardownFunc, err := DAGSetup("notifications", Config{
-		DAGParams: &dagconfig.SimNetParams,
+		DAGParams: &dagconfig.SimnetParams,
 	})
 	if err != nil {
 		t.Fatalf("Failed to setup dag instance: %v", err)
@@ -41,11 +41,11 @@ func TestNotifications(t *testing.T) {
 		dag.Subscribe(callback)
 	}

-	isOrphan, delay, err := dag.ProcessBlock(blocks[1], BFNone)
+	isOrphan, isDelayed, err := dag.ProcessBlock(blocks[1], BFNone)
 	if err != nil {
 		t.Fatalf("ProcessBlock fail on block 1: %v\n", err)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("ProcessBlock: block 1 " +
 			"is too far in the future")
 	}
--- a/blockdag/phantom.go
+++ b/blockdag/phantom.go
@@ -1,105 +0,0 @@
-package blockdag
-
-import (
-	"github.com/kaspanet/kaspad/util/daghash"
-)
-
-// phantom calculates and returns the block's blue set, selected parent and blue score.
-// Chain start is determined by going down the DAG through the selected path
-// (follow the selected parent of each block) k + 1 steps.
-// The blue set of a block are all blue blocks in its past.
-// To optimize memory usage, for each block we are storing only the blue blocks in
-// its selected parent's anticone that are in the future of the chain start
-// as well as the selected parent itself - the rest of the
-// blue set can be restored by traversing the selected parent chain and combining
-// the .blues of all blocks in it.
-// The blue score is the total number of blocks in this block's blue set
-// of the selected parent. (the blue score of the genesis block is defined as 0)
-// The selected parent is chosen by determining which block's parent will give this block the highest blue score.
-func phantom(block *blockNode, k uint32) (blues []*blockNode, selectedParent *blockNode, score uint64) {
-	bestScore := uint64(0)
-	var bestParent *blockNode
-	var bestBlues []*blockNode
-	var bestHash *daghash.Hash
-	for _, parent := range block.parents {
-		chainStart := digToChainStart(parent, k)
-		candidates := blueCandidates(chainStart)
-		blues := traverseCandidates(block, candidates, parent)
-		score := uint64(len(blues)) + parent.blueScore
-
-		if score > bestScore || (score == bestScore && (bestHash == nil || daghash.Less(parent.hash, bestHash))) {
-			bestScore = score
-			bestBlues = blues
-			bestParent = parent
-			bestHash = parent.hash
-		}
-	}
-
-	return bestBlues, bestParent, bestScore
-}
-
-// digToChainStart digs through the selected path and returns the block in depth k+1
-func digToChainStart(parent *blockNode, k uint32) *blockNode {
-	current := parent
-
-	for i := uint32(0); i < k; i++ {
-		if current.isGenesis() {
-			break
-		}
-		current = current.selectedParent
-	}
-
-	return current
-}
-
-func blueCandidates(chainStart *blockNode) blockSet {
-	candidates := newSet()
-	candidates.add(chainStart)
-
-	queue := []*blockNode{chainStart}
-	for len(queue) > 0 {
-		var current *blockNode
-		current, queue = queue[0], queue[1:]
-
-		children := current.children
-		for _, child := range children {
-			if !candidates.contains(child) {
-				candidates.add(child)
-				queue = append(queue, child)
-			}
-		}
-	}
-
-	return candidates
-}
-
-//traverseCandidates returns all the blocks that are in the future of the chain start and in the anticone of the selected parent
-func traverseCandidates(newBlock *blockNode, candidates blockSet, selectedParent *blockNode) []*blockNode {
-	blues := []*blockNode{}
-	selectedParentPast := newSet()
-	queue := newDownHeap()
-	visited := newSet()
-
-	for _, parent := range newBlock.parents {
-		queue.Push(parent)
-	}
-
-	for queue.Len() > 0 {
-		current := queue.pop()
-		if candidates.contains(current) {
-			if current == selectedParent || selectedParentPast.anyChildInSet(current) {
-				selectedParentPast.add(current)
-			} else {
-				blues = append(blues, current)
-			}
-			for _, parent := range current.parents {
-				if !visited.contains(parent) {
-					visited.add(parent)
-					queue.Push(parent)
-				}
-			}
-		}
-	}
-
-	return append(blues, selectedParent)
-}
--- a/blockdag/phantom_test.go
+++ b/blockdag/phantom_test.go
@@ -1,892 +0,0 @@
-package blockdag
-
-import (
-	"fmt"
-	"reflect"
-	"sort"
-	"testing"
-	"time"
-
-	"github.com/kaspanet/kaspad/util/daghash"
-
-	"github.com/kaspanet/kaspad/dagconfig"
-)
-
-type testBlockData struct {
-	parents                []string
-	id                     string //id is a virtual entity that is used only for tests so we can define relations between blocks without knowing their hash
-	expectedScore          uint64
-	expectedSelectedParent string
-	expectedBlues          []string
-}
-
-//TestPhantom iterate over several dag simulations, and checks
-//that the blue score, blue set and selected parent of each
-//block calculated as expected
-func TestPhantom(t *testing.T) {
-	netParams := dagconfig.SimNetParams
-
-	blockVersion := int32(0x10000000)
-
-	tests := []struct {
-		k              uint32
-		dagData        []*testBlockData
-		virtualBlockID string
-		expectedReds   []string
-	}{
-		{
-			//Block hash order:AKJIHGFEDCB
-			k:              1,
-			virtualBlockID: "K",
-			expectedReds:   []string{"D"},
-			dagData: []*testBlockData{
-				{
-					parents:                []string{"A"},
-					id:                     "B",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"A"},
-					id:                     "C",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"B"},
-					id:                     "D",
-					expectedScore:          2,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"B"},
-				},
-				{
-					parents:                []string{"B"},
-					id:                     "E",
-					expectedScore:          2,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"B"},
-				},
-				{
-					parents:                []string{"C"},
-					id:                     "F",
-					expectedScore:          2,
-					expectedSelectedParent: "C",
-					expectedBlues:          []string{"C"},
-				},
-				{
-					parents:                []string{"C", "D"},
-					id:                     "G",
-					expectedScore:          4,
-					expectedSelectedParent: "C",
-					expectedBlues:          []string{"D", "B", "C"},
-				},
-				{
-					parents:                []string{"C", "E"},
-					id:                     "H",
-					expectedScore:          4,
-					expectedSelectedParent: "C",
-					expectedBlues:          []string{"E", "B", "C"},
-				},
-				{
-					parents:                []string{"E", "G"},
-					id:                     "I",
-					expectedScore:          5,
-					expectedSelectedParent: "E",
-					expectedBlues:          []string{"G", "D", "E"},
-				},
-				{
-					parents:                []string{"F"},
-					id:                     "J",
-					expectedScore:          3,
-					expectedSelectedParent: "F",
-					expectedBlues:          []string{"F"},
-				},
-				{
-					parents:                []string{"H", "I", "J"},
-					id:                     "K",
-					expectedScore:          9,
-					expectedSelectedParent: "H",
-					expectedBlues:          []string{"I", "G", "J", "F", "H"},
-				},
-			},
-		},
-		{
-			//block hash order:AVUTSRQPONMLKJIHGFEDCB
-			k:              2,
-			virtualBlockID: "V",
-			expectedReds:   []string{"D", "J", "P"},
-			dagData: []*testBlockData{
-				{
-					parents:                []string{"A"},
-					id:                     "B",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"A"},
-					id:                     "C",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"B"},
-					id:                     "D",
-					expectedScore:          2,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"B"},
-				},
-				{
-					parents:                []string{"B"},
-					id:                     "E",
-					expectedScore:          2,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"B"},
-				},
-				{
-					parents:                []string{"C"},
-					id:                     "F",
-					expectedScore:          2,
-					expectedSelectedParent: "C",
-					expectedBlues:          []string{"C"},
-				},
-				{
-					parents:                []string{"C"},
-					id:                     "G",
-					expectedScore:          2,
-					expectedSelectedParent: "C",
-					expectedBlues:          []string{"C"},
-				},
-				{
-					parents:                []string{"G"},
-					id:                     "H",
-					expectedScore:          3,
-					expectedSelectedParent: "G",
-					expectedBlues:          []string{"G"},
-				},
-				{
-					parents:                []string{"E"},
-					id:                     "I",
-					expectedScore:          3,
-					expectedSelectedParent: "E",
-					expectedBlues:          []string{"E"},
-				},
-				{
-					parents:                []string{"E"},
-					id:                     "J",
-					expectedScore:          3,
-					expectedSelectedParent: "E",
-					expectedBlues:          []string{"E"},
-				},
-				{
-					parents:                []string{"I"},
-					id:                     "K",
-					expectedScore:          4,
-					expectedSelectedParent: "I",
-					expectedBlues:          []string{"I"},
-				},
-				{
-					parents:                []string{"K", "H"},
-					id:                     "L",
-					expectedScore:          5,
-					expectedSelectedParent: "K",
-					expectedBlues:          []string{"K"},
-				},
-				{
-					parents:                []string{"F", "L"},
-					id:                     "M",
-					expectedScore:          10,
-					expectedSelectedParent: "F",
-					expectedBlues:          []string{"L", "K", "I", "H", "G", "E", "B", "F"},
-				},
-				{
-					parents:                []string{"G", "K"},
-					id:                     "N",
-					expectedScore:          7,
-					expectedSelectedParent: "G",
-					expectedBlues:          []string{"K", "I", "E", "B", "G"},
-				},
-				{
-					parents:                []string{"J", "N"},
-					id:                     "O",
-					expectedScore:          8,
-					expectedSelectedParent: "N",
-					expectedBlues:          []string{"N"},
-				},
-				{
-					parents:                []string{"D"},
-					id:                     "P",
-					expectedScore:          3,
-					expectedSelectedParent: "D",
-					expectedBlues:          []string{"D"},
-				},
-				{
-					parents:                []string{"O", "P"},
-					id:                     "Q",
-					expectedScore:          10,
-					expectedSelectedParent: "P",
-					expectedBlues:          []string{"O", "N", "K", "J", "I", "E", "P"},
-				},
-				{
-					parents:                []string{"L", "Q"},
-					id:                     "R",
-					expectedScore:          11,
-					expectedSelectedParent: "Q",
-					expectedBlues:          []string{"Q"},
-				},
-				{
-					parents:                []string{"M", "R"},
-					id:                     "S",
-					expectedScore:          15,
-					expectedSelectedParent: "M",
-					expectedBlues:          []string{"R", "Q", "O", "N", "M"},
-				},
-				{
-					parents:                []string{"H", "F"},
-					id:                     "T",
-					expectedScore:          5,
-					expectedSelectedParent: "F",
-					expectedBlues:          []string{"H", "G", "F"},
-				},
-				{
-					parents:                []string{"M", "T"},
-					id:                     "U",
-					expectedScore:          12,
-					expectedSelectedParent: "M",
-					expectedBlues:          []string{"T", "M"},
-				},
-				{
-					parents:                []string{"S", "U"},
-					id:                     "V",
-					expectedScore:          18,
-					expectedSelectedParent: "S",
-					expectedBlues:          []string{"U", "T", "S"},
-				},
-			},
-		},
-		{
-			//Block hash order:AXWVUTSRQPONMLKJIHGFEDCB
-			k:              1,
-			virtualBlockID: "X",
-			expectedReds:   []string{"D", "F", "G", "H", "J", "K", "L", "N", "O", "Q", "R", "S", "U", "V"},
-			dagData: []*testBlockData{
-				{
-					parents:                []string{"A"},
-					id:                     "B",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"A"},
-					id:                     "C",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"A"},
-					id:                     "D",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"A"},
-					id:                     "E",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"B"},
-					id:                     "F",
-					expectedScore:          2,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"B"},
-				},
-				{
-					parents:                []string{"B"},
-					id:                     "G",
-					expectedScore:          2,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"B"},
-				},
-				{
-					parents:                []string{"C"},
-					id:                     "H",
-					expectedScore:          2,
-					expectedSelectedParent: "C",
-					expectedBlues:          []string{"C"},
-				},
-				{
-					parents:                []string{"C"},
-					id:                     "I",
-					expectedScore:          2,
-					expectedSelectedParent: "C",
-					expectedBlues:          []string{"C"},
-				},
-				{
-					parents:                []string{"B"},
-					id:                     "J",
-					expectedScore:          2,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"B"},
-				},
-				{
-					parents:                []string{"D"},
-					id:                     "K",
-					expectedScore:          2,
-					expectedSelectedParent: "D",
-					expectedBlues:          []string{"D"},
-				},
-				{
-					parents:                []string{"D"},
-					id:                     "L",
-					expectedScore:          2,
-					expectedSelectedParent: "D",
-					expectedBlues:          []string{"D"},
-				},
-				{
-					parents:                []string{"E"},
-					id:                     "M",
-					expectedScore:          2,
-					expectedSelectedParent: "E",
-					expectedBlues:          []string{"E"},
-				},
-				{
-					parents:                []string{"E"},
-					id:                     "N",
-					expectedScore:          2,
-					expectedSelectedParent: "E",
-					expectedBlues:          []string{"E"},
-				},
-				{
-					parents:                []string{"F", "G", "J"},
-					id:                     "O",
-					expectedScore:          5,
-					expectedSelectedParent: "F",
-					expectedBlues:          []string{"J", "G", "F"},
-				},
-				{
-					parents:                []string{"B", "M", "I"},
-					id:                     "P",
-					expectedScore:          6,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"M", "I", "E", "C", "B"},
-				},
-				{
-					parents:                []string{"K", "E"},
-					id:                     "Q",
-					expectedScore:          4,
-					expectedSelectedParent: "E",
-					expectedBlues:          []string{"K", "D", "E"},
-				},
-				{
-					parents:                []string{"L", "N"},
-					id:                     "R",
-					expectedScore:          3,
-					expectedSelectedParent: "L",
-					expectedBlues:          []string{"L"},
-				},
-				{
-					parents:                []string{"I", "Q"},
-					id:                     "S",
-					expectedScore:          5,
-					expectedSelectedParent: "Q",
-					expectedBlues:          []string{"Q"},
-				},
-				{
-					parents:                []string{"K", "P"},
-					id:                     "T",
-					expectedScore:          7,
-					expectedSelectedParent: "P",
-					expectedBlues:          []string{"P"},
-				},
-				{
-					parents:                []string{"K", "L"},
-					id:                     "U",
-					expectedScore:          4,
-					expectedSelectedParent: "K",
-					expectedBlues:          []string{"L", "K"},
-				},
-				{
-					parents:                []string{"U", "R"},
-					id:                     "V",
-					expectedScore:          5,
-					expectedSelectedParent: "R",
-					expectedBlues:          []string{"U", "R"},
-				},
-				{
-					parents:                []string{"S", "U", "T"},
-					id:                     "W",
-					expectedScore:          8,
-					expectedSelectedParent: "T",
-					expectedBlues:          []string{"T"},
-				},
-				{
-					parents:                []string{"V", "W", "H"},
-					id:                     "X",
-					expectedScore:          9,
-					expectedSelectedParent: "W",
-					expectedBlues:          []string{"W"},
-				},
-			},
-		},
-		{
-			//Secret mining attack: The attacker is mining
-			//blocks B,C,D,E,F,G,T in secret without propagating
-			//them, so all blocks except T should be red, because
-			//they don't follow the rules of PHANTOM that require
-			//you to point to all the parents that you know, and
-			//propagate your block as soon as it's mined
-
-			//Block hash order:AYXWVUTSRQPONMLKJIHGFEDCB
-			k:              1,
-			virtualBlockID: "Y",
-			expectedReds:   []string{"B", "C", "D", "E", "F", "G", "L"},
-			dagData: []*testBlockData{
-				{
-					parents:                []string{"A"},
-					id:                     "B",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"B"},
-					id:                     "C",
-					expectedScore:          2,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"B"},
-				},
-				{
-					parents:                []string{"C"},
-					id:                     "D",
-					expectedScore:          3,
-					expectedSelectedParent: "C",
-					expectedBlues:          []string{"C"},
-				},
-				{
-					parents:                []string{"D"},
-					id:                     "E",
-					expectedScore:          4,
-					expectedSelectedParent: "D",
-					expectedBlues:          []string{"D"},
-				},
-				{
-					parents:                []string{"E"},
-					id:                     "F",
-					expectedScore:          5,
-					expectedSelectedParent: "E",
-					expectedBlues:          []string{"E"},
-				},
-				{
-					parents:                []string{"F"},
-					id:                     "G",
-					expectedScore:          6,
-					expectedSelectedParent: "F",
-					expectedBlues:          []string{"F"},
-				},
-				{
-					parents:                []string{"A"},
-					id:                     "H",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"A"},
-					id:                     "I",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"H", "I"},
-					id:                     "J",
-					expectedScore:          3,
-					expectedSelectedParent: "H",
-					expectedBlues:          []string{"I", "H"},
-				},
-				{
-					parents:                []string{"H", "I"},
-					id:                     "K",
-					expectedScore:          3,
-					expectedSelectedParent: "H",
-					expectedBlues:          []string{"I", "H"},
-				},
-				{
-					parents:                []string{"I"},
-					id:                     "L",
-					expectedScore:          2,
-					expectedSelectedParent: "I",
-					expectedBlues:          []string{"I"},
-				},
-				{
-					parents:                []string{"J", "K", "L"},
-					id:                     "M",
-					expectedScore:          5,
-					expectedSelectedParent: "J",
-					expectedBlues:          []string{"K", "J"},
-				},
-				{
-					parents:                []string{"J", "K", "L"},
-					id:                     "N",
-					expectedScore:          5,
-					expectedSelectedParent: "J",
-					expectedBlues:          []string{"K", "J"},
-				},
-				{
-					parents:                []string{"N", "M"},
-					id:                     "O",
-					expectedScore:          7,
-					expectedSelectedParent: "M",
-					expectedBlues:          []string{"N", "M"},
-				},
-				{
-					parents:                []string{"N", "M"},
-					id:                     "P",
-					expectedScore:          7,
-					expectedSelectedParent: "M",
-					expectedBlues:          []string{"N", "M"},
-				},
-				{
-					parents:                []string{"N", "M"},
-					id:                     "Q",
-					expectedScore:          7,
-					expectedSelectedParent: "M",
-					expectedBlues:          []string{"N", "M"},
-				},
-				{
-					parents:                []string{"O", "P", "Q"},
-					id:                     "R",
-					expectedScore:          10,
-					expectedSelectedParent: "O",
-					expectedBlues:          []string{"Q", "P", "O"},
-				},
-				{
-					parents:                []string{"O", "P", "Q"},
-					id:                     "S",
-					expectedScore:          10,
-					expectedSelectedParent: "O",
-					expectedBlues:          []string{"Q", "P", "O"},
-				},
-				{
-					parents:                []string{"G", "S", "R"},
-					id:                     "T",
-					expectedScore:          12,
-					expectedSelectedParent: "R",
-					expectedBlues:          []string{"S", "R"},
-				},
-				{
-					parents:                []string{"S", "R"},
-					id:                     "U",
-					expectedScore:          12,
-					expectedSelectedParent: "R",
-					expectedBlues:          []string{"S", "R"},
-				},
-				{
-					parents:                []string{"T", "U"},
-					id:                     "V",
-					expectedScore:          14,
-					expectedSelectedParent: "T",
-					expectedBlues:          []string{"U", "T"},
-				},
-				{
-					parents:                []string{"T", "U"},
-					id:                     "W",
-					expectedScore:          14,
-					expectedSelectedParent: "T",
-					expectedBlues:          []string{"U", "T"},
-				},
-				{
-					parents:                []string{"U", "T"},
-					id:                     "X",
-					expectedScore:          14,
-					expectedSelectedParent: "T",
-					expectedBlues:          []string{"U", "T"},
-				},
-				{
-					parents:                []string{"V", "W", "X"},
-					id:                     "Y",
-					expectedScore:          17,
-					expectedSelectedParent: "V",
-					expectedBlues:          []string{"X", "W", "V"},
-				},
-			},
-		},
-		{
-			//Censorship mining attack: The attacker is mining blocks B,C,D,E,F,G in secret without propagating them,
-			//so all blocks except B and C should be red, because they don't follow the rules of
-			//PHANTOM that require you to point to all the parents that you know
-
-			//Block hash order:AYXWVUTSRQPONMLKJIHGFEDCB
-			k:              1,
-			virtualBlockID: "Y",
-			expectedReds:   []string{"D", "E", "F", "G", "L"},
-			dagData: []*testBlockData{
-				{
-					parents:                []string{"A"},
-					id:                     "B",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"B"},
-					id:                     "C",
-					expectedScore:          2,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"B"},
-				},
-				{
-					parents:                []string{"C"},
-					id:                     "D",
-					expectedScore:          3,
-					expectedSelectedParent: "C",
-					expectedBlues:          []string{"C"},
-				},
-				{
-					parents:                []string{"D"},
-					id:                     "E",
-					expectedScore:          4,
-					expectedSelectedParent: "D",
-					expectedBlues:          []string{"D"},
-				},
-				{
-					parents:                []string{"E"},
-					id:                     "F",
-					expectedScore:          5,
-					expectedSelectedParent: "E",
-					expectedBlues:          []string{"E"},
-				},
-				{
-					parents:                []string{"F"},
-					id:                     "G",
-					expectedScore:          6,
-					expectedSelectedParent: "F",
-					expectedBlues:          []string{"F"},
-				},
-				{
-					parents:                []string{"A"},
-					id:                     "H",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"A"},
-					id:                     "I",
-					expectedScore:          1,
-					expectedSelectedParent: "A",
-					expectedBlues:          []string{"A"},
-				},
-				{
-					parents:                []string{"H", "I", "B"},
-					id:                     "J",
-					expectedScore:          4,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"I", "H", "B"},
-				},
-				{
-					parents:                []string{"H", "I", "B"},
-					id:                     "K",
-					expectedScore:          4,
-					expectedSelectedParent: "B",
-					expectedBlues:          []string{"I", "H", "B"},
-				},
-				{
-					parents:                []string{"I"},
-					id:                     "L",
-					expectedScore:          2,
-					expectedSelectedParent: "I",
-					expectedBlues:          []string{"I"},
-				},
-				{
-					parents:                []string{"J", "K", "L", "C"},
-					id:                     "M",
-					expectedScore:          7,
-					expectedSelectedParent: "J",
-					expectedBlues:          []string{"K", "C", "J"},
-				},
-				{
-					parents:                []string{"J", "K", "L", "C"},
-					id:                     "N",
-					expectedScore:          7,
-					expectedSelectedParent: "J",
-					expectedBlues:          []string{"K", "C", "J"},
-				},
-				{
-					parents:                []string{"N", "M", "D"},
-					id:                     "O",
-					expectedScore:          9,
-					expectedSelectedParent: "M",
-					expectedBlues:          []string{"N", "M"},
-				},
-				{
-					parents:                []string{"N", "M", "D"},
-					id:                     "P",
-					expectedScore:          9,
-					expectedSelectedParent: "M",
-					expectedBlues:          []string{"N", "M"},
-				},
-				{
-					parents:                []string{"N", "M", "D"},
-					id:                     "Q",
-					expectedScore:          9,
-					expectedSelectedParent: "M",
-					expectedBlues:          []string{"N", "M"},
-				},
-				{
-					parents:                []string{"O", "P", "Q", "E"},
-					id:                     "R",
-					expectedScore:          12,
-					expectedSelectedParent: "O",
-					expectedBlues:          []string{"Q", "P", "O"},
-				},
-				{
-					parents:                []string{"O", "P", "Q", "E"},
-					id:                     "S",
-					expectedScore:          12,
-					expectedSelectedParent: "O",
-					expectedBlues:          []string{"Q", "P", "O"},
-				},
-				{
-					parents:                []string{"G", "S", "R"},
-					id:                     "T",
-					expectedScore:          14,
-					expectedSelectedParent: "R",
-					expectedBlues:          []string{"S", "R"},
-				},
-				{
-					parents:                []string{"S", "R", "F"},
-					id:                     "U",
-					expectedScore:          14,
-					expectedSelectedParent: "R",
-					expectedBlues:          []string{"S", "R"},
-				},
-				{
-					parents:                []string{"T", "U"},
-					id:                     "V",
-					expectedScore:          16,
-					expectedSelectedParent: "T",
-					expectedBlues:          []string{"U", "T"},
-				},
-				{
-					parents:                []string{"T", "U"},
-					id:                     "W",
-					expectedScore:          16,
-					expectedSelectedParent: "T",
-					expectedBlues:          []string{"U", "T"},
-				},
-				{
-					parents:                []string{"T", "U"},
-					id:                     "X",
-					expectedScore:          16,
-					expectedSelectedParent: "T",
-					expectedBlues:          []string{"U", "T"},
-				},
-				{
-					parents:                []string{"V", "W", "X"},
-					id:                     "Y",
-					expectedScore:          19,
-					expectedSelectedParent: "V",
-					expectedBlues:          []string{"X", "W", "V"},
-				},
-			},
-		},
-	}
-
-	for i, test := range tests {
-		netParams.K = test.k
-		// Generate enough synthetic blocks for the rest of the test
-		blockDAG := newTestDAG(&netParams)
-		genesisNode := blockDAG.genesis
-		blockTime := genesisNode.Header().Timestamp
-		blockByIDMap := make(map[string]*blockNode)
-		idByBlockMap := make(map[*blockNode]string)
-		blockByIDMap["A"] = genesisNode
-		idByBlockMap[genesisNode] = "A"
-
-		for _, blockData := range test.dagData {
-			blockTime = blockTime.Add(time.Second)
-			parents := blockSet{}
-			for _, parentID := range blockData.parents {
-				parent := blockByIDMap[parentID]
-				parents.add(parent)
-			}
-			node := newTestNode(parents, blockVersion, 0, blockTime, test.k)
-			node.hash = &daghash.Hash{} //It helps to predict hash order
-			for i, char := range blockData.id {
-				node.hash[i] = byte(char)
-			}
-
-			blockDAG.index.AddNode(node)
-			addNodeAsChildToParents(node)
-
-			blockByIDMap[blockData.id] = node
-			idByBlockMap[node] = blockData.id
-
-			bluesIDs := make([]string, 0, len(node.blues))
-			for _, blue := range node.blues {
-				bluesIDs = append(bluesIDs, idByBlockMap[blue])
-			}
-			selectedParentID := idByBlockMap[node.selectedParent]
-			fullDataStr := fmt.Sprintf("blues: %v, selectedParent: %v, score: %v",
-				bluesIDs, selectedParentID, node.blueScore)
-			if blockData.expectedScore != node.blueScore {
-				t.Errorf("Test %d: Block %v expected to have score %v but got %v (fulldata: %v)",
-					i, blockData.id, blockData.expectedScore, node.blueScore, fullDataStr)
-			}
-			if blockData.expectedSelectedParent != selectedParentID {
-				t.Errorf("Test %d: Block %v expected to have selected parent %v but got %v (fulldata: %v)",
-					i, blockData.id, blockData.expectedSelectedParent, selectedParentID, fullDataStr)
-			}
-			if !reflect.DeepEqual(blockData.expectedBlues, bluesIDs) {
-				t.Errorf("Test %d: Block %v expected to have blues %v but got %v (fulldata: %v)",
-					i, blockData.id, blockData.expectedBlues, bluesIDs, fullDataStr)
-			}
-		}
-
-		reds := make(map[string]bool)
-
-		for id := range blockByIDMap {
-			reds[id] = true
-		}
-
-		for tip := blockByIDMap[test.virtualBlockID]; tip.selectedParent != nil; tip = tip.selectedParent {
-			tipID := idByBlockMap[tip]
-			delete(reds, tipID)
-			for _, blue := range tip.blues {
-				blueID := idByBlockMap[blue]
-				delete(reds, blueID)
-			}
-		}
-		if !checkReds(test.expectedReds, reds) {
-			redsIDs := make([]string, 0, len(reds))
-			for id := range reds {
-				redsIDs = append(redsIDs, id)
-			}
-			sort.Strings(redsIDs)
-			sort.Strings(test.expectedReds)
-			t.Errorf("Test %d: Expected reds %v but got %v", i, test.expectedReds, redsIDs)
-		}
-
-	}
-}
-
-func checkReds(expectedReds []string, reds map[string]bool) bool {
-	if len(expectedReds) != len(reds) {
-		return false
-	}
-	for _, redID := range expectedReds {
-		if !reds[redID] {
-			return false
-		}
-	}
-	return true
-}
--- a/blockdag/process.go
+++ b/blockdag/process.go
@@ -6,6 +6,8 @@ package blockdag

 import (
 	"fmt"
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/pkg/errors"
 	"time"

 	"github.com/kaspanet/kaspad/util"
@@ -43,15 +45,19 @@ const (
 	// in the block index but was never fully processed
 	BFWasStored

+	// BFDisallowDelay is set to indicate that a delayed block should be rejected.
+	// This is used for the case where a block is submitted through RPC.
+	BFDisallowDelay
+
 	// BFNone is a convenience value to specifically indicate no flags.
 	BFNone BehaviorFlags = 0
 )

-// BlockExists determines whether a block with the given hash exists in
+// IsInDAG determines whether a block with the given hash exists in
 // the DAG.
 //
 // This function is safe for concurrent access.
-func (dag *BlockDAG) BlockExists(hash *daghash.Hash) bool {
+func (dag *BlockDAG) IsInDAG(hash *daghash.Hash) bool {
 	return dag.index.HaveBlock(hash)
 }

@@ -94,7 +100,8 @@ func (dag *BlockDAG) processOrphans(hash *daghash.Hash, flags BehaviorFlags) err
 			// still missing.
 			_, err := lookupParentNodes(orphan.block, dag)
 			if err != nil {
-				if ruleErr, ok := err.(RuleError); ok && ruleErr.ErrorCode == ErrParentBlockUnknown {
+				var ruleErr RuleError
+				if ok := errors.As(err, &ruleErr); ok && ruleErr.ErrorCode == ErrParentBlockUnknown {
 					continue
 				}
 				return err
@@ -110,7 +117,7 @@ func (dag *BlockDAG) processOrphans(hash *daghash.Hash, flags BehaviorFlags) err
 			if err != nil {
 				// Since we don't want to reject the original block because of
 				// a bad unorphaned child, only return an error if it's not a RuleError.
-				if _, ok := err.(RuleError); !ok {
+				if !errors.As(err, &RuleError{}) {
 					return err
 				}
 				log.Warnf("Verification failed for orphan block %s: %s", orphanHash, err)
@@ -134,49 +141,79 @@ func (dag *BlockDAG) processOrphans(hash *daghash.Hash, flags BehaviorFlags) err
 // whether or not the block is an orphan.
 //
 // This function is safe for concurrent access.
-func (dag *BlockDAG) ProcessBlock(block *util.Block, flags BehaviorFlags) (isOrphan bool, delay time.Duration, err error) {
+func (dag *BlockDAG) ProcessBlock(block *util.Block, flags BehaviorFlags) (isOrphan bool, isDelayed bool, err error) {
 	dag.dagLock.Lock()
 	defer dag.dagLock.Unlock()
+	return dag.processBlockNoLock(block, flags)
+}

-	isDelayedBlock := flags&BFAfterDelay == BFAfterDelay
+func (dag *BlockDAG) processBlockNoLock(block *util.Block, flags BehaviorFlags) (isOrphan bool, isDelayed bool, err error) {
+	isAfterDelay := flags&BFAfterDelay == BFAfterDelay
 	wasBlockStored := flags&BFWasStored == BFWasStored
+	disallowDelay := flags&BFDisallowDelay == BFDisallowDelay

 	blockHash := block.Hash()
 	log.Tracef("Processing block %s", blockHash)

 	// The block must not already exist in the DAG.
-	if dag.BlockExists(blockHash) && !wasBlockStored {
+	if dag.IsInDAG(blockHash) && !wasBlockStored {
 		str := fmt.Sprintf("already have block %s", blockHash)
-		return false, 0, ruleError(ErrDuplicateBlock, str)
+		return false, false, ruleError(ErrDuplicateBlock, str)
 	}

 	// The block must not already exist as an orphan.
 	if _, exists := dag.orphans[*blockHash]; exists {
 		str := fmt.Sprintf("already have block (orphan) %s", blockHash)
-		return false, 0, ruleError(ErrDuplicateBlock, str)
+		return false, false, ruleError(ErrDuplicateBlock, str)
 	}

-	if !isDelayedBlock {
+	if dag.isKnownDelayedBlock(blockHash) {
+		str := fmt.Sprintf("already have block (delayed) %s", blockHash)
+		return false, false, ruleError(ErrDuplicateBlock, str)
+	}
+
+	if !isAfterDelay {
 		// Perform preliminary sanity checks on the block and its transactions.
 		delay, err := dag.checkBlockSanity(block, flags)
 		if err != nil {
-			return false, 0, err
+			return false, false, err
+		}
+
+		if delay != 0 && disallowDelay {
+			str := fmt.Sprintf("Cannot process blocks beyond the allowed time offset while the BFDisallowDelay flag is raised %s", blockHash)
+			return false, true, ruleError(ErrDelayedBlockIsNotAllowed, str)
 		}

 		if delay != 0 {
-			return false, delay, err
+			err = dag.addDelayedBlock(block, delay)
+			if err != nil {
+				return false, false, err
+			}
+			return false, true, nil
 		}
 	}

+	var missingParents []*daghash.Hash
+	for _, parentHash := range block.MsgBlock().Header.ParentHashes {
+		if !dag.IsInDAG(parentHash) {
+			missingParents = append(missingParents, parentHash)
+		}
+	}
+
+	// Handle the case of a block with a valid timestamp(non-delayed) which points to a delayed block.
+	delay, isParentDelayed := dag.maxDelayOfParents(missingParents)
+	if isParentDelayed {
+		// Add Nanosecond to ensure that parent process time will be after its child.
+		delay += time.Nanosecond
+		err := dag.addDelayedBlock(block, delay)
+		if err != nil {
+			return false, false, err
+		}
+		return false, true, err
+	}
+
 	// Handle orphan blocks.
-	allParentsExist := true
-	for _, parentHash := range block.MsgBlock().Header.ParentHashes {
-		if !dag.BlockExists(parentHash) {
-			allParentsExist = false
-		}
-	}
-
-	if !allParentsExist {
+	if len(missingParents) > 0 {
 		// Some orphans during netsync are a normal part of the process, since the anticone
 		// of the chain-split is never explicitly requested.
 		// Therefore, if we are during netsync - don't report orphans to default logs.
@@ -184,21 +221,21 @@ func (dag *BlockDAG) ProcessBlock(block *util.Block, flags BehaviorFlags) (isOrp
 		// The number K*2 was chosen since in peace times anticone is limited to K blocks,
 		// while some red block can make it a bit bigger, but much more than that indicates
 		// there might be some problem with the netsync process.
-		if flags&BFIsSync == BFIsSync && uint32(len(dag.orphans)) < dag.dagParams.K*2 {
+		if flags&BFIsSync == BFIsSync && dagconfig.KType(len(dag.orphans)) < dag.dagParams.K*2 {
 			log.Debugf("Adding orphan block %s. This is normal part of netsync process", blockHash)
 		} else {
 			log.Infof("Adding orphan block %s", blockHash)
 		}
 		dag.addOrphanBlock(block)

-		return true, 0, nil
+		return true, false, nil
 	}

 	// The block has passed all context independent checks and appears sane
 	// enough to potentially accept it into the block DAG.
 	err = dag.maybeAcceptBlock(block, flags)
 	if err != nil {
-		return false, 0, err
+		return false, false, err
 	}

 	// Accept any orphan blocks that depend on this block (they are
@@ -206,10 +243,33 @@ func (dag *BlockDAG) ProcessBlock(block *util.Block, flags BehaviorFlags) (isOrp
 	// there are no more.
 	err = dag.processOrphans(blockHash, flags)
 	if err != nil {
-		return false, 0, err
+		return false, false, err
+	}
+
+	if !isAfterDelay {
+		err = dag.processDelayedBlocks()
+		if err != nil {
+			return false, false, err
+		}
 	}

 	log.Debugf("Accepted block %s", blockHash)

-	return false, 0, nil
+	return false, false, nil
+}
+
+// maxDelayOfParents returns the maximum delay of the given block hashes.
+// Note that delay could be 0, but isDelayed will return true. This is the case where the parent process time is due.
+func (dag *BlockDAG) maxDelayOfParents(parentHashes []*daghash.Hash) (delay time.Duration, isDelayed bool) {
+	for _, parentHash := range parentHashes {
+		if delayedParent, exists := dag.delayedBlocks[*parentHash]; exists {
+			isDelayed = true
+			parentDelay := delayedParent.processTime.Sub(dag.AdjustedTime())
+			if parentDelay > delay {
+				delay = parentDelay
+			}
+		}
+	}
+
+	return delay, isDelayed
 }
--- a/blockdag/process_test.go
+++ b/blockdag/process_test.go
@@ -1,76 +1,18 @@
 package blockdag

 import (
-	"bou.ke/monkey"
-	"fmt"
-	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/daghash"
 	"path/filepath"
 	"testing"
 	"time"
+
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util/daghash"
 )

-func TestProcessBlock(t *testing.T) {
-	dag, teardownFunc, err := DAGSetup("TestProcessBlock", Config{
-		DAGParams: &dagconfig.SimNetParams,
-	})
-	if err != nil {
-		t.Errorf("Failed to setup dag instance: %v", err)
-		return
-	}
-	defer teardownFunc()
-
-	// Check that BFAfterDelay skip checkBlockSanity
-	called := false
-	guard := monkey.Patch((*BlockDAG).checkBlockSanity, func(_ *BlockDAG, _ *util.Block, _ BehaviorFlags) (time.Duration, error) {
-		called = true
-		return 0, nil
-	})
-	defer guard.Unpatch()
-
-	isOrphan, delay, err := dag.ProcessBlock(util.NewBlock(&Block100000), BFNoPoWCheck)
-	if err != nil {
-		t.Errorf("ProcessBlock: %s", err)
-	}
-	if delay != 0 {
-		t.Errorf("ProcessBlock: block is too far in the future")
-	}
-	if !isOrphan {
-		t.Errorf("ProcessBlock: unexpected returned non orphan block")
-	}
-	if !called {
-		t.Errorf("ProcessBlock: expected checkBlockSanity to be called")
-	}
-
-	Block100000Copy := Block100000
-	// Change nonce to change block hash
-	Block100000Copy.Header.Nonce++
-	called = false
-	isOrphan, delay, err = dag.ProcessBlock(util.NewBlock(&Block100000Copy), BFAfterDelay|BFNoPoWCheck)
-	if err != nil {
-		t.Errorf("ProcessBlock: %s", err)
-	}
-	if delay != 0 {
-		t.Errorf("ProcessBlock: block is too far in the future")
-	}
-	if !isOrphan {
-		t.Errorf("ProcessBlock: unexpected returned non orphan block")
-	}
-	if called {
-		t.Errorf("ProcessBlock: Didn't expected checkBlockSanity to be called")
-	}
-
-	isOrphan, delay, err = dag.ProcessBlock(util.NewBlock(dagconfig.SimNetParams.GenesisBlock), BFNone)
-	expectedErrMsg := fmt.Sprintf("already have block %s", dagconfig.SimNetParams.GenesisHash)
-	if err == nil || err.Error() != expectedErrMsg {
-		t.Errorf("ProcessBlock: Expected error \"%s\" but got \"%s\"", expectedErrMsg, err)
-	}
-}
-
 func TestProcessOrphans(t *testing.T) {
 	dag, teardownFunc, err := DAGSetup("TestProcessOrphans", Config{
-		DAGParams: &dagconfig.SimNetParams,
+		DAGParams: &dagconfig.SimnetParams,
 	})
 	if err != nil {
 		t.Errorf("Failed to setup dag instance: %v", err)
@@ -97,11 +39,11 @@ func TestProcessOrphans(t *testing.T) {
 	childBlock.MsgBlock().Header.UTXOCommitment = &daghash.ZeroHash

 	// Process the child block so that it gets added to the orphan pool
-	isOrphan, delay, err := dag.ProcessBlock(childBlock, BFNoPoWCheck)
+	isOrphan, isDelayed, err := dag.ProcessBlock(childBlock, BFNoPoWCheck)
 	if err != nil {
 		t.Fatalf("TestProcessOrphans: child block unexpectedly returned an error: %s", err)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("TestProcessOrphans: child block is too far in the future")
 	}
 	if !isOrphan {
@@ -109,11 +51,11 @@ func TestProcessOrphans(t *testing.T) {
 	}

 	// Process the parent block. Note that this will attempt to unorphan the child block
-	isOrphan, delay, err = dag.ProcessBlock(parentBlock, BFNone)
+	isOrphan, isDelayed, err = dag.ProcessBlock(parentBlock, BFNone)
 	if err != nil {
 		t.Fatalf("TestProcessOrphans: parent block unexpectedly returned an error: %s", err)
 	}
-	if delay != 0 {
+	if isDelayed {
 		t.Fatalf("TestProcessOrphans: parent block is too far in the future")
 	}
 	if isOrphan {
@@ -129,3 +71,168 @@ func TestProcessOrphans(t *testing.T) {
 		t.Fatalf("TestProcessOrphans: child block erroneously not marked as invalid")
 	}
 }
+
+type fakeTimeSource struct {
+	time time.Time
+}
+
+func (fts *fakeTimeSource) AdjustedTime() time.Time {
+	return fts.time
+}
+
+func (fts *fakeTimeSource) AddTimeSample(_ string, _ time.Time) {
+}
+
+func (fts *fakeTimeSource) Offset() time.Duration {
+	return 0
+}
+
+func TestProcessDelayedBlocks(t *testing.T) {
+	// We use dag1 so we can build the test blocks with the proper
+	// block header (UTXO commitment, acceptedIDMerkleroot, etc), and
+	// then we use dag2 for the actual test.
+	dag1, teardownFunc, err := DAGSetup("TestProcessDelayedBlocks1", Config{
+		DAGParams: &dagconfig.SimnetParams,
+	})
+	if err != nil {
+		t.Fatalf("Failed to setup DAG instance: %v", err)
+	}
+	defer teardownFunc()
+
+	initialTime := dag1.dagParams.GenesisBlock.Header.Timestamp
+	// Here we use a fake time source that returns a timestamp
+	// one hour into the future to make delayedBlock artificially
+	// valid.
+	dag1.timeSource = &fakeTimeSource{initialTime.Add(time.Hour)}
+
+	delayedBlock, err := PrepareBlockForTest(dag1, []*daghash.Hash{dag1.dagParams.GenesisBlock.BlockHash()}, nil)
+	if err != nil {
+		t.Fatalf("error in PrepareBlockForTest: %s", err)
+	}
+
+	blockDelay := time.Duration(dag1.dagParams.TimestampDeviationTolerance+5) * time.Second
+	delayedBlock.Header.Timestamp = initialTime.Add(blockDelay)
+
+	isOrphan, isDelayed, err := dag1.ProcessBlock(util.NewBlock(delayedBlock), BFNoPoWCheck)
+	if err != nil {
+		t.Fatalf("ProcessBlock returned unexpected error: %s\n", err)
+	}
+	if isOrphan {
+		t.Fatalf("ProcessBlock incorrectly returned delayedBlock " +
+			"is an orphan\n")
+	}
+	if isDelayed {
+		t.Fatalf("ProcessBlock incorrectly returned delayedBlock " +
+			"is delayed\n")
+	}
+
+	delayedBlockChild, err := PrepareBlockForTest(dag1, []*daghash.Hash{delayedBlock.BlockHash()}, nil)
+	if err != nil {
+		t.Fatalf("error in PrepareBlockForTest: %s", err)
+	}
+
+	// Here the actual test begins. We add a delayed block and
+	// its child and check that they are not added to the DAG,
+	// and check that they're added only if we add a new block
+	// after the delayed block timestamp is valid.
+	dag2, teardownFunc2, err := DAGSetup("TestProcessDelayedBlocks2", Config{
+		DAGParams: &dagconfig.SimnetParams,
+	})
+	if err != nil {
+		t.Fatalf("Failed to setup DAG instance: %v", err)
+	}
+	defer teardownFunc2()
+	dag2.timeSource = &fakeTimeSource{initialTime}
+
+	isOrphan, isDelayed, err = dag2.ProcessBlock(util.NewBlock(delayedBlock), BFNoPoWCheck)
+	if err != nil {
+		t.Fatalf("ProcessBlock returned unexpected error: %s\n", err)
+	}
+	if isOrphan {
+		t.Fatalf("ProcessBlock incorrectly returned delayedBlock " +
+			"is an orphan\n")
+	}
+	if !isDelayed {
+		t.Fatalf("ProcessBlock incorrectly returned delayedBlock " +
+			"is not delayed\n")
+	}
+
+	if dag2.IsInDAG(delayedBlock.BlockHash()) {
+		t.Errorf("dag.IsInDAG should return false for a delayed block")
+	}
+	if !dag2.IsKnownBlock(delayedBlock.BlockHash()) {
+		t.Errorf("dag.IsKnownBlock should return true for a a delayed block")
+	}
+
+	isOrphan, isDelayed, err = dag2.ProcessBlock(util.NewBlock(delayedBlockChild), BFNoPoWCheck)
+	if err != nil {
+		t.Fatalf("ProcessBlock returned unexpected error: %s\n", err)
+	}
+	if isOrphan {
+		t.Fatalf("ProcessBlock incorrectly returned delayedBlockChild " +
+			"is an orphan\n")
+	}
+	if !isDelayed {
+		t.Fatalf("ProcessBlock incorrectly returned delayedBlockChild " +
+			"is not delayed\n")
+	}
+
+	if dag2.IsInDAG(delayedBlockChild.BlockHash()) {
+		t.Errorf("dag.IsInDAG should return false for a child of a delayed block")
+	}
+	if !dag2.IsKnownBlock(delayedBlockChild.BlockHash()) {
+		t.Errorf("dag.IsKnownBlock should return true for a child of a delayed block")
+	}
+
+	blockBeforeDelay, err := PrepareBlockForTest(dag2, []*daghash.Hash{dag2.dagParams.GenesisBlock.BlockHash()}, nil)
+	if err != nil {
+		t.Fatalf("error in PrepareBlockForTest: %s", err)
+	}
+	isOrphan, isDelayed, err = dag2.ProcessBlock(util.NewBlock(blockBeforeDelay), BFNoPoWCheck)
+	if err != nil {
+		t.Fatalf("ProcessBlock returned unexpected error: %s\n", err)
+	}
+	if isOrphan {
+		t.Fatalf("ProcessBlock incorrectly returned blockBeforeDelay " +
+			"is an orphan\n")
+	}
+	if isDelayed {
+		t.Fatalf("ProcessBlock incorrectly returned blockBeforeDelay " +
+			"is delayed\n")
+	}
+
+	if dag2.IsInDAG(delayedBlock.BlockHash()) {
+		t.Errorf("delayedBlock shouldn't be added to the DAG because its time hasn't reached yet")
+	}
+	if dag2.IsInDAG(delayedBlockChild.BlockHash()) {
+		t.Errorf("delayedBlockChild shouldn't be added to the DAG because its parent is not in the DAG")
+	}
+
+	// We advance the clock to the point where delayedBlock timestamp is valid.
+	secondsUntilDelayedBlockIsValid := delayedBlock.Header.Timestamp.Unix() - int64(dag2.TimestampDeviationTolerance) - dag2.AdjustedTime().Unix() + 1
+	dag2.timeSource = &fakeTimeSource{initialTime.Add(time.Duration(secondsUntilDelayedBlockIsValid) * time.Second)}
+
+	blockAfterDelay, err := PrepareBlockForTest(dag2, []*daghash.Hash{dag2.dagParams.GenesisBlock.BlockHash()}, nil)
+	if err != nil {
+		t.Fatalf("error in PrepareBlockForTest: %s", err)
+	}
+	isOrphan, isDelayed, err = dag2.ProcessBlock(util.NewBlock(blockAfterDelay), BFNoPoWCheck)
+	if err != nil {
+		t.Fatalf("ProcessBlock returned unexpected error: %s\n", err)
+	}
+	if isOrphan {
+		t.Fatalf("ProcessBlock incorrectly returned blockBeforeDelay " +
+			"is an orphan\n")
+	}
+	if isDelayed {
+		t.Fatalf("ProcessBlock incorrectly returned blockBeforeDelay " +
+			"is not delayed\n")
+	}
+
+	if !dag2.IsInDAG(delayedBlock.BlockHash()) {
+		t.Fatalf("delayedBlock should be added to the DAG because its time has been reached")
+	}
+	if !dag2.IsInDAG(delayedBlockChild.BlockHash()) {
+		t.Errorf("delayedBlockChild shouldn't be added to the DAG because its parent has been added to the DAG")
+	}
+}
--- a/blockdag/reachability.go
+++ b/blockdag/reachability.go
@@ -0,0 +1,577 @@
+package blockdag
+
+import (
+	"fmt"
+	"github.com/pkg/errors"
+	"math"
+	"strings"
+	"time"
+)
+
+// reachabilityInterval represents an interval to be used within the
+// tree reachability algorithm. See reachabilityTreeNode for further
+// details.
+type reachabilityInterval struct {
+	start uint64
+	end   uint64
+}
+
+func newReachabilityInterval(start uint64, end uint64) *reachabilityInterval {
+	return &reachabilityInterval{start: start, end: end}
+}
+
+// size returns the size of this interval. Note that intervals are
+// inclusive from both sides.
+func (ri *reachabilityInterval) size() uint64 {
+	return ri.end - ri.start + 1
+}
+
+// splitInHalf splits this interval by a fraction of 0.5.
+// See splitFraction for further details.
+func (ri *reachabilityInterval) splitInHalf() (
+	left *reachabilityInterval, right *reachabilityInterval, err error) {
+
+	return ri.splitFraction(0.5)
+}
+
+// splitFraction splits this interval to two parts such that their
+// union is equal to the original interval and the first (left) part
+// contains the given fraction of the original interval's size.
+// Note: if the split results in fractional parts, this method rounds
+// the first part up and the last part down.
+func (ri *reachabilityInterval) splitFraction(fraction float64) (
+	left *reachabilityInterval, right *reachabilityInterval, err error) {
+
+	if fraction < 0 || fraction > 1 {
+		return nil, nil, errors.Errorf("fraction must be between 0 and 1")
+	}
+	if ri.size() == 0 {
+		return nil, nil, errors.Errorf("cannot split an empty interval")
+	}
+
+	allocationSize := uint64(math.Ceil(float64(ri.size()) * fraction))
+	left = newReachabilityInterval(ri.start, ri.start+allocationSize-1)
+	right = newReachabilityInterval(ri.start+allocationSize, ri.end)
+	return left, right, nil
+}
+
+// splitExact splits this interval to exactly |sizes| parts where
+// |part_i| = sizes[i]. This method expects sum(sizes) to be exactly
+// equal to the interval's size.
+func (ri *reachabilityInterval) splitExact(sizes []uint64) ([]*reachabilityInterval, error) {
+	sizesSum := uint64(0)
+	for _, size := range sizes {
+		sizesSum += size
+	}
+	if sizesSum != ri.size() {
+		return nil, errors.Errorf("sum of sizes must be equal to the interval's size")
+	}
+
+	intervals := make([]*reachabilityInterval, len(sizes))
+	start := ri.start
+	for i, size := range sizes {
+		intervals[i] = newReachabilityInterval(start, start+size-1)
+		start += size
+	}
+	return intervals, nil
+}
+
+// splitWithExponentialBias splits this interval to |sizes| parts
+// by the allocation rule described below. This method expects sum(sizes)
+// to be smaller or equal to the interval's size. Every part_i is
+// allocated at least sizes[i] capacity. The remaining budget is
+// split by an exponentially biased rule described below.
+//
+// This rule follows the GHOSTDAG protocol behavior where the child
+// with the largest subtree is expected to dominate the competition
+// for new blocks and thus grow the most. However, we may need to
+// add slack for non-largest subtrees in order to make CPU reindexing
+// attacks unworthy.
+func (ri *reachabilityInterval) splitWithExponentialBias(sizes []uint64) ([]*reachabilityInterval, error) {
+	intervalSize := ri.size()
+	sizesSum := uint64(0)
+	for _, size := range sizes {
+		sizesSum += size
+	}
+	if sizesSum > intervalSize {
+		return nil, errors.Errorf("sum of sizes must be less than or equal to the interval's size")
+	}
+	if sizesSum == intervalSize {
+		return ri.splitExact(sizes)
+	}
+
+	// Add a fractional bias to every size in the given sizes
+	totalBias := intervalSize - sizesSum
+	remainingBias := totalBias
+	biasedSizes := make([]uint64, len(sizes))
+	fractions := exponentialFractions(sizes)
+	for i, fraction := range fractions {
+		var bias uint64
+		if i == len(fractions)-1 {
+			bias = remainingBias
+		} else {
+			bias = uint64(math.Round(float64(totalBias) * fraction))
+			if bias > remainingBias {
+				bias = remainingBias
+			}
+		}
+		biasedSizes[i] = sizes[i] + bias
+		remainingBias -= bias
+	}
+	return ri.splitExact(biasedSizes)
+}
+
+// exponentialFractions returns a fraction of each size in sizes
+// as follows:
+//   fraction[i] = 2^size[i] / sum_j(2^size[j])
+// In the code below the above equation is divided by 2^max(size)
+// to avoid exploding numbers. Note that in 1 / 2^(max(size)-size[i])
+// we divide 1 by potentially a very large number, which will
+// result in loss of float precision. This is not a problem - all
+// numbers close to 0 bear effectively the same weight.
+func exponentialFractions(sizes []uint64) []float64 {
+	maxSize := uint64(0)
+	for _, size := range sizes {
+		if size > maxSize {
+			maxSize = size
+		}
+	}
+	fractions := make([]float64, len(sizes))
+	for i, size := range sizes {
+		fractions[i] = 1 / math.Pow(2, float64(maxSize-size))
+	}
+	fractionsSum := float64(0)
+	for _, fraction := range fractions {
+		fractionsSum += fraction
+	}
+	for i, fraction := range fractions {
+		fractions[i] = fraction / fractionsSum
+	}
+	return fractions
+}
+
+// isAncestorOf checks if this interval's node is a reachability tree
+// ancestor of the other interval's node. The condition below is relying on the
+// property of reachability intervals that intervals are either completely disjoint,
+// or one strictly contains the other.
+func (ri *reachabilityInterval) isAncestorOf(other *reachabilityInterval) bool {
+	return ri.start <= other.end && other.end <= ri.end
+}
+
+// String returns a string representation of the interval.
+func (ri *reachabilityInterval) String() string {
+	return fmt.Sprintf("[%d,%d]", ri.start, ri.end)
+}
+
+// reachabilityTreeNode represents a node in the reachability tree
+// of some DAG block. It mainly provides the ability to query *tree*
+// reachability with O(1) query time. It does so by managing an
+// index interval for each node and making sure all nodes in its
+// subtree are indexed within the interval, so the query
+// B ∈ subtree(A) simply becomes B.interval ⊂ A.interval.
+//
+// The main challenge of maintaining such intervals is that our tree
+// is an ever-growing tree and as such pre-allocated intervals may
+// not suffice as per future events. This is where the reindexing
+// algorithm below comes into place.
+// We use the reasonable assumption that the initial root interval
+// (e.g., [0, 2^64-1]) should always suffice for any practical use-
+// case, and so reindexing should always succeed unless more than
+// 2^64 blocks are added to the DAG/tree.
+type reachabilityTreeNode struct {
+	blockNode *blockNode
+
+	children []*reachabilityTreeNode
+	parent   *reachabilityTreeNode
+
+	// interval is the index interval containing all intervals of
+	// blocks in this node's subtree
+	interval *reachabilityInterval
+
+	// remainingInterval is the not-yet allocated interval (within
+	// this node's interval) awaiting new children
+	remainingInterval *reachabilityInterval
+}
+
+func newReachabilityTreeNode(blockNode *blockNode) *reachabilityTreeNode {
+	// Please see the comment above reachabilityTreeNode to understand why
+	// we use these initial values.
+	interval := newReachabilityInterval(1, math.MaxUint64-1)
+	// We subtract 1 from the end of the remaining interval to prevent the node from allocating
+	// the entire interval to its child, so its interval would *strictly* contain the interval of its child.
+	remainingInterval := newReachabilityInterval(interval.start, interval.end-1)
+	return &reachabilityTreeNode{blockNode: blockNode, interval: interval, remainingInterval: remainingInterval}
+}
+
+// addChild adds child to this tree node. If this node has no
+// remaining interval to allocate, a reindexing is triggered.
+// This method returns a list of reachabilityTreeNodes modified
+// by it.
+func (rtn *reachabilityTreeNode) addChild(child *reachabilityTreeNode) ([]*reachabilityTreeNode, error) {
+	// Set the parent-child relationship
+	rtn.children = append(rtn.children, child)
+	child.parent = rtn
+
+	// No allocation space left -- reindex
+	if rtn.remainingInterval.size() == 0 {
+		reindexStartTime := time.Now()
+		modifiedNodes, err := rtn.reindexIntervals()
+		if err != nil {
+			return nil, err
+		}
+		reindexTimeElapsed := time.Since(reindexStartTime)
+		log.Debugf("Reachability reindex triggered for "+
+			"block %s. Modified %d tree nodes and took %dms.",
+			rtn.blockNode.hash, len(modifiedNodes), reindexTimeElapsed.Milliseconds())
+		return modifiedNodes, nil
+	}
+
+	// Allocate from the remaining space
+	allocated, remaining, err := rtn.remainingInterval.splitInHalf()
+	if err != nil {
+		return nil, err
+	}
+	child.setInterval(allocated)
+	rtn.remainingInterval = remaining
+	return []*reachabilityTreeNode{rtn, child}, nil
+}
+
+// setInterval sets the reachability interval for this node.
+func (rtn *reachabilityTreeNode) setInterval(interval *reachabilityInterval) {
+	rtn.interval = interval
+
+	// Reserve a single interval index for the current node. This
+	// is necessary to ensure that ancestor intervals are strictly
+	// supersets of any descendant intervals and not equal
+	rtn.remainingInterval = newReachabilityInterval(interval.start, interval.end-1)
+}
+
+// reindexIntervals traverses the reachability subtree that's
+// defined by this node and reallocates reachability interval space
+// such that another reindexing is unlikely to occur shortly
+// thereafter. It does this by traversing down the reachability
+// tree until it finds a node with a subreeSize that's greater than
+// its interval size. See propagateInterval for further details.
+// This method returns a list of reachabilityTreeNodes modified by it.
+func (rtn *reachabilityTreeNode) reindexIntervals() ([]*reachabilityTreeNode, error) {
+	current := rtn
+
+	// Initial interval and subtree sizes
+	intervalSize := current.interval.size()
+	subTreeSizeMap := make(map[*reachabilityTreeNode]uint64)
+	current.countSubtrees(subTreeSizeMap)
+	currentSubtreeSize := subTreeSizeMap[current]
+
+	// Find the first ancestor that has sufficient interval space
+	for intervalSize < currentSubtreeSize {
+		if current.parent == nil {
+			// If we ended up here it means that there are more
+			// than 2^64 blocks, which shouldn't ever happen.
+			return nil, errors.Errorf("missing tree " +
+				"parent during reindexing. Theoretically, this " +
+				"should only ever happen if there are more " +
+				"than 2^64 blocks in the DAG.")
+		}
+		current = current.parent
+		intervalSize = current.interval.size()
+		current.countSubtrees(subTreeSizeMap)
+		currentSubtreeSize = subTreeSizeMap[current]
+	}
+
+	// Propagate the interval to the subtree
+	return current.propagateInterval(subTreeSizeMap)
+}
+
+// countSubtrees counts the size of each subtree under this node,
+// and populates the provided subTreeSizeMap with the results.
+// It is equivalent to the following recursive implementation:
+//
+// func (rtn *reachabilityTreeNode) countSubtrees() uint64 {
+//     subtreeSize := uint64(0)
+//     for _, child := range rtn.children {
+//         subtreeSize += child.countSubtrees()
+//     }
+//     return subtreeSize + 1
+// }
+//
+// However, we are expecting (linearly) deep trees, and so a
+// recursive stack-based approach is inefficient and will hit
+// recursion limits. Instead, the same logic was implemented
+// using a (queue-based) BFS method. At a high level, the
+// algorithm uses BFS for reaching all leaves and pushes
+// intermediate updates from leaves via parent chains until all
+// size information is gathered at the root of the operation
+// (i.e. at rtn).
+func (rtn *reachabilityTreeNode) countSubtrees(subTreeSizeMap map[*reachabilityTreeNode]uint64) {
+	queue := []*reachabilityTreeNode{rtn}
+	calculatedChildrenCount := make(map[*reachabilityTreeNode]uint64)
+	for len(queue) > 0 {
+		var current *reachabilityTreeNode
+		current, queue = queue[0], queue[1:]
+		if len(current.children) == 0 {
+			// We reached a leaf
+			subTreeSizeMap[current] = 1
+		} else if calculatedChildrenCount[current] <= uint64(len(current.children)) {
+			// We haven't yet calculated the subtree size of
+			// the current node. Add all its children to the
+			// queue
+			queue = append(queue, current.children...)
+			continue
+		}
+
+		// We reached a leaf or a pre-calculated subtree.
+		// Push information up
+		for current != rtn {
+			current = current.parent
+			calculatedChildrenCount[current]++
+			if calculatedChildrenCount[current] != uint64(len(current.children)) {
+				// Not all subtrees of the current node are ready
+				break
+			}
+			// All children of `current` have calculated their subtree size.
+			// Sum them all together and add 1 to get the sub tree size of
+			// `current`.
+			childSubtreeSizeSum := uint64(0)
+			for _, child := range current.children {
+				childSubtreeSizeSum += subTreeSizeMap[child]
+			}
+			subTreeSizeMap[current] = childSubtreeSizeSum + 1
+		}
+	}
+}
+
+// propagateInterval propagates the new interval using a BFS traversal.
+// Subtree intervals are recursively allocated according to subtree sizes and
+// the allocation rule in splitWithExponentialBias. This method returns
+// a list of reachabilityTreeNodes modified by it.
+func (rtn *reachabilityTreeNode) propagateInterval(subTreeSizeMap map[*reachabilityTreeNode]uint64) ([]*reachabilityTreeNode, error) {
+	// We set the interval to reset its remainingInterval, so we could reallocate it while reindexing.
+	rtn.setInterval(rtn.interval)
+	queue := []*reachabilityTreeNode{rtn}
+	var modifiedNodes []*reachabilityTreeNode
+	for len(queue) > 0 {
+		var current *reachabilityTreeNode
+		current, queue = queue[0], queue[1:]
+		if len(current.children) > 0 {
+			sizes := make([]uint64, len(current.children))
+			for i, child := range current.children {
+				sizes[i] = subTreeSizeMap[child]
+			}
+			intervals, err := current.remainingInterval.splitWithExponentialBias(sizes)
+			if err != nil {
+				return nil, err
+			}
+			for i, child := range current.children {
+				childInterval := intervals[i]
+				child.setInterval(childInterval)
+				queue = append(queue, child)
+			}
+
+			// Empty up remaining interval
+			current.remainingInterval.start = current.remainingInterval.end + 1
+		}
+
+		modifiedNodes = append(modifiedNodes, current)
+	}
+	return modifiedNodes, nil
+}
+
+// isAncestorOf checks if this node is a reachability tree ancestor
+// of the other node.
+func (rtn *reachabilityTreeNode) isAncestorOf(other *reachabilityTreeNode) bool {
+	return rtn.interval.isAncestorOf(other.interval)
+}
+
+// String returns a string representation of a reachability tree node
+// and its children.
+func (rtn *reachabilityTreeNode) String() string {
+	queue := []*reachabilityTreeNode{rtn}
+	lines := []string{rtn.interval.String()}
+	for len(queue) > 0 {
+		var current *reachabilityTreeNode
+		current, queue = queue[0], queue[1:]
+		if len(current.children) == 0 {
+			continue
+		}
+
+		line := ""
+		for _, child := range current.children {
+			line += child.interval.String()
+			queue = append(queue, child)
+		}
+		lines = append([]string{line}, lines...)
+	}
+	return strings.Join(lines, "\n")
+}
+
+// futureCoveringBlockSet represents a collection of blocks in the future of
+// a certain block. Once a block B is added to the DAG, every block A_i in
+// B's selected parent anticone must register B in its futureCoveringBlockSet. This allows
+// to relatively quickly (O(log(|futureCoveringBlockSet|))) query whether B
+// is a descendent (is in the "future") of any block that previously
+// registered it.
+//
+// Note that futureCoveringBlockSet is meant to be queried only if B is not
+// a reachability tree descendant of the block in question, as reachability
+// tree queries are always O(1).
+//
+// See insertBlock, isInFuture, and dag.isAncestorOf for further details.
+type futureCoveringBlockSet []*futureCoveringBlock
+
+// futureCoveringBlock represents a block in the future of some other block.
+type futureCoveringBlock struct {
+	blockNode *blockNode
+	treeNode  *reachabilityTreeNode
+}
+
+// insertBlock inserts the given block into this futureCoveringBlockSet
+// while keeping futureCoveringBlockSet ordered by interval.
+// If a block B ∈ futureCoveringBlockSet exists such that its interval
+// contains block's interval, block need not be added. If block's
+// interval contains B's interval, it replaces it.
+//
+// Notes:
+// * Intervals never intersect unless one contains the other
+//   (this follows from the tree structure and the indexing rule).
+// * Since futureCoveringBlockSet is kept ordered, a binary search can be
+//   used for insertion/queries.
+// * Although reindexing may change a block's interval, the
+//   is-superset relation will by definition
+//   be always preserved.
+func (fb *futureCoveringBlockSet) insertBlock(block *futureCoveringBlock) {
+	blockInterval := block.treeNode.interval
+	i := fb.findIndex(block)
+	if i > 0 {
+		candidate := (*fb)[i-1]
+		candidateInterval := candidate.treeNode.interval
+		if candidateInterval.isAncestorOf(blockInterval) {
+			// candidate is an ancestor of block, no need to insert
+			return
+		}
+		if blockInterval.isAncestorOf(candidateInterval) {
+			// block is an ancestor of candidate, and can thus replace it
+			(*fb)[i-1] = block
+			return
+		}
+	}
+
+	// Insert block in the correct index to maintain futureCoveringBlockSet as
+	// a sorted-by-interval list.
+	// Note that i might be equal to len(futureCoveringBlockSet)
+	left := (*fb)[:i]
+	right := append([]*futureCoveringBlock{block}, (*fb)[i:]...)
+	*fb = append(left, right...)
+}
+
+// isInFuture resolves whether the given block is in the subtree of
+// any block in this futureCoveringBlockSet.
+// See insertBlock method for the complementary insertion behavior.
+//
+// Like the insert method, this method also relies on the fact that
+// futureCoveringBlockSet is kept ordered by interval to efficiently perform a
+// binary search over futureCoveringBlockSet and answer the query in
+// O(log(|futureCoveringBlockSet|)).
+func (fb futureCoveringBlockSet) isInFuture(block *futureCoveringBlock) bool {
+	i := fb.findIndex(block)
+	if i == 0 {
+		// No candidate to contain block
+		return false
+	}
+
+	candidate := fb[i-1]
+	return candidate.treeNode.isAncestorOf(block.treeNode)
+}
+
+// findIndex finds the index of the block with the maximum start that is below
+// the given block.
+func (fb futureCoveringBlockSet) findIndex(block *futureCoveringBlock) int {
+	blockInterval := block.treeNode.interval
+	end := blockInterval.end
+
+	low := 0
+	high := len(fb)
+	for low < high {
+		middle := (low + high) / 2
+		middleInterval := fb[middle].treeNode.interval
+		if end < middleInterval.start {
+			high = middle
+		} else {
+			low = middle + 1
+		}
+	}
+	return low
+}
+
+// String returns a string representation of the intervals in this futureCoveringBlockSet.
+func (fb futureCoveringBlockSet) String() string {
+	intervalsString := ""
+	for _, block := range fb {
+		intervalsString += block.treeNode.interval.String()
+	}
+	return intervalsString
+}
+
+func (dag *BlockDAG) updateReachability(node *blockNode, selectedParentAnticone []*blockNode) error {
+	// Allocate a new reachability tree node
+	newTreeNode := newReachabilityTreeNode(node)
+
+	// If this is the genesis node, simply initialize it and return
+	if node.isGenesis() {
+		dag.reachabilityStore.setTreeNode(newTreeNode)
+		return nil
+	}
+
+	// Insert the node into the selected parent's reachability tree
+	selectedParentTreeNode, err := dag.reachabilityStore.treeNodeByBlockNode(node.selectedParent)
+	if err != nil {
+		return err
+	}
+	modifiedTreeNodes, err := selectedParentTreeNode.addChild(newTreeNode)
+	if err != nil {
+		return err
+	}
+	for _, modifiedTreeNode := range modifiedTreeNodes {
+		dag.reachabilityStore.setTreeNode(modifiedTreeNode)
+	}
+
+	// Add the block to the futureCoveringSets of all the blocks
+	// in the selected parent's anticone
+	for _, current := range selectedParentAnticone {
+		currentFutureCoveringSet, err := dag.reachabilityStore.futureCoveringSetByBlockNode(current)
+		if err != nil {
+			return err
+		}
+		currentFutureCoveringSet.insertBlock(&futureCoveringBlock{blockNode: node, treeNode: newTreeNode})
+		err = dag.reachabilityStore.setFutureCoveringSet(current, currentFutureCoveringSet)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// isAncestorOf returns true if this node is in the past of the other node
+// in the DAG. The complexity of this method is O(log(|this.futureCoveringBlockSet|))
+func (dag *BlockDAG) isAncestorOf(this *blockNode, other *blockNode) (bool, error) {
+	// First, check if this node is a reachability tree ancestor of the
+	// other node
+	thisTreeNode, err := dag.reachabilityStore.treeNodeByBlockNode(this)
+	if err != nil {
+		return false, err
+	}
+	otherTreeNode, err := dag.reachabilityStore.treeNodeByBlockNode(other)
+	if err != nil {
+		return false, err
+	}
+	if thisTreeNode.isAncestorOf(otherTreeNode) {
+		return true, nil
+	}
+
+	// Otherwise, use previously registered future blocks to complete the
+	// reachability test
+	thisFutureCoveringSet, err := dag.reachabilityStore.futureCoveringSetByBlockNode(this)
+	if err != nil {
+		return false, err
+	}
+	return thisFutureCoveringSet.isInFuture(&futureCoveringBlock{blockNode: other, treeNode: otherTreeNode}), nil
+}
--- a/blockdag/reachability_test.go
+++ b/blockdag/reachability_test.go
@@ -0,0 +1,648 @@
+package blockdag
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestAddChild(t *testing.T) {
+	// Scenario 1: test addChild in a chain
+	//             root -> a -> b -> c...
+	// Create the root node of a new reachability tree
+	root := newReachabilityTreeNode(&blockNode{})
+	root.setInterval(newReachabilityInterval(1, 100))
+
+	// Add a chain of child nodes just before a reindex occurs (2^6=64 < 100)
+	currentTip := root
+	for i := 0; i < 6; i++ {
+		node := newReachabilityTreeNode(&blockNode{})
+		modifiedNodes, err := currentTip.addChild(node)
+		if err != nil {
+			t.Fatalf("TestAddChild: addChild failed: %s", err)
+		}
+
+		// Expect only the node and its parent to be affected
+		expectedModifiedNodes := []*reachabilityTreeNode{currentTip, node}
+		if !reflect.DeepEqual(modifiedNodes, expectedModifiedNodes) {
+			t.Fatalf("TestAddChild: unexpected modifiedNodes. "+
+				"want: %s, got: %s", expectedModifiedNodes, modifiedNodes)
+		}
+
+		currentTip = node
+	}
+
+	// Add another node to the tip of the chain to trigger a reindex (100 < 2^7=128)
+	lastChild := newReachabilityTreeNode(&blockNode{})
+	modifiedNodes, err := currentTip.addChild(lastChild)
+	if err != nil {
+		t.Fatalf("TestAddChild: addChild failed: %s", err)
+	}
+
+	// Expect more than just the node and its parent to be modified but not
+	// all the nodes
+	if len(modifiedNodes) <= 2 && len(modifiedNodes) >= 7 {
+		t.Fatalf("TestAddChild: unexpected amount of modifiedNodes.")
+	}
+
+	// Expect the tip to have an interval of 1 and remaining interval of 0
+	tipInterval := lastChild.interval.size()
+	if tipInterval != 1 {
+		t.Fatalf("TestAddChild: unexpected tip interval size: want: 1, got: %d", tipInterval)
+	}
+	tipRemainingInterval := lastChild.remainingInterval.size()
+	if tipRemainingInterval != 0 {
+		t.Fatalf("TestAddChild: unexpected tip interval size: want: 0, got: %d", tipRemainingInterval)
+	}
+
+	// Expect all nodes to be descendant nodes of root
+	currentNode := currentTip
+	for currentNode != nil {
+		if !root.isAncestorOf(currentNode) {
+			t.Fatalf("TestAddChild: currentNode is not a descendant of root")
+		}
+		currentNode = currentNode.parent
+	}
+
+	// Scenario 2: test addChild where all nodes are direct descendants of root
+	//             root -> a, b, c...
+	// Create the root node of a new reachability tree
+	root = newReachabilityTreeNode(&blockNode{})
+	root.setInterval(newReachabilityInterval(1, 100))
+
+	// Add child nodes to root just before a reindex occurs (2^6=64 < 100)
+	childNodes := make([]*reachabilityTreeNode, 6)
+	for i := 0; i < len(childNodes); i++ {
+		childNodes[i] = newReachabilityTreeNode(&blockNode{})
+		modifiedNodes, err := root.addChild(childNodes[i])
+		if err != nil {
+			t.Fatalf("TestAddChild: addChild failed: %s", err)
+		}
+
+		// Expect only the node and the root to be affected
+		expectedModifiedNodes := []*reachabilityTreeNode{root, childNodes[i]}
+		if !reflect.DeepEqual(modifiedNodes, expectedModifiedNodes) {
+			t.Fatalf("TestAddChild: unexpected modifiedNodes. "+
+				"want: %s, got: %s", expectedModifiedNodes, modifiedNodes)
+		}
+	}
+
+	// Add another node to the root to trigger a reindex (100 < 2^7=128)
+	lastChild = newReachabilityTreeNode(&blockNode{})
+	modifiedNodes, err = root.addChild(lastChild)
+	if err != nil {
+		t.Fatalf("TestAddChild: addChild failed: %s", err)
+	}
+
+	// Expect more than just the node and the root to be modified but not
+	// all the nodes
+	if len(modifiedNodes) <= 2 && len(modifiedNodes) >= 7 {
+		t.Fatalf("TestAddChild: unexpected amount of modifiedNodes.")
+	}
+
+	// Expect the last-added child to have an interval of 1 and remaining interval of 0
+	lastChildInterval := lastChild.interval.size()
+	if lastChildInterval != 1 {
+		t.Fatalf("TestAddChild: unexpected lastChild interval size: want: 1, got: %d", lastChildInterval)
+	}
+	lastChildRemainingInterval := lastChild.remainingInterval.size()
+	if lastChildRemainingInterval != 0 {
+		t.Fatalf("TestAddChild: unexpected lastChild interval size: want: 0, got: %d", lastChildRemainingInterval)
+	}
+
+	// Expect all nodes to be descendant nodes of root
+	for _, childNode := range childNodes {
+		if !root.isAncestorOf(childNode) {
+			t.Fatalf("TestAddChild: childNode is not a descendant of root")
+		}
+	}
+}
+
+func TestSplitFraction(t *testing.T) {
+	tests := []struct {
+		interval      *reachabilityInterval
+		fraction      float64
+		expectedLeft  *reachabilityInterval
+		expectedRight *reachabilityInterval
+	}{
+		{
+			interval:      newReachabilityInterval(1, 100),
+			fraction:      0.5,
+			expectedLeft:  newReachabilityInterval(1, 50),
+			expectedRight: newReachabilityInterval(51, 100),
+		},
+		{
+			interval:      newReachabilityInterval(2, 100),
+			fraction:      0.5,
+			expectedLeft:  newReachabilityInterval(2, 51),
+			expectedRight: newReachabilityInterval(52, 100),
+		},
+		{
+			interval:      newReachabilityInterval(1, 99),
+			fraction:      0.5,
+			expectedLeft:  newReachabilityInterval(1, 50),
+			expectedRight: newReachabilityInterval(51, 99),
+		},
+		{
+			interval:      newReachabilityInterval(1, 100),
+			fraction:      0.2,
+			expectedLeft:  newReachabilityInterval(1, 20),
+			expectedRight: newReachabilityInterval(21, 100),
+		},
+		{
+			interval:      newReachabilityInterval(1, 100),
+			fraction:      0,
+			expectedLeft:  newReachabilityInterval(1, 0),
+			expectedRight: newReachabilityInterval(1, 100),
+		},
+		{
+			interval:      newReachabilityInterval(1, 100),
+			fraction:      1,
+			expectedLeft:  newReachabilityInterval(1, 100),
+			expectedRight: newReachabilityInterval(101, 100),
+		},
+	}
+
+	for i, test := range tests {
+		left, right, err := test.interval.splitFraction(test.fraction)
+		if err != nil {
+			t.Fatalf("TestSplitFraction: splitFraction unexpectedly failed in test #%d: %s", i, err)
+		}
+		if !reflect.DeepEqual(left, test.expectedLeft) {
+			t.Errorf("TestSplitFraction: unexpected left in test #%d. "+
+				"want: %s, got: %s", i, test.expectedLeft, left)
+		}
+		if !reflect.DeepEqual(right, test.expectedRight) {
+			t.Errorf("TestSplitFraction: unexpected right in test #%d. "+
+				"want: %s, got: %s", i, test.expectedRight, right)
+		}
+	}
+}
+
+func TestSplitExact(t *testing.T) {
+	tests := []struct {
+		interval          *reachabilityInterval
+		sizes             []uint64
+		expectedIntervals []*reachabilityInterval
+	}{
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{100},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{50, 50},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 50),
+				newReachabilityInterval(51, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{10, 20, 30, 40},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 10),
+				newReachabilityInterval(11, 30),
+				newReachabilityInterval(31, 60),
+				newReachabilityInterval(61, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{0, 100},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 0),
+				newReachabilityInterval(1, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{100, 0},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 100),
+				newReachabilityInterval(101, 100),
+			},
+		},
+	}
+
+	for i, test := range tests {
+		intervals, err := test.interval.splitExact(test.sizes)
+		if err != nil {
+			t.Fatalf("TestSplitExact: splitExact unexpectedly failed in test #%d: %s", i, err)
+		}
+		if !reflect.DeepEqual(intervals, test.expectedIntervals) {
+			t.Errorf("TestSplitExact: unexpected intervals in test #%d. "+
+				"want: %s, got: %s", i, test.expectedIntervals, intervals)
+		}
+	}
+}
+
+func TestSplitWithExponentialBias(t *testing.T) {
+	tests := []struct {
+		interval          *reachabilityInterval
+		sizes             []uint64
+		expectedIntervals []*reachabilityInterval
+	}{
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{100},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{50, 50},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 50),
+				newReachabilityInterval(51, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{10, 20, 30, 40},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 10),
+				newReachabilityInterval(11, 30),
+				newReachabilityInterval(31, 60),
+				newReachabilityInterval(61, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{25, 25},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 50),
+				newReachabilityInterval(51, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{1, 1},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 50),
+				newReachabilityInterval(51, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{33, 33, 33},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 33),
+				newReachabilityInterval(34, 66),
+				newReachabilityInterval(67, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{10, 15, 25},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 10),
+				newReachabilityInterval(11, 25),
+				newReachabilityInterval(26, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100),
+			sizes:    []uint64{25, 15, 10},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 75),
+				newReachabilityInterval(76, 90),
+				newReachabilityInterval(91, 100),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 10_000),
+			sizes:    []uint64{10, 10, 20},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 20),
+				newReachabilityInterval(21, 40),
+				newReachabilityInterval(41, 10_000),
+			},
+		},
+		{
+			interval: newReachabilityInterval(1, 100_000),
+			sizes:    []uint64{31_000, 31_000, 30_001},
+			expectedIntervals: []*reachabilityInterval{
+				newReachabilityInterval(1, 35_000),
+				newReachabilityInterval(35_001, 69_999),
+				newReachabilityInterval(70_000, 100_000),
+			},
+		},
+	}
+
+	for i, test := range tests {
+		intervals, err := test.interval.splitWithExponentialBias(test.sizes)
+		if err != nil {
+			t.Fatalf("TestSplitWithExponentialBias: splitWithExponentialBias unexpectedly failed in test #%d: %s", i, err)
+		}
+		if !reflect.DeepEqual(intervals, test.expectedIntervals) {
+			t.Errorf("TestSplitWithExponentialBias: unexpected intervals in test #%d. "+
+				"want: %s, got: %s", i, test.expectedIntervals, intervals)
+		}
+	}
+}
+
+func TestIsInFuture(t *testing.T) {
+	blocks := futureCoveringBlockSet{
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(2, 3)}},
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 77)}},
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
+	}
+
+	tests := []struct {
+		block          *futureCoveringBlock
+		expectedResult bool
+	}{
+		{
+			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 1)}},
+			expectedResult: false,
+		},
+		{
+			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(5, 7)}},
+			expectedResult: true,
+		},
+		{
+			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 76)}},
+			expectedResult: true,
+		},
+		{
+			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(78, 100)}},
+			expectedResult: false,
+		},
+		{
+			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1980, 2000)}},
+			expectedResult: false,
+		},
+		{
+			block:          &futureCoveringBlock{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1920)}},
+			expectedResult: true,
+		},
+	}
+
+	for i, test := range tests {
+		result := blocks.isInFuture(test.block)
+		if result != test.expectedResult {
+			t.Errorf("TestIsInFuture: unexpected result in test #%d. Want: %t, got: %t",
+				i, test.expectedResult, result)
+		}
+	}
+}
+
+func TestInsertBlock(t *testing.T) {
+	blocks := futureCoveringBlockSet{
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 3)}},
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 77)}},
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
+		{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
+	}
+
+	tests := []struct {
+		toInsert       []*futureCoveringBlock
+		expectedResult futureCoveringBlockSet
+	}{
+		{
+			toInsert: []*futureCoveringBlock{
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(5, 7)}},
+			},
+			expectedResult: futureCoveringBlockSet{
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 3)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 77)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
+			},
+		},
+		{
+			toInsert: []*futureCoveringBlock{
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(65, 78)}},
+			},
+			expectedResult: futureCoveringBlockSet{
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 3)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(65, 78)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
+			},
+		},
+		{
+			toInsert: []*futureCoveringBlock{
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(88, 97)}},
+			},
+			expectedResult: futureCoveringBlockSet{
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 3)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 77)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(88, 97)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
+			},
+		},
+		{
+			toInsert: []*futureCoveringBlock{
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(88, 97)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(3000, 3010)}},
+			},
+			expectedResult: futureCoveringBlockSet{
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1, 3)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(4, 67)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(67, 77)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(88, 97)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(657, 789)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1000, 1000)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(1920, 1921)}},
+				{treeNode: &reachabilityTreeNode{interval: newReachabilityInterval(3000, 3010)}},
+			},
+		},
+	}
+
+	for i, test := range tests {
+		// Create a clone of blocks so that we have a clean start for every test
+		blocksClone := make(futureCoveringBlockSet, len(blocks))
+		for i, block := range blocks {
+			blocksClone[i] = block
+		}
+
+		for _, block := range test.toInsert {
+			blocksClone.insertBlock(block)
+		}
+		if !reflect.DeepEqual(blocksClone, test.expectedResult) {
+			t.Errorf("TestInsertBlock: unexpected result in test #%d. Want: %s, got: %s",
+				i, test.expectedResult, blocksClone)
+		}
+	}
+}
+
+func TestSplitFractionErrors(t *testing.T) {
+	interval := newReachabilityInterval(100, 200)
+
+	// Negative fraction
+	_, _, err := interval.splitFraction(-0.5)
+	if err == nil {
+		t.Fatalf("TestSplitFractionErrors: splitFraction unexpectedly " +
+			"didn't return an error for a negative fraction")
+	}
+	expectedErrSubstring := "fraction must be between 0 and 1"
+	if !strings.Contains(err.Error(), expectedErrSubstring) {
+		t.Fatalf("TestSplitFractionErrors: splitFraction returned wrong error "+
+			"for a negative fraction. "+
+			"Want: %s, got: %s", expectedErrSubstring, err)
+	}
+
+	// Fraction > 1
+	_, _, err = interval.splitFraction(1.5)
+	if err == nil {
+		t.Fatalf("TestSplitFractionErrors: splitFraction unexpectedly " +
+			"didn't return an error for a fraction greater than 1")
+	}
+	expectedErrSubstring = "fraction must be between 0 and 1"
+	if !strings.Contains(err.Error(), expectedErrSubstring) {
+		t.Fatalf("TestSplitFractionErrors: splitFraction returned wrong error "+
+			"for a fraction greater than 1. "+
+			"Want: %s, got: %s", expectedErrSubstring, err)
+	}
+
+	// Splitting an empty interval
+	emptyInterval := newReachabilityInterval(1, 0)
+	_, _, err = emptyInterval.splitFraction(0.5)
+	if err == nil {
+		t.Fatalf("TestSplitFractionErrors: splitFraction unexpectedly " +
+			"didn't return an error for an empty interval")
+	}
+	expectedErrSubstring = "cannot split an empty interval"
+	if !strings.Contains(err.Error(), expectedErrSubstring) {
+		t.Fatalf("TestSplitFractionErrors: splitFraction returned wrong error "+
+			"for an empty interval. "+
+			"Want: %s, got: %s", expectedErrSubstring, err)
+	}
+}
+
+func TestSplitExactErrors(t *testing.T) {
+	interval := newReachabilityInterval(100, 199)
+
+	// Sum of sizes greater than the size of the interval
+	sizes := []uint64{50, 51}
+	_, err := interval.splitExact(sizes)
+	if err == nil {
+		t.Fatalf("TestSplitExactErrors: splitExact unexpectedly " +
+			"didn't return an error for (sum of sizes) > (size of interval)")
+	}
+	expectedErrSubstring := "sum of sizes must be equal to the interval's size"
+	if !strings.Contains(err.Error(), expectedErrSubstring) {
+		t.Fatalf("TestSplitExactErrors: splitExact returned wrong error "+
+			"for (sum of sizes) > (size of interval). "+
+			"Want: %s, got: %s", expectedErrSubstring, err)
+	}
+
+	// Sum of sizes smaller than the size of the interval
+	sizes = []uint64{50, 49}
+	_, err = interval.splitExact(sizes)
+	if err == nil {
+		t.Fatalf("TestSplitExactErrors: splitExact unexpectedly " +
+			"didn't return an error for (sum of sizes) < (size of interval)")
+	}
+	expectedErrSubstring = "sum of sizes must be equal to the interval's size"
+	if !strings.Contains(err.Error(), expectedErrSubstring) {
+		t.Fatalf("TestSplitExactErrors: splitExact returned wrong error "+
+			"for (sum of sizes) < (size of interval). "+
+			"Want: %s, got: %s", expectedErrSubstring, err)
+	}
+}
+
+func TestSplitWithExponentialBiasErrors(t *testing.T) {
+	interval := newReachabilityInterval(100, 199)
+
+	// Sum of sizes greater than the size of the interval
+	sizes := []uint64{50, 51}
+	_, err := interval.splitWithExponentialBias(sizes)
+	if err == nil {
+		t.Fatalf("TestSplitWithExponentialBiasErrors: splitWithExponentialBias " +
+			"unexpectedly didn't return an error")
+	}
+	expectedErrSubstring := "sum of sizes must be less than or equal to the interval's size"
+	if !strings.Contains(err.Error(), expectedErrSubstring) {
+		t.Fatalf("TestSplitWithExponentialBiasErrors: splitWithExponentialBias "+
+			"returned wrong error. Want: %s, got: %s", expectedErrSubstring, err)
+	}
+}
+
+func TestReindexIntervalErrors(t *testing.T) {
+	// Create a treeNode and give it size = 100
+	treeNode := newReachabilityTreeNode(&blockNode{})
+	treeNode.setInterval(newReachabilityInterval(0, 99))
+
+	// Add a chain of 100 child treeNodes to treeNode
+	var err error
+	currentTreeNode := treeNode
+	for i := 0; i < 100; i++ {
+		childTreeNode := newReachabilityTreeNode(&blockNode{})
+		_, err = currentTreeNode.addChild(childTreeNode)
+		if err != nil {
+			break
+		}
+		currentTreeNode = childTreeNode
+	}
+
+	// At the 100th addChild we expect a reindex. This reindex should
+	// fail because our initial treeNode only has size = 100, and the
+	// reindex requires size > 100.
+	// This simulates the case when (somehow) there's more than 2^64
+	// blocks in the DAG, since the genesis block has size = 2^64.
+	if err == nil {
+		t.Fatalf("TestReindexIntervalErrors: reindexIntervals " +
+			"unexpectedly didn't return an error")
+	}
+	if !strings.Contains(err.Error(), "missing tree parent during reindexing") {
+		t.Fatalf("TestReindexIntervalErrors: reindexIntervals "+
+			"returned an expected error: %s", err)
+	}
+}
+
+func TestFutureCoveringBlockSetString(t *testing.T) {
+	treeNodeA := newReachabilityTreeNode(&blockNode{})
+	treeNodeA.setInterval(newReachabilityInterval(123, 456))
+	treeNodeB := newReachabilityTreeNode(&blockNode{})
+	treeNodeB.setInterval(newReachabilityInterval(457, 789))
+	futureCoveringSet := futureCoveringBlockSet{
+		&futureCoveringBlock{treeNode: treeNodeA},
+		&futureCoveringBlock{treeNode: treeNodeB},
+	}
+
+	str := futureCoveringSet.String()
+	expectedStr := "[123,456][457,789]"
+	if str != expectedStr {
+		t.Fatalf("TestFutureCoveringBlockSetString: unexpected "+
+			"string. Want: %s, got: %s", expectedStr, str)
+	}
+}
+
+func TestReachabilityTreeNodeString(t *testing.T) {
+	treeNodeA := newReachabilityTreeNode(&blockNode{})
+	treeNodeA.setInterval(newReachabilityInterval(100, 199))
+	treeNodeB1 := newReachabilityTreeNode(&blockNode{})
+	treeNodeB1.setInterval(newReachabilityInterval(100, 150))
+	treeNodeB2 := newReachabilityTreeNode(&blockNode{})
+	treeNodeB2.setInterval(newReachabilityInterval(150, 199))
+	treeNodeC := newReachabilityTreeNode(&blockNode{})
+	treeNodeC.setInterval(newReachabilityInterval(100, 149))
+	treeNodeA.children = []*reachabilityTreeNode{treeNodeB1, treeNodeB2}
+	treeNodeB2.children = []*reachabilityTreeNode{treeNodeC}
+
+	str := treeNodeA.String()
+	expectedStr := "[100,149]\n[100,150][150,199]\n[100,199]"
+	if str != expectedStr {
+		t.Fatalf("TestReachabilityTreeNodeString: unexpected "+
+			"string. Want: %s, got: %s", expectedStr, str)
+	}
+}
--- a/blockdag/reachabilitystore.go
+++ b/blockdag/reachabilitystore.go
@@ -0,0 +1,392 @@
+package blockdag
+
+import (
+	"bytes"
+	"github.com/kaspanet/kaspad/database"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/wire"
+	"github.com/pkg/errors"
+	"io"
+)
+
+type reachabilityData struct {
+	treeNode          *reachabilityTreeNode
+	futureCoveringSet futureCoveringBlockSet
+}
+
+type reachabilityStore struct {
+	dag    *BlockDAG
+	dirty  map[daghash.Hash]struct{}
+	loaded map[daghash.Hash]*reachabilityData
+}
+
+func newReachabilityStore(dag *BlockDAG) *reachabilityStore {
+	return &reachabilityStore{
+		dag:    dag,
+		dirty:  make(map[daghash.Hash]struct{}),
+		loaded: make(map[daghash.Hash]*reachabilityData),
+	}
+}
+
+func (store *reachabilityStore) setTreeNode(treeNode *reachabilityTreeNode) {
+	// load the reachability data from DB to store.loaded
+	node := treeNode.blockNode
+	_, exists := store.reachabilityDataByHash(node.hash)
+	if !exists {
+		store.loaded[*node.hash] = &reachabilityData{}
+	}
+
+	store.loaded[*node.hash].treeNode = treeNode
+	store.setBlockAsDirty(node.hash)
+}
+
+func (store *reachabilityStore) setFutureCoveringSet(node *blockNode, futureCoveringSet futureCoveringBlockSet) error {
+	// load the reachability data from DB to store.loaded
+	_, exists := store.reachabilityDataByHash(node.hash)
+	if !exists {
+		return reachabilityNotFoundError(node)
+	}
+
+	store.loaded[*node.hash].futureCoveringSet = futureCoveringSet
+	store.setBlockAsDirty(node.hash)
+	return nil
+}
+
+func (store *reachabilityStore) setBlockAsDirty(blockHash *daghash.Hash) {
+	store.dirty[*blockHash] = struct{}{}
+}
+
+func reachabilityNotFoundError(node *blockNode) error {
+	return errors.Errorf("Couldn't find reachability data for block %s", node.hash)
+}
+
+func (store *reachabilityStore) treeNodeByBlockNode(node *blockNode) (*reachabilityTreeNode, error) {
+	reachabilityData, exists := store.reachabilityDataByHash(node.hash)
+	if !exists {
+		return nil, reachabilityNotFoundError(node)
+	}
+	return reachabilityData.treeNode, nil
+}
+
+func (store *reachabilityStore) futureCoveringSetByBlockNode(node *blockNode) (futureCoveringBlockSet, error) {
+	reachabilityData, exists := store.reachabilityDataByHash(node.hash)
+	if !exists {
+		return nil, reachabilityNotFoundError(node)
+	}
+	return reachabilityData.futureCoveringSet, nil
+}
+
+func (store *reachabilityStore) reachabilityDataByHash(hash *daghash.Hash) (*reachabilityData, bool) {
+	reachabilityData, ok := store.loaded[*hash]
+	return reachabilityData, ok
+}
+
+// flushToDB writes all dirty reachability data to the database.
+func (store *reachabilityStore) flushToDB(dbTx database.Tx) error {
+	if len(store.dirty) == 0 {
+		return nil
+	}
+
+	for hash := range store.dirty {
+		hash := hash // Copy hash to a new variable to avoid passing the same pointer
+		reachabilityData := store.loaded[hash]
+		err := store.dbStoreReachabilityData(dbTx, &hash, reachabilityData)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (store *reachabilityStore) clearDirtyEntries() {
+	store.dirty = make(map[daghash.Hash]struct{})
+}
+
+func (store *reachabilityStore) init(dbTx database.Tx) error {
+	bucket := dbTx.Metadata().Bucket(reachabilityDataBucketName)
+
+	// TODO: (Stas) This is a quick and dirty hack.
+	// We iterate over the entire bucket twice:
+	// * First, populate the loaded set with all entries
+	// * Second, connect the parent/children pointers in each entry
+	//   with other nodes, which are now guaranteed to exist
+	cursor := bucket.Cursor()
+	for ok := cursor.First(); ok; ok = cursor.Next() {
+		err := store.initReachabilityData(cursor)
+		if err != nil {
+			return err
+		}
+	}
+	cursor = bucket.Cursor()
+	for ok := cursor.First(); ok; ok = cursor.Next() {
+		err := store.loadReachabilityDataFromCursor(cursor)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (store *reachabilityStore) initReachabilityData(cursor database.Cursor) error {
+	hash, err := daghash.NewHash(cursor.Key())
+	if err != nil {
+		return err
+	}
+
+	store.loaded[*hash] = &reachabilityData{
+		treeNode:          &reachabilityTreeNode{},
+		futureCoveringSet: nil,
+	}
+	return nil
+}
+
+func (store *reachabilityStore) loadReachabilityDataFromCursor(cursor database.Cursor) error {
+	hash, err := daghash.NewHash(cursor.Key())
+	if err != nil {
+		return err
+	}
+
+	reachabilityData, ok := store.reachabilityDataByHash(hash)
+	if !ok {
+		return errors.Errorf("cannot find reachability data for block hash: %s", hash)
+	}
+
+	err = store.deserializeReachabilityData(cursor.Value(), reachabilityData)
+	if err != nil {
+		return err
+	}
+
+	// Connect the treeNode with its blockNode
+	reachabilityData.treeNode.blockNode = store.dag.index.LookupNode(hash)
+
+	return nil
+}
+
+// dbStoreReachabilityData stores the reachability data to the database.
+// This overwrites the current entry if there exists one.
+func (store *reachabilityStore) dbStoreReachabilityData(dbTx database.Tx, hash *daghash.Hash, reachabilityData *reachabilityData) error {
+	serializedReachabilyData, err := store.serializeReachabilityData(reachabilityData)
+	if err != nil {
+		return err
+	}
+
+	return dbTx.Metadata().Bucket(reachabilityDataBucketName).Put(hash[:], serializedReachabilyData)
+}
+
+func (store *reachabilityStore) serializeReachabilityData(reachabilityData *reachabilityData) ([]byte, error) {
+	w := &bytes.Buffer{}
+	err := store.serializeTreeNode(w, reachabilityData.treeNode)
+	if err != nil {
+		return nil, err
+	}
+	err = store.serializeFutureCoveringSet(w, reachabilityData.futureCoveringSet)
+	if err != nil {
+		return nil, err
+	}
+	return w.Bytes(), nil
+}
+
+func (store *reachabilityStore) serializeTreeNode(w io.Writer, treeNode *reachabilityTreeNode) error {
+	// Serialize the interval
+	err := store.serializeReachabilityInterval(w, treeNode.interval)
+	if err != nil {
+		return err
+	}
+
+	// Serialize the remaining interval
+	err = store.serializeReachabilityInterval(w, treeNode.remainingInterval)
+	if err != nil {
+		return err
+	}
+
+	// Serialize the parent
+	// If this is the genesis block, write the zero hash instead
+	parentHash := &daghash.ZeroHash
+	if treeNode.parent != nil {
+		parentHash = treeNode.parent.blockNode.hash
+	}
+	err = wire.WriteElement(w, parentHash)
+	if err != nil {
+		return err
+	}
+
+	// Serialize the amount of children
+	err = wire.WriteVarInt(w, uint64(len(treeNode.children)))
+	if err != nil {
+		return err
+	}
+
+	// Serialize the children
+	for _, child := range treeNode.children {
+		err = wire.WriteElement(w, child.blockNode.hash)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (store *reachabilityStore) serializeReachabilityInterval(w io.Writer, interval *reachabilityInterval) error {
+	// Serialize start
+	err := wire.WriteElement(w, interval.start)
+	if err != nil {
+		return err
+	}
+
+	// Serialize end
+	err = wire.WriteElement(w, interval.end)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (store *reachabilityStore) serializeFutureCoveringSet(w io.Writer, futureCoveringSet futureCoveringBlockSet) error {
+	// Serialize the set size
+	err := wire.WriteVarInt(w, uint64(len(futureCoveringSet)))
+	if err != nil {
+		return err
+	}
+
+	// Serialize each block in the set
+	for _, block := range futureCoveringSet {
+		err = wire.WriteElement(w, block.blockNode.hash)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (store *reachabilityStore) deserializeReachabilityData(
+	serializedReachabilityDataBytes []byte, destination *reachabilityData) error {
+
+	r := bytes.NewBuffer(serializedReachabilityDataBytes)
+
+	// Deserialize the tree node
+	err := store.deserializeTreeNode(r, destination)
+	if err != nil {
+		return err
+	}
+
+	// Deserialize the future covering set
+	err = store.deserializeFutureCoveringSet(r, destination)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (store *reachabilityStore) deserializeTreeNode(r io.Reader, destination *reachabilityData) error {
+	// Deserialize the interval
+	interval, err := store.deserializeReachabilityInterval(r)
+	if err != nil {
+		return err
+	}
+	destination.treeNode.interval = interval
+
+	// Deserialize the remaining interval
+	remainingInterval, err := store.deserializeReachabilityInterval(r)
+	if err != nil {
+		return err
+	}
+	destination.treeNode.remainingInterval = remainingInterval
+
+	// Deserialize the parent
+	// If this is the zero hash, this node is the genesis and as such doesn't have a parent
+	parentHash := &daghash.Hash{}
+	err = wire.ReadElement(r, parentHash)
+	if err != nil {
+		return err
+	}
+	if !daghash.ZeroHash.IsEqual(parentHash) {
+		parentReachabilityData, ok := store.reachabilityDataByHash(parentHash)
+		if !ok {
+			return errors.Errorf("parent reachability data not found for hash: %s", parentHash)
+		}
+		destination.treeNode.parent = parentReachabilityData.treeNode
+	}
+
+	// Deserialize the amount of children
+	childCount, err := wire.ReadVarInt(r)
+	if err != nil {
+		return err
+	}
+
+	// Deserialize the children
+	children := make([]*reachabilityTreeNode, childCount)
+	for i := uint64(0); i < childCount; i++ {
+		childHash := &daghash.Hash{}
+		err = wire.ReadElement(r, childHash)
+		if err != nil {
+			return err
+		}
+		childReachabilityData, ok := store.reachabilityDataByHash(childHash)
+		if !ok {
+			return errors.Errorf("child reachability data not found for hash: %s", parentHash)
+		}
+		children[i] = childReachabilityData.treeNode
+	}
+	destination.treeNode.children = children
+
+	return nil
+}
+
+func (store *reachabilityStore) deserializeReachabilityInterval(r io.Reader) (*reachabilityInterval, error) {
+	interval := &reachabilityInterval{}
+
+	// Deserialize start
+	start := uint64(0)
+	err := wire.ReadElement(r, &start)
+	if err != nil {
+		return nil, err
+	}
+	interval.start = start
+
+	// Deserialize end
+	end := uint64(0)
+	err = wire.ReadElement(r, &end)
+	if err != nil {
+		return nil, err
+	}
+	interval.end = end
+
+	return interval, nil
+}
+
+func (store *reachabilityStore) deserializeFutureCoveringSet(r io.Reader, destination *reachabilityData) error {
+	// Deserialize the set size
+	setSize, err := wire.ReadVarInt(r)
+	if err != nil {
+		return err
+	}
+
+	// Deserialize each block in the set
+	futureCoveringSet := make(futureCoveringBlockSet, setSize)
+	for i := uint64(0); i < setSize; i++ {
+		blockHash := &daghash.Hash{}
+		err = wire.ReadElement(r, blockHash)
+		if err != nil {
+			return err
+		}
+		blockNode := store.dag.index.LookupNode(blockHash)
+		if blockNode == nil {
+			return errors.Errorf("blockNode not found for hash %s", blockHash)
+		}
+		blockReachabilityData, ok := store.reachabilityDataByHash(blockHash)
+		if !ok {
+			return errors.Errorf("block reachability data not found for hash: %s", blockHash)
+		}
+		futureCoveringSet[i] = &futureCoveringBlock{
+			blockNode: blockNode,
+			treeNode:  blockReachabilityData.treeNode,
+		}
+	}
+	destination.futureCoveringSet = futureCoveringSet
+
+	return nil
+}
--- a/blockdag/test_utils.go
+++ b/blockdag/test_utils.go
@@ -10,6 +10,7 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 	"sync"

@@ -26,11 +27,8 @@ const (
 	// testDbType is the database backend type to use for the tests.
 	testDbType = "ffldb"

-	// testDbRoot is the root directory used to create all test databases.
-	testDbRoot = "testdbs"
-
 	// blockDataNet is the expected network in the test block data.
-	blockDataNet = wire.MainNet
+	blockDataNet = wire.Mainnet
 )

 // isSupportedDbType returns whether or not the passed database type is
@@ -79,16 +77,9 @@ func DAGSetup(dbName string, config Config) (*BlockDAG, func(), error) {
 	}

 	if config.DB == nil {
-		// Create the root directory for test databases.
-		if !FileExists(testDbRoot) {
-			if err := os.MkdirAll(testDbRoot, 0700); err != nil {
-				err := errors.Errorf("unable to create test db "+
-					"root: %s", err)
-				return nil, nil, err
-			}
-		}
+		tmpDir := os.TempDir()

-		dbPath := filepath.Join(testDbRoot, dbName)
+		dbPath := filepath.Join(tmpDir, dbName)
 		_ = os.RemoveAll(dbPath)
 		var err error
 		config.DB, err = database.Create(testDbType, dbPath, blockDataNet)
@@ -103,7 +94,6 @@ func DAGSetup(dbName string, config Config) (*BlockDAG, func(), error) {
 			spawn = realSpawn
 			config.DB.Close()
 			os.RemoveAll(dbPath)
-			os.RemoveAll(testDbRoot)
 		}
 	} else {
 		teardown = func() {
@@ -173,7 +163,7 @@ func SetVirtualForTest(dag *BlockDAG, virtual VirtualForTest) VirtualForTest {

 // GetVirtualFromParentsForTest generates a virtual block with the given parents.
 func GetVirtualFromParentsForTest(dag *BlockDAG, parentHashes []*daghash.Hash) (VirtualForTest, error) {
-	parents := newSet()
+	parents := newBlockSet()
 	for _, hash := range parentHashes {
 		parent := dag.index.LookupNode(hash)
 		if parent == nil {
@@ -181,7 +171,7 @@ func GetVirtualFromParentsForTest(dag *BlockDAG, parentHashes []*daghash.Hash) (
 		}
 		parents.add(parent)
 	}
-	virtual := newVirtualBlock(parents, dag.dagParams.K)
+	virtual := newVirtualBlock(dag, parents)

 	pastUTXO, _, err := dag.pastUTXO(&virtual.blockNode)
 	if err != nil {
@@ -200,7 +190,7 @@ func GetVirtualFromParentsForTest(dag *BlockDAG, parentHashes []*daghash.Hash) (
 // LoadBlocks reads files containing kaspa gzipped block data from disk
 // and returns them as an array of util.Block.
 func LoadBlocks(filename string) (blocks []*util.Block, err error) {
-	var network = wire.MainNet
+	var network = wire.Mainnet
 	var dr io.Reader
 	var fi io.ReadCloser

@@ -251,3 +241,72 @@ func LoadBlocks(filename string) (blocks []*util.Block, err error) {

 	return
 }
+
+// opTrueAddress returns an address pointing to a P2SH anyone-can-spend script
+func opTrueAddress(prefix util.Bech32Prefix) (util.Address, error) {
+	return util.NewAddressScriptHash(OpTrueScript, prefix)
+}
+
+// PrepareBlockForTest generates a block with the proper merkle roots, coinbase transaction etc. This function is used for test purposes only
+func PrepareBlockForTest(dag *BlockDAG, parentHashes []*daghash.Hash, transactions []*wire.MsgTx) (*wire.MsgBlock, error) {
+	newVirtual, err := GetVirtualFromParentsForTest(dag, parentHashes)
+	if err != nil {
+		return nil, err
+	}
+	oldVirtual := SetVirtualForTest(dag, newVirtual)
+	defer SetVirtualForTest(dag, oldVirtual)
+
+	OpTrueAddr, err := opTrueAddress(dag.dagParams.Prefix)
+	if err != nil {
+		return nil, err
+	}
+
+	blockTransactions := make([]*util.Tx, len(transactions)+1)
+
+	extraNonce := generateDeterministicExtraNonceForTest()
+	coinbasePayloadExtraData, err := CoinbasePayloadExtraData(extraNonce, "")
+	if err != nil {
+		return nil, err
+	}
+
+	blockTransactions[0], err = dag.NextCoinbaseFromAddress(OpTrueAddr, coinbasePayloadExtraData)
+	if err != nil {
+		return nil, err
+	}
+
+	for i, tx := range transactions {
+		blockTransactions[i+1] = util.NewTx(tx)
+	}
+
+	// Sort transactions by subnetwork ID
+	sort.Slice(blockTransactions, func(i, j int) bool {
+		if blockTransactions[i].MsgTx().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDCoinbase) {
+			return true
+		}
+		if blockTransactions[j].MsgTx().SubnetworkID.IsEqual(subnetworkid.SubnetworkIDCoinbase) {
+			return false
+		}
+		return subnetworkid.Less(&blockTransactions[i].MsgTx().SubnetworkID, &blockTransactions[j].MsgTx().SubnetworkID)
+	})
+
+	block, err := dag.BlockForMining(blockTransactions)
+	if err != nil {
+		return nil, err
+	}
+	block.Header.Timestamp = dag.NextBlockMinimumTime()
+	block.Header.Bits = dag.NextRequiredDifficulty(block.Header.Timestamp)
+
+	return block, nil
+}
+
+// generateDeterministicExtraNonceForTest returns a unique deterministic extra nonce for coinbase data, in order to create unique coinbase transactions.
+func generateDeterministicExtraNonceForTest() uint64 {
+	extraNonceForTest++
+	return extraNonceForTest
+}
+
+func resetExtraNonceForTest() {
+	extraNonceForTest = 0
+}
+
+var extraNonceForTest = uint64(0)
--- a/blockdag/test_utils_test.go
+++ b/blockdag/test_utils_test.go
@@ -1,14 +1,7 @@
 package blockdag

 import (
-	"github.com/pkg/errors"
-	"os"
-	"strings"
 	"testing"
-
-	"bou.ke/monkey"
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/database"
 )

 func TestIsSupportedDbType(t *testing.T) {
@@ -19,38 +12,3 @@ func TestIsSupportedDbType(t *testing.T) {
 		t.Errorf("madeUpDb should not be a supported DB driver")
 	}
 }
-
-// TestDAGSetupErrors tests all error-cases in DAGSetup.
-// The non-error-cases are tested in the more general tests.
-func TestDAGSetupErrors(t *testing.T) {
-	os.RemoveAll(testDbRoot)
-	testDAGSetupErrorThroughPatching(t, "unable to create test db root: ", os.MkdirAll, func(path string, perm os.FileMode) error {
-		return errors.New("Made up error")
-	})
-
-	testDAGSetupErrorThroughPatching(t, "failed to create dag instance: ", New, func(config *Config) (*BlockDAG, error) {
-		return nil, errors.New("Made up error")
-	})
-
-	testDAGSetupErrorThroughPatching(t, "unsupported db type ", isSupportedDbType, func(dbType string) bool {
-		return false
-	})
-
-	testDAGSetupErrorThroughPatching(t, "error creating db: ", database.Create, func(dbType string, args ...interface{}) (database.DB, error) {
-		return nil, errors.New("Made up error")
-	})
-}
-
-func testDAGSetupErrorThroughPatching(t *testing.T, expectedErrorMessage string, targetFunction interface{}, replacementFunction interface{}) {
-	guard := monkey.Patch(targetFunction, replacementFunction)
-	defer guard.Unpatch()
-	_, tearDown, err := DAGSetup("TestDAGSetup", Config{
-		DAGParams: &dagconfig.MainNetParams,
-	})
-	if tearDown != nil {
-		defer tearDown()
-	}
-	if err == nil || !strings.HasPrefix(err.Error(), expectedErrorMessage) {
-		t.Errorf("DAGSetup: expected error to have prefix '%s' but got error '%v'", expectedErrorMessage, err)
-	}
-}
--- a/blockdag/testdata/blk_0_to_4.dat
+++ b/blockdag/testdata/blk_0_to_4.dat
--- a/blockdag/testdata/blk_3A.dat
+++ b/blockdag/testdata/blk_3A.dat
--- a/blockdag/testdata/blk_3B.dat
+++ b/blockdag/testdata/blk_3B.dat
--- a/blockdag/testdata/blk_3C.dat
+++ b/blockdag/testdata/blk_3C.dat
--- a/blockdag/testdata/blk_3D.dat
+++ b/blockdag/testdata/blk_3D.dat
--- a/blockdag/thresholdstate.go
+++ b/blockdag/thresholdstate.go
@@ -130,15 +130,15 @@ func (dag *BlockDAG) thresholdState(prevNode *blockNode, checker thresholdCondit
 	// The threshold state for the window that contains the genesis block is
 	// defined by definition.
 	confirmationWindow := checker.MinerConfirmationWindow()
-	if prevNode == nil || (prevNode.chainHeight+1) < confirmationWindow {
+	if prevNode == nil || (prevNode.blueScore+1) < confirmationWindow {
 		return ThresholdDefined, nil
 	}

 	// Get the ancestor that is the last block of the previous confirmation
 	// window in order to get its threshold state. This can be done because
 	// the state is the same for all blocks within a given window.
-	prevNode = prevNode.SelectedAncestor(prevNode.chainHeight -
-		(prevNode.chainHeight+1)%confirmationWindow)
+	prevNode = prevNode.SelectedAncestor(prevNode.blueScore -
+		(prevNode.blueScore+1)%confirmationWindow)

 	// Iterate backwards through each of the previous confirmation windows
 	// to find the most recently cached threshold state.
@@ -219,18 +219,17 @@ func (dag *BlockDAG) thresholdState(prevNode *blockNode, checker thresholdCondit
 			// on by the miners, so iterate backwards through the
 			// confirmation window to count all of the votes in it.
 			var count uint64
-			countNode := prevNode
-			for i := uint64(0); i < confirmationWindow; i++ {
-				condition, err := checker.Condition(countNode)
+			windowNodes := make([]*blockNode, 0, confirmationWindow)
+			windowNodes = append(windowNodes, prevNode)
+			windowNodes = append(windowNodes, blueBlockWindow(prevNode, confirmationWindow-1)...)
+			for _, current := range windowNodes {
+				condition, err := checker.Condition(current)
 				if err != nil {
 					return ThresholdFailed, err
 				}
 				if condition {
 					count++
 				}
-
-				// Get the previous block node.
-				countNode = countNode.selectedParent
 			}

 			// The state is locked in if the number of blocks in the
@@ -265,8 +264,8 @@ func (dag *BlockDAG) thresholdState(prevNode *blockNode, checker thresholdCondit
 // This function is safe for concurrent access.
 func (dag *BlockDAG) ThresholdState(deploymentID uint32) (ThresholdState, error) {
 	dag.dagLock.Lock()
+	defer dag.dagLock.Unlock()
 	state, err := dag.deploymentState(dag.selectedTip(), deploymentID)
-	dag.dagLock.Unlock()

 	return state, err
 }
@@ -277,8 +276,8 @@ func (dag *BlockDAG) ThresholdState(deploymentID uint32) (ThresholdState, error)
 // This function is safe for concurrent access.
 func (dag *BlockDAG) IsDeploymentActive(deploymentID uint32) (bool, error) {
 	dag.dagLock.Lock()
+	defer dag.dagLock.Unlock()
 	state, err := dag.deploymentState(dag.selectedTip(), deploymentID)
-	dag.dagLock.Unlock()
 	if err != nil {
 		return false, err
 	}
--- a/blockdag/utxodiffstore.go
+++ b/blockdag/utxodiffstore.go
@@ -1,6 +1,7 @@
 package blockdag

 import (
+	"bytes"
 	"github.com/kaspanet/kaspad/database"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/util/locks"
@@ -161,9 +162,14 @@ func (diffStore *utxoDiffStore) flushToDB(dbTx database.Tx) error {
 		return nil
 	}

+	// Allocate a buffer here to avoid needless allocations/grows
+	// while writing each entry.
+	buffer := &bytes.Buffer{}
 	for hash := range diffStore.dirty {
+		hash := hash // Copy hash to a new variable to avoid passing the same pointer
+		buffer.Reset()
 		diffData := diffStore.loaded[hash]
-		err := dbStoreDiffData(dbTx, &hash, diffData)
+		err := dbStoreDiffData(dbTx, buffer, &hash, diffData)
 		if err != nil {
 			return err
 		}
@@ -177,12 +183,23 @@ func (diffStore *utxoDiffStore) clearDirtyEntries() {

 // dbStoreDiffData stores the UTXO diff data to the database.
 // This overwrites the current entry if there exists one.
-func dbStoreDiffData(dbTx database.Tx, hash *daghash.Hash, diffData *blockUTXODiffData) error {
-	serializedDiffData, err := serializeBlockUTXODiffData(diffData)
+func dbStoreDiffData(dbTx database.Tx, writeBuffer *bytes.Buffer, hash *daghash.Hash, diffData *blockUTXODiffData) error {
+	// To avoid a ton of allocs, use the given writeBuffer
+	// instead of allocating one. We expect the buffer to
+	// already be initalized and, in most cases, to already
+	// be large enough to accommodate the serialized data
+	// without growing.
+	err := serializeBlockUTXODiffData(writeBuffer, diffData)
 	if err != nil {
 		return err
 	}

+	// Bucket.Put doesn't copy on its own, so we manually
+	// copy here. We do so because we expect the buffer
+	// to be reused once we're done with it.
+	serializedDiffData := make([]byte, writeBuffer.Len())
+	copy(serializedDiffData, writeBuffer.Bytes())
+
 	return dbTx.Metadata().Bucket(utxoDiffsBucketName).Put(hash[:], serializedDiffData)
 }

--- a/blockdag/utxodiffstore_test.go
+++ b/blockdag/utxodiffstore_test.go
@@ -13,7 +13,7 @@ import (
 func TestUTXODiffStore(t *testing.T) {
 	// Create a new database and DAG instance to run tests against.
 	dag, teardownFunc, err := DAGSetup("TestUTXODiffStore", Config{
-		DAGParams: &dagconfig.SimNetParams,
+		DAGParams: &dagconfig.SimnetParams,
 	})
 	if err != nil {
 		t.Fatalf("TestUTXODiffStore: Failed to setup DAG instance: %v", err)
--- a/blockdag/utxoio.go
+++ b/blockdag/utxoio.go
@@ -19,26 +19,25 @@ import (
 // 	hasDiffChild | Boolean   | Indicates if a diff child exist
 //  diffChild    | Hash      | The diffChild's hash. Empty if hasDiffChild is true.
 //  diff		 | UTXODiff  | The diff data's diff
-func serializeBlockUTXODiffData(diffData *blockUTXODiffData) ([]byte, error) {
-	w := &bytes.Buffer{}
+func serializeBlockUTXODiffData(w io.Writer, diffData *blockUTXODiffData) error {
 	hasDiffChild := diffData.diffChild != nil
 	err := wire.WriteElement(w, hasDiffChild)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	if hasDiffChild {
 		err := wire.WriteElement(w, diffData.diffChild.hash)
 		if err != nil {
-			return nil, err
+			return err
 		}
 	}

 	err = serializeUTXODiff(w, diffData.diff)
 	if err != nil {
-		return nil, err
+		return err
 	}

-	return w.Bytes(), nil
+	return nil
 }

 // utxoEntryHeaderCode returns the calculated header code to be used when
--- a/blockdag/utxoset.go
+++ b/blockdag/utxoset.go
@@ -2,11 +2,12 @@ package blockdag

 import (
 	"fmt"
-	"github.com/pkg/errors"
 	"math"
 	"sort"
 	"strings"

+	"github.com/pkg/errors"
+
 	"github.com/kaspanet/kaspad/ecc"
 	"github.com/kaspanet/kaspad/wire"
 )
@@ -224,6 +225,10 @@ func (d *UTXODiff) diffFrom(other *UTXODiff) (*UTXODiff, error) {
 	for outpoint, utxoEntry := range d.toAdd {
 		if !other.toAdd.containsWithBlueScore(outpoint, utxoEntry.blockBlueScore) {
 			result.toRemove.add(outpoint, utxoEntry)
+		} else if (d.toRemove.contains(outpoint) && !other.toRemove.contains(outpoint)) ||
+			(!d.toRemove.contains(outpoint) && other.toRemove.contains(outpoint)) {
+			return nil, errors.New(
+				"diffFrom: outpoint both in d.toAdd, other.toAdd, and only one of d.toRemove and other.toRemove")
 		}
 		if diffEntry, ok := other.toRemove.get(outpoint); ok {
 			// An exception is made for entries with unequal blue scores
@@ -243,6 +248,18 @@ func (d *UTXODiff) diffFrom(other *UTXODiff) (*UTXODiff, error) {
 	// If they are not in other.toRemove - should be added in result.toAdd
 	// If they are in other.toAdd - base utxoSet is not the same
 	for outpoint, utxoEntry := range d.toRemove {
+		diffEntry, ok := other.toRemove.get(outpoint)
+		if ok {
+			// if have the same entry in d.toRemove - simply don't copy.
+			// unless existing entry is with different blue score, in this case - this is an error
+			if utxoEntry.blockBlueScore != diffEntry.blockBlueScore {
+				return nil, errors.New("diffFrom: outpoint both in d.toRemove and other.toRemove with different " +
+					"blue scores, with no corresponding entry in d.toAdd")
+			}
+		} else { // if no existing entry - add to result.toAdd
+			result.toAdd.add(outpoint, utxoEntry)
+		}
+
 		if !other.toRemove.containsWithBlueScore(outpoint, utxoEntry.blockBlueScore) {
 			result.toAdd.add(outpoint, utxoEntry)
 		}
@@ -256,7 +273,7 @@ func (d *UTXODiff) diffFrom(other *UTXODiff) (*UTXODiff, error) {
 					other.toRemove.containsWithBlueScore(outpoint, utxoEntry.blockBlueScore)) {
 				continue
 			}
-			return nil, errors.New("diffFrom: transaction both in d.toRemove and in other.toAdd")
+			return nil, errors.New("diffFrom: outpoint both in d.toRemove and in other.toAdd")
 		}
 	}

@@ -284,6 +301,56 @@ func (d *UTXODiff) diffFrom(other *UTXODiff) (*UTXODiff, error) {
 	return &result, nil
 }

+// WithDiffInPlace applies provided diff to this diff in-place, that would be the result if
+// first d, and than diff were applied to the same base
+func (d *UTXODiff) WithDiffInPlace(diff *UTXODiff) error {
+	for outpoint, entryToRemove := range diff.toRemove {
+		if d.toAdd.containsWithBlueScore(outpoint, entryToRemove.blockBlueScore) {
+			// If already exists in toAdd with the same blueScore - remove from toAdd
+			d.toAdd.remove(outpoint)
+			continue
+		}
+		if d.toRemove.contains(outpoint) {
+			// If already exists - this is an error
+			return ruleError(ErrWithDiff, fmt.Sprintf(
+				"WithDiffInPlace: outpoint %s both in d.toRemove and in diff.toRemove", outpoint))
+		}
+
+		// If not exists neither in toAdd nor in toRemove - add to toRemove
+		d.toRemove.add(outpoint, entryToRemove)
+	}
+
+	for outpoint, entryToAdd := range diff.toAdd {
+		if d.toRemove.containsWithBlueScore(outpoint, entryToAdd.blockBlueScore) {
+			// If already exists in toRemove with the same blueScore - remove from toRemove
+			if d.toAdd.contains(outpoint) && !diff.toRemove.contains(outpoint) {
+				return ruleError(ErrWithDiff, fmt.Sprintf(
+					"WithDiffInPlace: outpoint %s both in d.toAdd and in diff.toAdd with no "+
+						"corresponding entry in diff.toRemove", outpoint))
+			}
+			d.toRemove.remove(outpoint)
+			continue
+		}
+		if existingEntry, ok := d.toAdd.get(outpoint); ok &&
+			(existingEntry.blockBlueScore == entryToAdd.blockBlueScore ||
+				!diff.toRemove.containsWithBlueScore(outpoint, existingEntry.blockBlueScore)) {
+			// If already exists - this is an error
+			return ruleError(ErrWithDiff, fmt.Sprintf(
+				"WithDiffInPlace: outpoint %s both in d.toAdd and in diff.toAdd", outpoint))
+		}
+
+		// If not exists neither in toAdd nor in toRemove, or exists in toRemove with different blueScore - add to toAdd
+		d.toAdd.add(outpoint, entryToAdd)
+	}
+
+	// Apply diff.diffMultiset to d.diffMultiset
+	if d.useMultiset {
+		d.diffMultiset = d.diffMultiset.Union(diff.diffMultiset)
+	}
+
+	return nil
+}
+
 // WithDiff applies provided diff to this diff, creating a new utxoDiff, that would be the result if
 // first d, and than diff were applied to the same base
 //
@@ -331,8 +398,7 @@ func (d *UTXODiff) WithDiff(diff *UTXODiff) (*UTXODiff, error) {
 			// or diff.toRemove.
 			// These are just "updates" to accepted blue score
 			if diffEntry.blockBlueScore != utxoEntry.blockBlueScore &&
-				(d.toRemove.containsWithBlueScore(outpoint, diffEntry.blockBlueScore) ||
-					diff.toRemove.containsWithBlueScore(outpoint, utxoEntry.blockBlueScore)) {
+				diff.toRemove.containsWithBlueScore(outpoint, utxoEntry.blockBlueScore) {
 				continue
 			}
 			return nil, ruleError(ErrWithDiff, fmt.Sprintf("WithDiff: outpoint %s both in d.toAdd and in other.toAdd", outpoint))
@@ -353,11 +419,10 @@ func (d *UTXODiff) WithDiff(diff *UTXODiff) (*UTXODiff, error) {
 			// or diff.toAdd.
 			// These are just "updates" to accepted blue score
 			if diffEntry.blockBlueScore != utxoEntry.blockBlueScore &&
-				(d.toAdd.containsWithBlueScore(outpoint, diffEntry.blockBlueScore) ||
-					diff.toAdd.containsWithBlueScore(outpoint, utxoEntry.blockBlueScore)) {
+				d.toAdd.containsWithBlueScore(outpoint, diffEntry.blockBlueScore) {
 				continue
 			}
-			return nil, ruleError(ErrWithDiff, "WithDiff: transaction both in d.toRemove and in other.toRemove")
+			return nil, ruleError(ErrWithDiff, "WithDiff: outpoint both in d.toRemove and in other.toRemove")
 		}
 	}

--- a/blockdag/utxoset_test.go
+++ b/blockdag/utxoset_test.go
@@ -1,11 +1,12 @@
 package blockdag

 import (
-	"github.com/kaspanet/kaspad/util/subnetworkid"
 	"math"
 	"reflect"
 	"testing"

+	"github.com/kaspanet/kaspad/util/subnetworkid"
+
 	"github.com/kaspanet/kaspad/ecc"
 	"github.com/kaspanet/kaspad/util/daghash"
 	"github.com/kaspanet/kaspad/wire"
@@ -136,8 +137,11 @@ func TestUTXODiffRules(t *testing.T) {
 	// For each of the following test cases, we will:
 	// this.diffFrom(other) and compare it to expectedDiffFromResult
 	// this.WithDiff(other) and compare it to expectedWithDiffResult
+	// this.WithDiffInPlace(other) and compare it to expectedWithDiffResult
 	//
 	// Note: an expected nil result means that we expect the respective operation to fail
+	// See the following spreadsheet for a summary of all test-cases:
+	// https://docs.google.com/spreadsheets/d/1E8G3mp5y1-yifouwLLXRLueSRfXdDRwRKFieYE07buY/edit?usp=sharing
 	tests := []struct {
 		name                   string
 		this                   *UTXODiff
@@ -146,7 +150,7 @@ func TestUTXODiffRules(t *testing.T) {
 		expectedWithDiffResult *UTXODiff
 	}{
 		{
-			name: "one toAdd in this, one toAdd in other",
+			name: "first toAdd in this, first toAdd in other",
 			this: &UTXODiff{
 				toAdd:    utxoCollection{outpoint0: utxoEntry1},
 				toRemove: utxoCollection{},
@@ -162,7 +166,23 @@ func TestUTXODiffRules(t *testing.T) {
 			expectedWithDiffResult: nil,
 		},
 		{
-			name: "one toAdd in this, one toRemove in other",
+			name: "first in toAdd in this, second in toAdd in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{},
+			},
+			expectedDiffFromResult: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			expectedWithDiffResult: nil,
+		},
+		{
+			name: "first in toAdd in this, second in toRemove in other",
 			this: &UTXODiff{
 				toAdd:    utxoCollection{outpoint0: utxoEntry1},
 				toRemove: utxoCollection{},
@@ -178,7 +198,36 @@ func TestUTXODiffRules(t *testing.T) {
 			},
 		},
 		{
-			name: "one toAdd in this, empty other",
+			name: "first in toAdd in this and other, second in toRemove in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			expectedDiffFromResult: nil,
+			expectedWithDiffResult: nil,
+		},
+		{
+			name: "first in toAdd in this and toRemove in other, second in toAdd in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			expectedDiffFromResult: nil,
+			expectedWithDiffResult: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{},
+			},
+		},
+		{
+			name: "first in toAdd in this, empty other",
 			this: &UTXODiff{
 				toAdd:    utxoCollection{outpoint0: utxoEntry1},
 				toRemove: utxoCollection{},
@@ -197,7 +246,7 @@ func TestUTXODiffRules(t *testing.T) {
 			},
 		},
 		{
-			name: "one toRemove in this, one toAdd in other",
+			name: "first in toRemove in this and in toAdd in other",
 			this: &UTXODiff{
 				toAdd:    utxoCollection{},
 				toRemove: utxoCollection{outpoint0: utxoEntry1},
@@ -213,7 +262,23 @@ func TestUTXODiffRules(t *testing.T) {
 			},
 		},
 		{
-			name: "one toRemove in this, one toRemove in other",
+			name: "first in toRemove in this, second in toAdd in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{},
+			},
+			expectedDiffFromResult: nil,
+			expectedWithDiffResult: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+		},
+		{
+			name: "first in toRemove in this and other",
 			this: &UTXODiff{
 				toAdd:    utxoCollection{},
 				toRemove: utxoCollection{outpoint0: utxoEntry1},
@@ -229,7 +294,49 @@ func TestUTXODiffRules(t *testing.T) {
 			expectedWithDiffResult: nil,
 		},
 		{
-			name: "one toRemove in this, empty other",
+			name: "first in toRemove in this, second in toRemove in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			expectedDiffFromResult: nil,
+			expectedWithDiffResult: nil,
+		},
+		{
+			name: "first in toRemove in this and toAdd in other, second in toRemove in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			expectedDiffFromResult: nil,
+			expectedWithDiffResult: nil,
+		},
+		{
+			name: "first in toRemove in this and other, second in toAdd in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			expectedDiffFromResult: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{},
+			},
+			expectedWithDiffResult: nil,
+		},
+		{
+			name: "first in toRemove in this, empty other",
 			this: &UTXODiff{
 				toAdd:    utxoCollection{},
 				toRemove: utxoCollection{outpoint0: utxoEntry1},
@@ -248,7 +355,116 @@ func TestUTXODiffRules(t *testing.T) {
 			},
 		},
 		{
-			name: "empty this, one toAdd in other",
+			name: "first in toAdd in this and other, second in toRemove in this",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{},
+			},
+			expectedDiffFromResult: nil,
+			expectedWithDiffResult: nil,
+		},
+		{
+			name: "first in toAdd in this, second in toRemove in this and toAdd in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{},
+			},
+			expectedDiffFromResult: nil,
+			expectedWithDiffResult: nil,
+		},
+		{
+			name: "first in toAdd in this and toRemove in other, second in toRemove in this",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			expectedDiffFromResult: nil,
+			expectedWithDiffResult: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+		},
+		{
+			name: "first in toAdd in this, second in toRemove in this and in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			expectedDiffFromResult: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			expectedWithDiffResult: nil,
+		},
+		{
+			name: "first in toAdd and second in toRemove in both this and other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			expectedDiffFromResult: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{},
+			},
+			expectedWithDiffResult: nil,
+		},
+		{
+			name: "first in toAdd in this and toRemove in other, second in toRemove in this and toAdd in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			expectedDiffFromResult: nil,
+			expectedWithDiffResult: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{},
+			},
+		},
+		{
+			name: "first in toAdd and second in toRemove in this, empty other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{},
+			},
+			expectedDiffFromResult: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry2},
+				toRemove: utxoCollection{outpoint0: utxoEntry1},
+			},
+			expectedWithDiffResult: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+		},
+		{
+			name: "empty this, first in toAdd in other",
 			this: &UTXODiff{
 				toAdd:    utxoCollection{},
 				toRemove: utxoCollection{},
@@ -267,7 +483,7 @@ func TestUTXODiffRules(t *testing.T) {
 			},
 		},
 		{
-			name: "empty this, one toRemove in other",
+			name: "empty this, first in toRemove in other",
 			this: &UTXODiff{
 				toAdd:    utxoCollection{},
 				toRemove: utxoCollection{},
@@ -285,6 +501,25 @@ func TestUTXODiffRules(t *testing.T) {
 				toRemove: utxoCollection{outpoint0: utxoEntry1},
 			},
 		},
+		{
+			name: "empty this, first in toAdd and second in toRemove in other",
+			this: &UTXODiff{
+				toAdd:    utxoCollection{},
+				toRemove: utxoCollection{},
+			},
+			other: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			expectedDiffFromResult: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+			expectedWithDiffResult: &UTXODiff{
+				toAdd:    utxoCollection{outpoint0: utxoEntry1},
+				toRemove: utxoCollection{outpoint0: utxoEntry2},
+			},
+		},
 		{
 			name: "empty this, empty other",
 			this: &UTXODiff{
@@ -304,108 +539,6 @@ func TestUTXODiffRules(t *testing.T) {
 				toRemove: utxoCollection{},
 			},
 		},
-		{
-			name: "equal outpoints different blue scores: first in toAdd in this, second in toAdd in other",
-			this: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry1},
-				toRemove: utxoCollection{},
-			},
-			other: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry2},
-				toRemove: utxoCollection{},
-			},
-			expectedDiffFromResult: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry2},
-				toRemove: utxoCollection{outpoint0: utxoEntry1},
-			},
-			expectedWithDiffResult: nil,
-		},
-		{
-			name: "equal outpoints different blue scores: first in toRemove in this, second in toRemove in other",
-			this: &UTXODiff{
-				toAdd:    utxoCollection{},
-				toRemove: utxoCollection{outpoint0: utxoEntry1},
-			},
-			other: &UTXODiff{
-				toAdd:    utxoCollection{},
-				toRemove: utxoCollection{outpoint0: utxoEntry2},
-			},
-			expectedDiffFromResult: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry1},
-				toRemove: utxoCollection{outpoint0: utxoEntry2},
-			},
-			expectedWithDiffResult: nil,
-		},
-		{
-			name: "equal outpoints different blue scores: first in toAdd and second in toRemove in this, empty other",
-			this: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry1},
-				toRemove: utxoCollection{outpoint0: utxoEntry2},
-			},
-			other: &UTXODiff{
-				toAdd:    utxoCollection{},
-				toRemove: utxoCollection{},
-			},
-			expectedDiffFromResult: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry2},
-				toRemove: utxoCollection{outpoint0: utxoEntry1},
-			},
-			expectedWithDiffResult: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry1},
-				toRemove: utxoCollection{outpoint0: utxoEntry2},
-			},
-		},
-		{
-			name: "equal outpoints different blue scores: empty this, first in toAdd and second in toRemove in other",
-			this: &UTXODiff{
-				toAdd:    utxoCollection{},
-				toRemove: utxoCollection{},
-			},
-			other: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry1},
-				toRemove: utxoCollection{outpoint0: utxoEntry2},
-			},
-			expectedDiffFromResult: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry1},
-				toRemove: utxoCollection{outpoint0: utxoEntry2},
-			},
-			expectedWithDiffResult: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry1},
-				toRemove: utxoCollection{outpoint0: utxoEntry2},
-			},
-		},
-		{
-			name: "equal outpoints different blue scores: first in toAdd and second in toRemove in both this and other",
-			this: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry1},
-				toRemove: utxoCollection{outpoint0: utxoEntry2},
-			},
-			other: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry1},
-				toRemove: utxoCollection{outpoint0: utxoEntry2},
-			},
-			expectedDiffFromResult: &UTXODiff{
-				toAdd:    utxoCollection{},
-				toRemove: utxoCollection{},
-			},
-			expectedWithDiffResult: nil,
-		},
-		{
-			name: "equal outpoints different blue scores: first in toAdd in this and toRemove in other, second in toRemove in this and toAdd in other",
-			this: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry1},
-				toRemove: utxoCollection{outpoint0: utxoEntry2},
-			},
-			other: &UTXODiff{
-				toAdd:    utxoCollection{outpoint0: utxoEntry2},
-				toRemove: utxoCollection{outpoint0: utxoEntry1},
-			},
-			expectedDiffFromResult: nil,
-			expectedWithDiffResult: &UTXODiff{
-				toAdd:    utxoCollection{},
-				toRemove: utxoCollection{},
-			},
-		},
 	}

 	for _, test := range tests {
@@ -460,6 +593,24 @@ func TestUTXODiffRules(t *testing.T) {
 				"Expected: \"%v\", got: \"%v\".", test.name, expectedWithDiffResult, withDiffResult)
 		}

+		// Repeat WithDiff check this time using WithDiffInPlace
+		thisClone := this.clone()
+		err = thisClone.WithDiffInPlace(other)
+
+		// Test whether WithDiffInPlace returned an error
+		isWithDiffInPlaceOk := err == nil
+		expectedIsWithDiffInPlaceOk := expectedWithDiffResult != nil
+		if isWithDiffInPlaceOk != expectedIsWithDiffInPlaceOk {
+			t.Errorf("unexpected WithDiffInPlace error in test \"%s\". "+
+				"Expected: \"%t\", got: \"%t\".", test.name, expectedIsWithDiffInPlaceOk, isWithDiffInPlaceOk)
+		}
+
+		// If not error, test the WithDiffInPlace result
+		if isWithDiffInPlaceOk && !thisClone.equal(expectedWithDiffResult) {
+			t.Errorf("unexpected WithDiffInPlace result in test \"%s\". "+
+				"Expected: \"%v\", got: \"%v\".", test.name, expectedWithDiffResult, thisClone)
+		}
+
 		// Make sure that diffFrom after WithDiff results in the original other
 		if isWithDiffOk {
 			otherResult, err := this.diffFrom(withDiffResult)
--- a/blockdag/validate.go
+++ b/blockdag/validate.go
@@ -6,11 +6,12 @@ package blockdag

 import (
 	"fmt"
-	"github.com/pkg/errors"
 	"math"
 	"sort"
 	"time"

+	"github.com/pkg/errors"
+
 	"github.com/kaspanet/kaspad/dagconfig"
 	"github.com/kaspanet/kaspad/txscript"
 	"github.com/kaspanet/kaspad/util"
@@ -432,7 +433,9 @@ func (dag *BlockDAG) checkBlockHeaderSanity(header *wire.BlockHeader, flags Beha

 	// Ensure the block time is not too far in the future. If it's too far, return
 	// the duration of time that should be waited before the block becomes valid.
-	maxTimestamp := dag.timeSource.AdjustedTime().Add(time.Second *
+	// This check needs to be last as it does not return an error but rather marks the
+	// header as delayed (and valid).
+	maxTimestamp := dag.AdjustedTime().Add(time.Second *
 		time.Duration(int64(dag.TimestampDeviationTolerance)*dag.targetTimePerBlock))
 	if header.Timestamp.After(maxTimestamp) {
 		return header.Timestamp.Sub(maxTimestamp), nil
@@ -443,9 +446,9 @@ func (dag *BlockDAG) checkBlockHeaderSanity(header *wire.BlockHeader, flags Beha

 //checkBlockParentsOrder ensures that the block's parents are ordered by hash
 func checkBlockParentsOrder(header *wire.BlockHeader) error {
-	sortedHashes := make([]*daghash.Hash, 0, header.NumParentBlocks())
-	for _, hash := range header.ParentHashes {
-		sortedHashes = append(sortedHashes, hash)
+	sortedHashes := make([]*daghash.Hash, header.NumParentBlocks())
+	for i, hash := range header.ParentHashes {
+		sortedHashes[i] = hash
 	}
 	sort.Slice(sortedHashes, func(i, j int) bool {
 		return daghash.Less(sortedHashes[i], sortedHashes[j])
@@ -552,7 +555,7 @@ func (dag *BlockDAG) checkBlockSanity(block *util.Block, flags BehaviorFlags) (t
 //  - BFFastAdd: No checks are performed.
 //
 // This function MUST be called with the dag state lock held (for writes).
-func (dag *BlockDAG) checkBlockHeaderContext(header *wire.BlockHeader, bluestParent *blockNode, blockChainHeight uint64, fastAdd bool) error {
+func (dag *BlockDAG) checkBlockHeaderContext(header *wire.BlockHeader, bluestParent *blockNode, fastAdd bool) error {
 	if !fastAdd {
 		if err := dag.validateDifficulty(header, bluestParent); err != nil {
 			return err
@@ -595,41 +598,32 @@ func (dag *BlockDAG) validateDifficulty(header *wire.BlockHeader, bluestParent *
 }

 // validateParents validates that no parent is an ancestor of another parent, and no parent is finalized
-func validateParents(blockHeader *wire.BlockHeader, parents blockSet) error {
-	minBlueScore := uint64(math.MaxUint64)
-	queue := newDownHeap()
-	visited := newSet()
-	for _, parent := range parents {
+func (dag *BlockDAG) validateParents(blockHeader *wire.BlockHeader, parents blockSet) error {
+	for parentA := range parents {
 		// isFinalized might be false-negative because node finality status is
 		// updated in a separate goroutine. This is why later the block is
 		// checked more thoroughly on the finality rules in dag.checkFinalityRules.
-		if parent.isFinalized {
-			return ruleError(ErrFinality, fmt.Sprintf("block %s is a finalized parent of block %s", parent.hash, blockHeader.BlockHash()))
+		if parentA.isFinalized {
+			return ruleError(ErrFinality, fmt.Sprintf("block %s is a finalized "+
+				"parent of block %s", parentA.hash, blockHeader.BlockHash()))
 		}
-		if parent.blueScore < minBlueScore {
-			minBlueScore = parent.blueScore
-		}
-		for _, grandParent := range parent.parents {
-			if !visited.contains(grandParent) {
-				queue.Push(grandParent)
-				visited.add(grandParent)
+
+		for parentB := range parents {
+			if parentA == parentB {
+				continue
 			}
-		}
-	}
-	for queue.Len() > 0 {
-		current := queue.pop()
-		if parents.contains(current) {
-			return ruleError(ErrInvalidParentsRelation, fmt.Sprintf("block %s is both a parent of %s and an"+
-				" ancestor of another parent",
-				current.hash,
-				blockHeader.BlockHash()))
-		}
-		if current.blueScore > minBlueScore {
-			for _, parent := range current.parents {
-				if !visited.contains(parent) {
-					queue.Push(parent)
-					visited.add(parent)
-				}
+
+			isAncestorOf, err := dag.isAncestorOf(parentA, parentB)
+			if err != nil {
+				return err
+			}
+			if isAncestorOf {
+				return ruleError(ErrInvalidParentsRelation, fmt.Sprintf("block %s is both a parent of %s and an"+
+					" ancestor of another parent %s",
+					parentA.hash,
+					blockHeader.BlockHash(),
+					parentB.hash,
+				))
 			}
 		}
 	}
@@ -651,14 +645,14 @@ func (dag *BlockDAG) checkBlockContext(block *util.Block, parents blockSet, flag
 	bluestParent := parents.bluest()
 	fastAdd := flags&BFFastAdd == BFFastAdd

-	err := validateParents(&block.MsgBlock().Header, parents)
+	err := dag.validateParents(&block.MsgBlock().Header, parents)
 	if err != nil {
 		return err
 	}

 	// Perform all block header related validation checks.
 	header := &block.MsgBlock().Header
-	if err = dag.checkBlockHeaderContext(header, bluestParent, block.ChainHeight(), fastAdd); err != nil {
+	if err = dag.checkBlockHeaderContext(header, bluestParent, fastAdd); err != nil {
 		return err
 	}

@@ -969,7 +963,7 @@ func (dag *BlockDAG) CheckConnectBlockTemplateNoLock(block *util.Block) error {
 		return err
 	}

-	templateNode := newBlockNode(&header, dag.virtual.tips(), dag.dagParams.K)
+	templateNode, _ := dag.newBlockNode(&header, dag.virtual.tips())

 	_, err = dag.checkConnectToPastUTXO(templateNode,
 		dag.UTXOSet(), block.Transactions(), false)
--- a/blockdag/validate_test.go
+++ b/blockdag/validate_test.go
@@ -5,7 +5,6 @@
 package blockdag

 import (
-	"bou.ke/monkey"
 	"github.com/pkg/errors"
 	"math"
 	"path/filepath"
@@ -30,35 +29,35 @@ func TestSequenceLocksActive(t *testing.T) {
 	}

 	tests := []struct {
-		seqLock          *SequenceLock
-		blockChainHeight uint64
-		mtp              time.Time
+		seqLock        *SequenceLock
+		blockBlueScore uint64
+		mtp            time.Time

 		want bool
 	}{
-		// Block based sequence lock with equal block height.
-		{seqLock: seqLock(1000, -1), blockChainHeight: 1001, mtp: time.Unix(9, 0), want: true},
+		// Block based sequence lock with equal block blue score.
+		{seqLock: seqLock(1000, -1), blockBlueScore: 1001, mtp: time.Unix(9, 0), want: true},

 		// Time based sequence lock with mtp past the absolute time.
-		{seqLock: seqLock(-1, 30), blockChainHeight: 2, mtp: time.Unix(31, 0), want: true},
+		{seqLock: seqLock(-1, 30), blockBlueScore: 2, mtp: time.Unix(31, 0), want: true},

-		// Block based sequence lock with current height below seq lock block height.
-		{seqLock: seqLock(1000, -1), blockChainHeight: 90, mtp: time.Unix(9, 0), want: false},
+		// Block based sequence lock with current blue score below seq lock block blue score.
+		{seqLock: seqLock(1000, -1), blockBlueScore: 90, mtp: time.Unix(9, 0), want: false},

 		// Time based sequence lock with current time before lock time.
-		{seqLock: seqLock(-1, 30), blockChainHeight: 2, mtp: time.Unix(29, 0), want: false},
+		{seqLock: seqLock(-1, 30), blockBlueScore: 2, mtp: time.Unix(29, 0), want: false},

-		// Block based sequence lock at the same height, so shouldn't yet be active.
-		{seqLock: seqLock(1000, -1), blockChainHeight: 1000, mtp: time.Unix(9, 0), want: false},
+		// Block based sequence lock at the same blue score, so shouldn't yet be active.
+		{seqLock: seqLock(1000, -1), blockBlueScore: 1000, mtp: time.Unix(9, 0), want: false},

 		// Time based sequence lock with current time equal to lock time, so shouldn't yet be active.
-		{seqLock: seqLock(-1, 30), blockChainHeight: 2, mtp: time.Unix(30, 0), want: false},
+		{seqLock: seqLock(-1, 30), blockBlueScore: 2, mtp: time.Unix(30, 0), want: false},
 	}

 	t.Logf("Running %d sequence locks tests", len(tests))
 	for i, test := range tests {
 		got := SequenceLockActive(test.seqLock,
-			test.blockChainHeight, test.mtp)
+			test.blockBlueScore, test.mtp)
 		if got != test.want {
 			t.Fatalf("SequenceLockActive #%d got %v want %v", i,
 				got, test.want)
@@ -71,7 +70,7 @@ func TestSequenceLocksActive(t *testing.T) {
 func TestCheckConnectBlockTemplate(t *testing.T) {
 	// Create a new database and DAG instance to run tests against.
 	dag, teardownFunc, err := DAGSetup("checkconnectblocktemplate", Config{
-		DAGParams: &dagconfig.SimNetParams,
+		DAGParams: &dagconfig.SimnetParams,
 	})
 	if err != nil {
 		t.Errorf("Failed to setup dag instance: %v", err)
@@ -101,12 +100,12 @@ func TestCheckConnectBlockTemplate(t *testing.T) {
 	}

 	for i := 1; i <= 3; i++ {
-		_, delay, err := dag.ProcessBlock(blocks[i], BFNone)
+		_, isDelayed, err := dag.ProcessBlock(blocks[i], BFNone)
 		if err != nil {
 			t.Fatalf("CheckConnectBlockTemplate: Received unexpected error "+
 				"processing block %d: %v", i, err)
 		}
-		if delay != 0 {
+		if isDelayed {
 			t.Fatalf("CheckConnectBlockTemplate: block %d is too far in the future", i)
 		}
 	}
@@ -126,7 +125,8 @@ func TestCheckConnectBlockTemplate(t *testing.T) {
 	}

 	blockNode3 := dag.index.LookupNode(blocks[3].Hash())
-	if blockNode3.children.containsHash(blocks[4].Hash()) {
+	blockNode4 := dag.index.LookupNode(blocks[4].Hash())
+	if blockNode3.children.contains(blockNode4) {
 		t.Errorf("Block 4 wasn't successfully detached as a child from block3")
 	}

@@ -162,7 +162,7 @@ func TestCheckConnectBlockTemplate(t *testing.T) {
 func TestCheckBlockSanity(t *testing.T) {
 	// Create a new database and dag instance to run tests against.
 	dag, teardownFunc, err := DAGSetup("TestCheckBlockSanity", Config{
-		DAGParams: &dagconfig.SimNetParams,
+		DAGParams: &dagconfig.SimnetParams,
 	})
 	if err != nil {
 		t.Errorf("Failed to setup dag instance: %v", err)
@@ -187,8 +187,8 @@ func TestCheckBlockSanity(t *testing.T) {
 	if err == nil {
 		t.Errorf("CheckBlockSanity: transactions disorder is not detected")
 	}
-	ruleErr, ok := err.(RuleError)
-	if !ok {
+	var ruleErr RuleError
+	if !errors.As(err, &ruleErr) {
 		t.Errorf("CheckBlockSanity: wrong error returned, expect RuleError, got %T", err)
 	} else if ruleErr.ErrorCode != ErrTransactionsNotSorted {
 		t.Errorf("CheckBlockSanity: wrong error returned, expect ErrTransactionsNotSorted, got %v, err %s", ruleErr.ErrorCode, err)
@@ -480,8 +480,10 @@ func TestCheckBlockSanity(t *testing.T) {
 	if err == nil {
 		t.Errorf("CheckBlockSanity: error is nil when it shouldn't be")
 	}
-	rError := err.(RuleError)
-	if rError.ErrorCode != ErrWrongParentsOrder {
+	var rError RuleError
+	if !errors.As(err, &rError) {
+		t.Fatalf("CheckBlockSanity: expected a RuleError, but got %s", err)
+	} else if rError.ErrorCode != ErrWrongParentsOrder {
 		t.Errorf("CheckBlockSanity: Expected error was ErrWrongParentsOrder but got %v", err)
 	}
 	if delay != 0 {
@@ -502,7 +504,7 @@ func TestCheckBlockSanity(t *testing.T) {
 }

 func TestPastMedianTime(t *testing.T) {
-	dag := newTestDAG(&dagconfig.MainNetParams)
+	dag := newTestDAG(&dagconfig.MainnetParams)
 	tip := dag.genesis
 	blockVersion := int32(0x10000000)

@@ -510,90 +512,69 @@ func TestPastMedianTime(t *testing.T) {

 	for i := 0; i < 100; i++ {
 		blockTime = blockTime.Add(time.Second)
-		tip = newTestNode(setFromSlice(tip),
+		tip = newTestNode(dag, blockSetFromSlice(tip),
 			blockVersion,
 			0,
-			blockTime,
-			dagconfig.MainNetParams.K)
+			blockTime)
 	}

 	// Checks that a block is valid if it has timestamp equals to past median time
-	chainHeight := tip.chainHeight + 1
-	node := newTestNode(setFromSlice(tip),
+	node := newTestNode(dag, blockSetFromSlice(tip),
 		blockVersion,
 		dag.powMaxBits,
-		tip.PastMedianTime(dag),
-		dagconfig.MainNetParams.K)
+		tip.PastMedianTime(dag))

 	header := node.Header()
-	err := dag.checkBlockHeaderContext(header, node.parents.bluest(), chainHeight, false)
+	err := dag.checkBlockHeaderContext(header, node.parents.bluest(), false)
 	if err != nil {
 		t.Errorf("TestPastMedianTime: unexpected error from checkBlockHeaderContext: %v"+
 			"(a block with timestamp equals to past median time should be valid)", err)
 	}

 	// Checks that a block is valid if its timestamp is after past median time
-	chainHeight = tip.chainHeight + 1
-	node = newTestNode(setFromSlice(tip),
+	node = newTestNode(dag, blockSetFromSlice(tip),
 		blockVersion,
 		dag.powMaxBits,
-		tip.PastMedianTime(dag).Add(time.Second),
-		dagconfig.MainNetParams.K)
+		tip.PastMedianTime(dag).Add(time.Second))

 	header = node.Header()
-	err = dag.checkBlockHeaderContext(header, node.parents.bluest(), chainHeight, false)
+	err = dag.checkBlockHeaderContext(header, node.parents.bluest(), false)
 	if err != nil {
 		t.Errorf("TestPastMedianTime: unexpected error from checkBlockHeaderContext: %v"+
 			"(a block with timestamp bigger than past median time should be valid)", err)
 	}

 	// Checks that a block is invalid if its timestamp is before past median time
-	chainHeight = tip.chainHeight + 1
-	node = newTestNode(setFromSlice(tip),
+	node = newTestNode(dag, blockSetFromSlice(tip),
 		blockVersion,
 		0,
-		tip.PastMedianTime(dag).Add(-time.Second),
-		dagconfig.MainNetParams.K)
+		tip.PastMedianTime(dag).Add(-time.Second))

 	header = node.Header()
-	err = dag.checkBlockHeaderContext(header, node.parents.bluest(), chainHeight, false)
+	err = dag.checkBlockHeaderContext(header, node.parents.bluest(), false)
 	if err == nil {
 		t.Errorf("TestPastMedianTime: unexpected success: block should be invalid if its timestamp is before past median time")
 	}
-
-	guard := monkey.Patch(blockWindow.medianTimestamp, func(_ blockWindow) (int64, error) {
-		return 0, errors.New("medianTimestamp error")
-	})
-	defer guard.Unpatch()
-	defer func() {
-		if recover() == nil {
-			t.Errorf("Got no panic on PastMedianTime, while expected panic")
-		}
-	}()
-	node.PastMedianTime(dag)
-
 }

 func TestValidateParents(t *testing.T) {
-	blockDAG := newTestDAG(&dagconfig.SimNetParams)
-	genesisNode := blockDAG.genesis
-	blockVersion := int32(0x10000000)
-
-	blockTime := genesisNode.Header().Timestamp
-
-	generateNode := func(parents ...*blockNode) *blockNode {
-		// The timestamp of each block is changed to prevent a situation where two blocks share the same hash
-		blockTime = blockTime.Add(time.Second)
-		return newTestNode(setFromSlice(parents...),
-			blockVersion,
-			0,
-			blockTime,
-			dagconfig.SimNetParams.K)
+	// Create a new database and dag instance to run tests against.
+	dag, teardownFunc, err := DAGSetup("TestCheckBlockSanity", Config{
+		DAGParams: &dagconfig.SimnetParams,
+	})
+	if err != nil {
+		t.Errorf("Failed to setup dag instance: %v", err)
+		return
 	}
+	defer teardownFunc()

-	a := generateNode(genesisNode)
-	b := generateNode(a)
-	c := generateNode(genesisNode)
+	a := prepareAndProcessBlock(t, dag, dag.dagParams.GenesisBlock)
+	b := prepareAndProcessBlock(t, dag, a)
+	c := prepareAndProcessBlock(t, dag, dag.dagParams.GenesisBlock)
+
+	aNode := nodeByMsgBlock(t, dag, a)
+	bNode := nodeByMsgBlock(t, dag, b)
+	cNode := nodeByMsgBlock(t, dag, c)

 	fakeBlockHeader := &wire.BlockHeader{
 		HashMerkleRoot:       &daghash.ZeroHash,
@@ -602,19 +583,19 @@ func TestValidateParents(t *testing.T) {
 	}

 	// Check direct parents relation
-	err := validateParents(fakeBlockHeader, setFromSlice(a, b))
+	err = dag.validateParents(fakeBlockHeader, blockSetFromSlice(aNode, bNode))
 	if err == nil {
 		t.Errorf("validateParents: `a` is a parent of `b`, so an error is expected")
 	}

 	// Check indirect parents relation
-	err = validateParents(fakeBlockHeader, setFromSlice(genesisNode, b))
+	err = dag.validateParents(fakeBlockHeader, blockSetFromSlice(dag.genesis, bNode))
 	if err == nil {
 		t.Errorf("validateParents: `genesis` and `b` are indirectly related, so an error is expected")
 	}

 	// Check parents with no relation
-	err = validateParents(fakeBlockHeader, setFromSlice(b, c))
+	err = dag.validateParents(fakeBlockHeader, blockSetFromSlice(bNode, cNode))
 	if err != nil {
 		t.Errorf("validateParents: unexpected error: %v", err)
 	}
--- a/blockdag/versionbits.go
+++ b/blockdag/versionbits.go
@@ -250,9 +250,9 @@ func (dag *BlockDAG) warnUnknownRuleActivations(node *blockNode) error {

 		case ThresholdLockedIn:
 			window := checker.MinerConfirmationWindow()
-			activationChainHeight := window - (node.chainHeight % window)
+			activationBlueScore := window - (node.blueScore % window)
 			log.Warnf("Unknown new rules are about to activate in "+
-				"%d blocks (bit %d)", activationChainHeight, bit)
+				"%d blueScore (bit %d)", activationBlueScore, bit)
 		}
 	}

--- a/blockdag/virtualblock.go
+++ b/blockdag/virtualblock.go
@@ -11,9 +11,9 @@ import (

 // virtualBlock is a virtual block whose parents are the tips of the DAG.
 type virtualBlock struct {
-	mtx      sync.Mutex
-	phantomK uint32
-	utxoSet  *FullUTXOSet
+	mtx     sync.Mutex
+	dag     *BlockDAG
+	utxoSet *FullUTXOSet
 	blockNode

 	// selectedParentChainSet is a block set that includes all the blocks
@@ -27,28 +27,18 @@ type virtualBlock struct {
 }

 // newVirtualBlock creates and returns a new VirtualBlock.
-func newVirtualBlock(tips blockSet, phantomK uint32) *virtualBlock {
+func newVirtualBlock(dag *BlockDAG, tips blockSet) *virtualBlock {
 	// The mutex is intentionally not held since this is a constructor.
 	var virtual virtualBlock
-	virtual.phantomK = phantomK
+	virtual.dag = dag
 	virtual.utxoSet = NewFullUTXOSet()
-	virtual.selectedParentChainSet = newSet()
+	virtual.selectedParentChainSet = newBlockSet()
 	virtual.selectedParentChainSlice = nil
 	virtual.setTips(tips)

 	return &virtual
 }

-// clone creates and returns a clone of the virtual block.
-func (v *virtualBlock) clone() *virtualBlock {
-	return &virtualBlock{
-		phantomK:               v.phantomK,
-		utxoSet:                v.utxoSet,
-		blockNode:              v.blockNode,
-		selectedParentChainSet: v.selectedParentChainSet,
-	}
-}
-
 // setTips replaces the tips of the virtual block with the blocks in the
 // given blockSet. This only differs from the exported version in that it
 // is up to the caller to ensure the lock is held.
@@ -56,7 +46,8 @@ func (v *virtualBlock) clone() *virtualBlock {
 // This function MUST be called with the view mutex locked (for writes).
 func (v *virtualBlock) setTips(tips blockSet) *chainUpdates {
 	oldSelectedParent := v.selectedParent
-	v.blockNode = *newBlockNode(nil, tips, v.phantomK)
+	node, _ := v.dag.newBlockNode(nil, tips)
+	v.blockNode = *node
 	return v.updateSelectedParentSet(oldSelectedParent)
 }

@@ -122,8 +113,8 @@ func (v *virtualBlock) updateSelectedParentSet(oldSelectedParent *blockNode) *ch
 // This function is safe for concurrent access.
 func (v *virtualBlock) SetTips(tips blockSet) {
 	v.mtx.Lock()
+	defer v.mtx.Unlock()
 	v.setTips(tips)
-	v.mtx.Unlock()
 }

 // addTip adds the given tip to the set of tips in the virtual block.
@@ -134,7 +125,7 @@ func (v *virtualBlock) SetTips(tips blockSet) {
 // This function MUST be called with the view mutex locked (for writes).
 func (v *virtualBlock) addTip(newTip *blockNode) *chainUpdates {
 	updatedTips := v.tips().clone()
-	for _, parent := range newTip.parents {
+	for parent := range newTip.parents {
 		updatedTips.remove(parent)
 	}

--- a/blockdag/virtualblock_test.go
+++ b/blockdag/virtualblock_test.go
@@ -5,14 +5,45 @@
 package blockdag

 import (
+	"github.com/kaspanet/kaspad/dagconfig"
+	"github.com/kaspanet/kaspad/util"
 	"reflect"
 	"testing"
 )

+func buildNode(t *testing.T, dag *BlockDAG, parents blockSet) *blockNode {
+	block, err := PrepareBlockForTest(dag, parents.hashes(), nil)
+	if err != nil {
+		t.Fatalf("error in PrepareBlockForTest: %s", err)
+	}
+	utilBlock := util.NewBlock(block)
+	isOrphan, isDelayed, err := dag.ProcessBlock(utilBlock, BFNoPoWCheck)
+	if err != nil {
+		t.Fatalf("unexpected error in ProcessBlock: %s", err)
+	}
+	if isDelayed {
+		t.Fatalf("block is too far in the future")
+	}
+	if isOrphan {
+		t.Fatalf("block was unexpectedly orphan")
+	}
+	return nodeByMsgBlock(t, dag, block)
+}
+
 // TestVirtualBlock ensures that VirtualBlock works as expected.
 func TestVirtualBlock(t *testing.T) {
-	phantomK := uint32(1)
-	buildNode := buildNodeGenerator(phantomK, false)
+	// Create a new database and DAG instance to run tests against.
+	params := dagconfig.SimnetParams
+	params.K = 1
+	dag, teardownFunc, err := DAGSetup("TestVirtualBlock", Config{
+		DAGParams: &params,
+	})
+	if err != nil {
+		t.Fatalf("TestVirtualBlock: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()
+
+	resetExtraNonceForTest()

 	// Create a DAG as follows:
 	// 0 <- 1 <- 2
@@ -20,13 +51,13 @@ func TestVirtualBlock(t *testing.T) {
 	//   <- 3 <- 5
 	//  \    X
 	//   <- 4 <- 6
-	node0 := buildNode(setFromSlice())
-	node1 := buildNode(setFromSlice(node0))
-	node2 := buildNode(setFromSlice(node1))
-	node3 := buildNode(setFromSlice(node0))
-	node4 := buildNode(setFromSlice(node0))
-	node5 := buildNode(setFromSlice(node3, node4))
-	node6 := buildNode(setFromSlice(node3, node4))
+	node0 := dag.genesis
+	node1 := buildNode(t, dag, blockSetFromSlice(node0))
+	node2 := buildNode(t, dag, blockSetFromSlice(node1))
+	node3 := buildNode(t, dag, blockSetFromSlice(node0))
+	node4 := buildNode(t, dag, blockSetFromSlice(node0))
+	node5 := buildNode(t, dag, blockSetFromSlice(node3, node4))
+	node6 := buildNode(t, dag, blockSetFromSlice(node3, node4))

 	// Given an empty VirtualBlock, each of the following test cases will:
 	// Set its tips to tipsToSet
@@ -44,38 +75,38 @@ func TestVirtualBlock(t *testing.T) {
 			name:                   "empty virtual",
 			tipsToSet:              []*blockNode{},
 			tipsToAdd:              []*blockNode{},
-			expectedTips:           newSet(),
+			expectedTips:           newBlockSet(),
 			expectedSelectedParent: nil,
 		},
 		{
 			name:                   "virtual with genesis tip",
 			tipsToSet:              []*blockNode{node0},
 			tipsToAdd:              []*blockNode{},
-			expectedTips:           setFromSlice(node0),
+			expectedTips:           blockSetFromSlice(node0),
 			expectedSelectedParent: node0,
 		},
 		{
 			name:                   "virtual with genesis tip, add child of genesis",
 			tipsToSet:              []*blockNode{node0},
 			tipsToAdd:              []*blockNode{node1},
-			expectedTips:           setFromSlice(node1),
+			expectedTips:           blockSetFromSlice(node1),
 			expectedSelectedParent: node1,
 		},
 		{
 			name:                   "empty virtual, add a full DAG",
 			tipsToSet:              []*blockNode{},
 			tipsToAdd:              []*blockNode{node0, node1, node2, node3, node4, node5, node6},
-			expectedTips:           setFromSlice(node2, node5, node6),
+			expectedTips:           blockSetFromSlice(node2, node5, node6),
 			expectedSelectedParent: node5,
 		},
 	}

 	for _, test := range tests {
 		// Create an empty VirtualBlock
-		virtual := newVirtualBlock(nil, phantomK)
+		virtual := newVirtualBlock(dag, nil)

 		// Set the tips. This will be the initial state
-		virtual.SetTips(setFromSlice(test.tipsToSet...))
+		virtual.SetTips(blockSetFromSlice(test.tipsToSet...))

 		// Add all blockNodes in tipsToAdd in order
 		for _, tipToAdd := range test.tipsToAdd {
@@ -100,17 +131,25 @@ func TestVirtualBlock(t *testing.T) {
 }

 func TestSelectedPath(t *testing.T) {
-	phantomK := uint32(1)
-	buildNode := buildNodeGenerator(phantomK, false)
+	// Create a new database and DAG instance to run tests against.
+	params := dagconfig.SimnetParams
+	params.K = 1
+	dag, teardownFunc, err := DAGSetup("TestSelectedPath", Config{
+		DAGParams: &params,
+	})
+	if err != nil {
+		t.Fatalf("TestSelectedPath: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()

 	// Create an empty VirtualBlock
-	virtual := newVirtualBlock(nil, phantomK)
+	virtual := newVirtualBlock(dag, nil)

-	tip := buildNode(setFromSlice())
+	tip := dag.genesis
 	virtual.AddTip(tip)
-	initialPath := setFromSlice(tip)
+	initialPath := blockSetFromSlice(tip)
 	for i := 0; i < 5; i++ {
-		tip = buildNode(setFromSlice(tip))
+		tip = buildNode(t, dag, blockSetFromSlice(tip))
 		initialPath.add(tip)
 		virtual.AddTip(tip)
 	}
@@ -118,7 +157,7 @@ func TestSelectedPath(t *testing.T) {

 	firstPath := initialPath.clone()
 	for i := 0; i < 5; i++ {
-		tip = buildNode(setFromSlice(tip))
+		tip = buildNode(t, dag, blockSetFromSlice(tip))
 		firstPath.add(tip)
 		virtual.AddTip(tip)
 	}
@@ -136,7 +175,7 @@ func TestSelectedPath(t *testing.T) {
 	secondPath := initialPath.clone()
 	tip = initialTip
 	for i := 0; i < 100; i++ {
-		tip = buildNode(setFromSlice(tip))
+		tip = buildNode(t, dag, blockSetFromSlice(tip))
 		secondPath.add(tip)
 		virtual.AddTip(tip)
 	}
@@ -154,7 +193,7 @@ func TestSelectedPath(t *testing.T) {

 	tip = initialTip
 	for i := 0; i < 3; i++ {
-		tip = buildNode(setFromSlice(tip))
+		tip = buildNode(t, dag, blockSetFromSlice(tip))
 		virtual.AddTip(tip)
 	}
 	// Because we added a very short chain, the selected path should not be affected.
@@ -170,41 +209,50 @@ func TestSelectedPath(t *testing.T) {
 	}

 	// We call updateSelectedParentSet manually without updating the tips, to check if it panics
-	virtual2 := newVirtualBlock(nil, phantomK)
+	virtual2 := newVirtualBlock(dag, nil)
 	defer func() {
 		if r := recover(); r == nil {
 			t.Fatalf("updateSelectedParentSet didn't panic")
 		}
 	}()
-	virtual2.updateSelectedParentSet(buildNode(setFromSlice()))
+	virtual2.updateSelectedParentSet(buildNode(t, dag, blockSetFromSlice()))
 }

 func TestChainUpdates(t *testing.T) {
-	phantomK := uint32(1)
-	buildNode := buildNodeGenerator(phantomK, false)
-	genesis := buildNode(setFromSlice())
+	// Create a new database and DAG instance to run tests against.
+	params := dagconfig.SimnetParams
+	params.K = 1
+	dag, teardownFunc, err := DAGSetup("TestChainUpdates", Config{
+		DAGParams: &params,
+	})
+	if err != nil {
+		t.Fatalf("TestChainUpdates: Failed to setup DAG instance: %s", err)
+	}
+	defer teardownFunc()
+
+	genesis := dag.genesis

 	// Create a chain to be removed
 	var toBeRemovedNodes []*blockNode
 	toBeRemovedTip := genesis
 	for i := 0; i < 5; i++ {
-		toBeRemovedTip = buildNode(setFromSlice(toBeRemovedTip))
+		toBeRemovedTip = buildNode(t, dag, blockSetFromSlice(toBeRemovedTip))
 		toBeRemovedNodes = append(toBeRemovedNodes, toBeRemovedTip)
 	}

 	// Create a VirtualBlock with the toBeRemoved chain
-	virtual := newVirtualBlock(setFromSlice(toBeRemovedNodes...), phantomK)
+	virtual := newVirtualBlock(dag, blockSetFromSlice(toBeRemovedNodes...))

 	// Create a chain to be added
 	var toBeAddedNodes []*blockNode
 	toBeAddedTip := genesis
 	for i := 0; i < 8; i++ {
-		toBeAddedTip = buildNode(setFromSlice(toBeAddedTip))
+		toBeAddedTip = buildNode(t, dag, blockSetFromSlice(toBeAddedTip))
 		toBeAddedNodes = append(toBeAddedNodes, toBeAddedTip)
 	}

 	// Set the virtual tip to be the tip of the toBeAdded chain
-	chainUpdates := virtual.setTips(setFromSlice(toBeAddedTip))
+	chainUpdates := virtual.setTips(blockSetFromSlice(toBeAddedTip))

 	// Make sure that the removed blocks are as expected (in reverse order)
 	if len(chainUpdates.removedChainBlockHashes) != len(toBeRemovedNodes) {
--- a/cmd/addblock/addblock.go
+++ b/cmd/addblock/addblock.go
@@ -5,6 +5,7 @@
 package main

 import (
+	"github.com/pkg/errors"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -16,28 +17,29 @@ import (
 )

 const (
-	// blockDbNamePrefix is the prefix for the kaspad block database.
-	blockDbNamePrefix = "blocks"
+	// blockDBNamePrefix is the prefix for the kaspad block database.
+	blockDBNamePrefix = "blocks"
 )

 var (
 	cfg   *ConfigFlags
-	log   logs.Logger
+	log   *logs.Logger
 	spawn func(func())
 )

 // loadBlockDB opens the block database and returns a handle to it.
 func loadBlockDB() (database.DB, error) {
 	// The database name is based on the database type.
-	dbName := blockDbNamePrefix + "_" + cfg.DbType
+	dbName := blockDBNamePrefix + "_" + cfg.DBType
 	dbPath := filepath.Join(cfg.DataDir, dbName)

 	log.Infof("Loading block database from '%s'", dbPath)
-	db, err := database.Open(cfg.DbType, dbPath, ActiveConfig().NetParams().Net)
+	db, err := database.Open(cfg.DBType, dbPath, ActiveConfig().NetParams().Net)
 	if err != nil {
 		// Return the error if it's not because the database doesn't
 		// exist.
-		if dbErr, ok := err.(database.Error); !ok || dbErr.ErrorCode !=
+		var dbErr database.Error
+		if ok := errors.As(err, &dbErr); !ok || dbErr.ErrorCode !=
 			database.ErrDbDoesNotExist {

 			return nil, err
@@ -48,7 +50,7 @@ func loadBlockDB() (database.DB, error) {
 		if err != nil {
 			return nil, err
 		}
-		db, err = database.Create(cfg.DbType, dbPath, ActiveConfig().NetParams().Net)
+		db, err = database.Create(cfg.DBType, dbPath, ActiveConfig().NetParams().Net)
 		if err != nil {
 			return nil, err
 		}
--- a/cmd/addblock/config.go
+++ b/cmd/addblock/config.go
@@ -19,7 +19,7 @@ import (
 )

 const (
-	defaultDbType   = "ffldb"
+	defaultDBType   = "ffldb"
 	defaultDataFile = "bootstrap.dat"
 	defaultProgress = 10
 )
@@ -40,12 +40,11 @@ func ActiveConfig() *ConfigFlags {
 //
 // See loadConfig for details on the configuration load process.
 type ConfigFlags struct {
-	DataDir   string `short:"b" long:"datadir" description:"Location of the kaspad data directory"`
-	DbType    string `long:"dbtype" description:"Database backend to use for the Block DAG"`
-	InFile    string `short:"i" long:"infile" description:"File containing the block(s)"`
-	TxIndex   bool   `long:"txindex" description:"Build a full hash-based transaction index which makes all transactions available via the getrawtransaction RPC"`
-	AddrIndex bool   `long:"addrindex" description:"Build a full address-based transaction index which makes the searchrawtransactions RPC available"`
-	Progress  int    `short:"p" long:"progress" description:"Show a progress message each time this number of seconds have passed -- Use 0 to disable progress announcements"`
+	DataDir         string `short:"b" long:"datadir" description:"Location of the kaspad data directory"`
+	DBType          string `long:"dbtype" description:"Database backend to use for the Block DAG"`
+	InFile          string `short:"i" long:"infile" description:"File containing the block(s)"`
+	Progress        int    `short:"p" long:"progress" description:"Show a progress message each time this number of seconds have passed -- Use 0 to disable progress announcements"`
+	AcceptanceIndex bool   `long:"acceptanceindex" description:"Maintain a full hash-based acceptance index which makes the getChainFromBlock RPC available"`
 	config.NetworkFlags
 }

@@ -75,7 +74,7 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	// Default config.
 	activeConfig = &ConfigFlags{
 		DataDir:  defaultDataDir,
-		DbType:   defaultDbType,
+		DBType:   defaultDBType,
 		InFile:   defaultDataFile,
 		Progress: defaultProgress,
 	}
@@ -84,7 +83,8 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	parser := flags.NewParser(&activeConfig, flags.Default)
 	remainingArgs, err := parser.Parse()
 	if err != nil {
-		if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp {
+		var flagsErr *flags.Error
+		if ok := errors.As(err, &flagsErr); !ok || flagsErr.Type != flags.ErrHelp {
 			parser.WriteHelp(os.Stderr)
 		}
 		return nil, nil, err
@@ -96,10 +96,10 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	}

 	// Validate database type.
-	if !validDbType(activeConfig.DbType) {
+	if !validDbType(activeConfig.DBType) {
 		str := "%s: The specified database type [%s] is invalid -- " +
 			"supported types %s"
-		err := errors.Errorf(str, "loadConfig", activeConfig.DbType, strings.Join(knownDbTypes, ", "))
+		err := errors.Errorf(str, "loadConfig", activeConfig.DBType, strings.Join(knownDbTypes, ", "))
 		fmt.Fprintln(os.Stderr, err)
 		parser.WriteHelp(os.Stderr)
 		return nil, nil, err
--- a/cmd/addblock/import.go
+++ b/cmd/addblock/import.go
@@ -6,13 +6,13 @@ package main

 import (
 	"encoding/binary"
+	"github.com/kaspanet/kaspad/blockdag/indexers"
 	"github.com/pkg/errors"
 	"io"
 	"sync"
 	"time"

 	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/blockdag/indexers"
 	"github.com/kaspanet/kaspad/database"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/kaspanet/kaspad/wire"
@@ -101,14 +101,14 @@ func (bi *blockImporter) processBlock(serializedBlock []byte) (bool, error) {

 	// Skip blocks that already exist.
 	blockHash := block.Hash()
-	if bi.dag.HaveBlock(blockHash) {
+	if bi.dag.IsKnownBlock(blockHash) {
 		return false, nil
 	}

 	// Don't bother trying to process orphans.
 	parentHashes := block.MsgBlock().Header.ParentHashes
 	if len(parentHashes) > 0 {
-		if !bi.dag.HaveBlocks(parentHashes) {
+		if !bi.dag.AreKnownBlocks(parentHashes) {
 			return false, errors.Errorf("import file contains block "+
 				"%v which does not link to the available "+
 				"block DAG", parentHashes)
@@ -116,12 +116,12 @@ func (bi *blockImporter) processBlock(serializedBlock []byte) (bool, error) {
 	}

 	// Ensure the blocks follows all of the DAG rules.
-	isOrphan, delay, err := bi.dag.ProcessBlock(block,
+	isOrphan, isDelayed, err := bi.dag.ProcessBlock(block,
 		blockdag.BFFastAdd)
 	if err != nil {
 		return false, err
 	}
-	if delay != 0 {
+	if isDelayed {
 		return false, errors.Errorf("import file contains a block that is too far in the future")
 	}
 	if isOrphan {
@@ -288,28 +288,11 @@ func (bi *blockImporter) Import() chan *importResults {
 // newBlockImporter returns a new importer for the provided file reader seeker
 // and database.
 func newBlockImporter(db database.DB, r io.ReadSeeker) (*blockImporter, error) {
-	// Create the transaction and address indexes if needed.
-	//
-	// CAUTION: the txindex needs to be first in the indexes array because
-	// the addrindex uses data from the txindex during catchup. If the
-	// addrindex is run first, it may not have the transactions from the
-	// current block indexed.
+	// Create the acceptance index if needed.
 	var indexes []indexers.Indexer
-	if cfg.TxIndex || cfg.AddrIndex {
-		// Enable transaction index if address index is enabled since it
-		// requires it.
-		if !cfg.TxIndex {
-			log.Infof("Transaction index enabled because it is " +
-				"required by the address index")
-			cfg.TxIndex = true
-		} else {
-			log.Info("Transaction index is enabled")
-		}
-		indexes = append(indexes, indexers.NewTxIndex())
-	}
-	if cfg.AddrIndex {
-		log.Info("Address index is enabled")
-		indexes = append(indexes, indexers.NewAddrIndex(ActiveConfig().NetParams()))
+	if cfg.AcceptanceIndex {
+		log.Info("Acceptance index is enabled")
+		indexes = append(indexes, indexers.NewAcceptanceIndex())
 	}

 	// Create an index manager if any of the optional indexes are enabled.
--- a/cmd/addsubnetwork/addsubnetwork.go
+++ b/cmd/addsubnetwork/addsubnetwork.go
@@ -1,87 +0,0 @@
-package main
-
-import (
-	"github.com/kaspanet/kaspad/blockdag"
-	"github.com/kaspanet/kaspad/rpcclient"
-	"github.com/kaspanet/kaspad/rpcmodel"
-	"github.com/kaspanet/kaspad/util/subnetworkid"
-	"github.com/pkg/errors"
-	"time"
-)
-
-const (
-	getSubnetworkRetryDelay = 5 * time.Second
-	maxGetSubnetworkRetries = 12
-)
-
-func main() {
-	cfg, err := parseConfig()
-	if err != nil {
-		panic(errors.Errorf("error parsing command-line arguments: %s", err))
-	}
-
-	privateKey, addrPubKeyHash, err := decodeKeys(cfg)
-	if err != nil {
-		panic(errors.Errorf("error decoding public key: %s", err))
-	}
-
-	client, err := connect(cfg)
-	if err != nil {
-		panic(errors.Errorf("could not connect to RPC server: %s", err))
-	}
-	log.Infof("Connected to server %s", cfg.RPCServer)
-
-	fundingOutpoint, fundingTx, err := findUnspentTXO(cfg, client, addrPubKeyHash)
-	if err != nil {
-		panic(errors.Errorf("error finding unspent transactions: %s", err))
-	}
-	if fundingOutpoint == nil || fundingTx == nil {
-		panic(errors.Errorf("could not find any unspent transactions this for key"))
-	}
-	log.Infof("Found transaction to spend: %s:%d", fundingOutpoint.TxID, fundingOutpoint.Index)
-
-	registryTx, err := buildSubnetworkRegistryTx(cfg, fundingOutpoint, fundingTx, privateKey)
-	if err != nil {
-		panic(errors.Errorf("error building subnetwork registry tx: %s", err))
-	}
-
-	_, err = client.SendRawTransaction(registryTx, true)
-	if err != nil {
-		panic(errors.Errorf("failed sending subnetwork registry tx: %s", err))
-	}
-	log.Infof("Successfully sent subnetwork registry transaction")
-
-	subnetworkID, err := blockdag.TxToSubnetworkID(registryTx)
-	if err != nil {
-		panic(errors.Errorf("could not build subnetwork ID: %s", err))
-	}
-
-	err = waitForSubnetworkToBecomeAccepted(client, subnetworkID)
-	if err != nil {
-		panic(errors.Errorf("error waiting for subnetwork to become accepted: %s", err))
-	}
-	log.Infof("Subnetwork '%s' was successfully registered.", subnetworkID)
-}
-
-func waitForSubnetworkToBecomeAccepted(client *rpcclient.Client, subnetworkID *subnetworkid.SubnetworkID) error {
-	retries := 0
-	for {
-		_, err := client.GetSubnetwork(subnetworkID.String())
-		if err != nil {
-			if rpcError, ok := err.(*rpcmodel.RPCError); ok && rpcError.Code == rpcmodel.ErrRPCSubnetworkNotFound {
-				log.Infof("Subnetwork not found")
-
-				retries++
-				if retries == maxGetSubnetworkRetries {
-					return errors.Errorf("failed to get subnetwork %d times: %s", maxGetSubnetworkRetries, err)
-				}
-
-				log.Infof("Waiting %d seconds...", int(getSubnetworkRetryDelay.Seconds()))
-				<-time.After(getSubnetworkRetryDelay)
-				continue
-			}
-			return errors.Errorf("failed getting subnetwork: %s", err)
-		}
-		return nil
-	}
-}
--- a/cmd/addsubnetwork/config.go
+++ b/cmd/addsubnetwork/config.go
@@ -1,71 +0,0 @@
-package main
-
-import (
-	"github.com/jessevdk/go-flags"
-	"github.com/kaspanet/kaspad/config"
-	"github.com/pkg/errors"
-)
-
-var activeConfig *ConfigFlags
-
-// ActiveConfig returns the active configuration struct
-func ActiveConfig() *ConfigFlags {
-	return activeConfig
-}
-
-// ConfigFlags holds the configurations set by the command line argument
-type ConfigFlags struct {
-	PrivateKey    string `short:"k" long:"private-key" description:"Private key" required:"true"`
-	RPCUser       string `short:"u" long:"rpcuser" description:"RPC username" required:"true"`
-	RPCPassword   string `short:"P" long:"rpcpass" default-mask:"-" description:"RPC password" required:"true"`
-	RPCServer     string `short:"s" long:"rpcserver" description:"RPC server to connect to" required:"true"`
-	RPCCert       string `short:"c" long:"rpccert" description:"RPC server certificate chain for validation"`
-	DisableTLS    bool   `long:"notls" description:"Disable TLS"`
-	GasLimit      uint64 `long:"gaslimit" description:"The gas limit of the new subnetwork"`
-	RegistryTxFee uint64 `long:"regtxfee" description:"The fee for the subnetwork registry transaction"`
-	config.NetworkFlags
-}
-
-const (
-	defaultSubnetworkGasLimit = 1000
-	defaultRegistryTxFee      = 3000
-)
-
-func parseConfig() (*ConfigFlags, error) {
-	activeConfig = &ConfigFlags{}
-	parser := flags.NewParser(activeConfig, flags.PrintErrors|flags.HelpFlag)
-	_, err := parser.Parse()
-
-	if err != nil {
-		return nil, err
-	}
-
-	if activeConfig.RPCCert == "" && !activeConfig.DisableTLS {
-		return nil, errors.New("--notls has to be disabled if --cert is used")
-	}
-
-	if activeConfig.RPCCert != "" && activeConfig.DisableTLS {
-		return nil, errors.New("--cert should be omitted if --notls is used")
-	}
-
-	err = activeConfig.ResolveNetwork(parser)
-	if err != nil {
-		return nil, err
-	}
-
-	if activeConfig.GasLimit < 0 {
-		return nil, errors.Errorf("gaslimit may not be smaller than 0")
-	}
-	if activeConfig.GasLimit == 0 {
-		activeConfig.GasLimit = defaultSubnetworkGasLimit
-	}
-
-	if activeConfig.RegistryTxFee < 0 {
-		return nil, errors.Errorf("regtxfee may not be smaller than 0")
-	}
-	if activeConfig.RegistryTxFee == 0 {
-		activeConfig.RegistryTxFee = defaultRegistryTxFee
-	}
-
-	return activeConfig, nil
-}
--- a/cmd/addsubnetwork/connect.go
+++ b/cmd/addsubnetwork/connect.go
@@ -1,37 +0,0 @@
-package main
-
-import (
-	"github.com/kaspanet/kaspad/rpcclient"
-	"github.com/pkg/errors"
-	"io/ioutil"
-)
-
-func connect(cfg *ConfigFlags) (*rpcclient.Client, error) {
-	var cert []byte
-	if !cfg.DisableTLS {
-		var err error
-		cert, err = ioutil.ReadFile(cfg.RPCCert)
-		if err != nil {
-			return nil, errors.Errorf("error reading certificates file: %s", err)
-		}
-	}
-
-	connCfg := &rpcclient.ConnConfig{
-		Host:       cfg.RPCServer,
-		Endpoint:   "ws",
-		User:       cfg.RPCUser,
-		Pass:       cfg.RPCPassword,
-		DisableTLS: cfg.DisableTLS,
-	}
-
-	if !cfg.DisableTLS {
-		connCfg.Certificates = cert
-	}
-
-	client, err := rpcclient.New(connCfg, nil)
-	if err != nil {
-		return nil, errors.Errorf("error connecting to address %s: %s", cfg.RPCServer, err)
-	}
-
-	return client, nil
-}
--- a/cmd/addsubnetwork/keys.go
+++ b/cmd/addsubnetwork/keys.go
@@ -1,19 +0,0 @@
-package main
-
-import (
-	"github.com/kaspanet/kaspad/ecc"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/base58"
-)
-
-func decodeKeys(cfg *ConfigFlags) (*ecc.PrivateKey, *util.AddressPubKeyHash, error) {
-	privateKeyBytes := base58.Decode(cfg.PrivateKey)
-	privateKey, _ := ecc.PrivKeyFromBytes(ecc.S256(), privateKeyBytes)
-	serializedPrivateKey := privateKey.PubKey().SerializeCompressed()
-
-	addr, err := util.NewAddressPubKeyHashFromPublicKey(serializedPrivateKey, ActiveConfig().NetParams().Prefix)
-	if err != nil {
-		return nil, nil, err
-	}
-	return privateKey, addr, nil
-}
--- a/cmd/addsubnetwork/log.go
+++ b/cmd/addsubnetwork/log.go
@@ -1,10 +0,0 @@
-package main
-
-import (
-	"github.com/kaspanet/kaspad/logs"
-)
-
-var (
-	backendLog = logs.NewBackend()
-	log        = backendLog.Logger("ASUB")
-)
--- a/cmd/addsubnetwork/registrytx.go
+++ b/cmd/addsubnetwork/registrytx.go
@@ -1,29 +0,0 @@
-package main
-
-import (
-	"github.com/kaspanet/kaspad/ecc"
-	"github.com/kaspanet/kaspad/txscript"
-	"github.com/kaspanet/kaspad/wire"
-	"github.com/pkg/errors"
-)
-
-func buildSubnetworkRegistryTx(cfg *ConfigFlags, fundingOutpoint *wire.Outpoint, fundingTx *wire.MsgTx, privateKey *ecc.PrivateKey) (*wire.MsgTx, error) {
-	txIn := &wire.TxIn{
-		PreviousOutpoint: *fundingOutpoint,
-		Sequence:         wire.MaxTxInSequenceNum,
-	}
-	txOut := &wire.TxOut{
-		ScriptPubKey: fundingTx.TxOut[fundingOutpoint.Index].ScriptPubKey,
-		Value:        fundingTx.TxOut[fundingOutpoint.Index].Value - cfg.RegistryTxFee,
-	}
-	registryTx := wire.NewRegistryMsgTx(1, []*wire.TxIn{txIn}, []*wire.TxOut{txOut}, cfg.GasLimit)
-
-	SignatureScript, err := txscript.SignatureScript(registryTx, 0, fundingTx.TxOut[fundingOutpoint.Index].ScriptPubKey,
-		txscript.SigHashAll, privateKey, true)
-	if err != nil {
-		return nil, errors.Errorf("failed to build signature script: %s", err)
-	}
-	txIn.SignatureScript = SignatureScript
-
-	return registryTx, nil
-}
--- a/cmd/addsubnetwork/utxo.go
+++ b/cmd/addsubnetwork/utxo.go
@@ -1,112 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/hex"
-	"github.com/kaspanet/kaspad/rpcclient"
-	"github.com/kaspanet/kaspad/rpcmodel"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/wire"
-	"github.com/pkg/errors"
-)
-
-const (
-	resultsCount     = 1000
-	minConfirmations = 10
-)
-
-func findUnspentTXO(cfg *ConfigFlags, client *rpcclient.Client, addrPubKeyHash *util.AddressPubKeyHash) (*wire.Outpoint, *wire.MsgTx, error) {
-	txs, err := collectTransactions(client, addrPubKeyHash)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	utxos := buildUTXOs(txs)
-	for outpoint, tx := range utxos {
-		// Skip TXOs that can't pay for registration
-		if tx.TxOut[outpoint.Index].Value < cfg.RegistryTxFee {
-			continue
-		}
-
-		return &outpoint, tx, nil
-	}
-
-	return nil, nil, nil
-}
-
-func collectTransactions(client *rpcclient.Client, addrPubKeyHash *util.AddressPubKeyHash) ([]*wire.MsgTx, error) {
-	txs := make([]*wire.MsgTx, 0)
-	skip := 0
-	for {
-		results, err := client.SearchRawTransactionsVerbose(addrPubKeyHash, skip, resultsCount, true, false, nil)
-		if err != nil {
-			// Break when there are no further txs
-			if rpcError, ok := err.(*rpcmodel.RPCError); ok && rpcError.Code == rpcmodel.ErrRPCNoTxInfo {
-				break
-			}
-
-			return nil, err
-		}
-
-		for _, result := range results {
-			// Mempool transactions bring about unnecessary complexity, so
-			// simply don't bother processing them
-			if result.IsInMempool {
-				continue
-			}
-
-			tx, err := parseRawTransactionResult(result)
-			if err != nil {
-				return nil, errors.Errorf("failed to process SearchRawTransactionResult: %s", err)
-			}
-			if tx == nil {
-				continue
-			}
-			if !isTxMatured(tx, *result.Confirmations) {
-				continue
-			}
-
-			txs = append(txs, tx)
-		}
-
-		skip += resultsCount
-	}
-	return txs, nil
-}
-
-func parseRawTransactionResult(result *rpcmodel.SearchRawTransactionsResult) (*wire.MsgTx, error) {
-	txBytes, err := hex.DecodeString(result.Hex)
-	if err != nil {
-		return nil, errors.Errorf("failed to decode transaction bytes: %s", err)
-	}
-	var tx wire.MsgTx
-	reader := bytes.NewReader(txBytes)
-	err = tx.Deserialize(reader)
-	if err != nil {
-		return nil, errors.Errorf("failed to deserialize transaction: %s", err)
-	}
-	return &tx, nil
-}
-
-func isTxMatured(tx *wire.MsgTx, confirmations uint64) bool {
-	if !tx.IsCoinBase() {
-		return confirmations >= minConfirmations
-	}
-	return confirmations >= ActiveConfig().NetParams().BlockCoinbaseMaturity
-}
-
-func buildUTXOs(txs []*wire.MsgTx) map[wire.Outpoint]*wire.MsgTx {
-	utxos := make(map[wire.Outpoint]*wire.MsgTx)
-	for _, tx := range txs {
-		for i := range tx.TxOut {
-			outpoint := wire.NewOutpoint(tx.TxID(), uint32(i))
-			utxos[*outpoint] = tx
-		}
-	}
-	for _, tx := range txs {
-		for _, input := range tx.TxIn {
-			delete(utxos, input.PreviousOutpoint)
-		}
-	}
-	return utxos
-}
--- a/cmd/genaddr/genaddr.go
+++ b/cmd/genaddr/genaddr.go
@@ -1,35 +0,0 @@
-package main
-
-import (
-	"encoding/hex"
-	"fmt"
-	"os"
-
-	"github.com/kaspanet/kaspad/dagconfig"
-	"github.com/kaspanet/kaspad/ecc"
-	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/base58"
-)
-
-func main() {
-	activeNetParams := &dagconfig.DevNetParams
-	privateKey, err := ecc.NewPrivateKey(ecc.S256())
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Failed to generate private key: %s", err)
-		os.Exit(1)
-	}
-	fmt.Printf("\nPrivate key (base-58): %s\n", base58.Encode(privateKey.Serialize()))
-	wif, err := util.NewWIF(privateKey, activeNetParams.PrivateKeyID, true)
-	if err != nil {
-		panic(fmt.Sprintf("error generating wif: %s", err))
-	}
-	fmt.Printf("\nPrivate key wif: %s\n", wif)
-	addr, err := util.NewAddressPubKeyHashFromPublicKey(privateKey.PubKey().SerializeCompressed(), activeNetParams.Prefix)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Failed to generate p2pkh address: %s", err)
-		os.Exit(1)
-	}
-	fmt.Printf("Address: %s\n", addr)
-	hash160 := addr.Hash160()[:]
-	fmt.Printf("Hash160 of address (hex): %s\n\n", hex.EncodeToString(hash160))
-}
--- a/cmd/gencerts/gencerts.go
+++ b/cmd/gencerts/gencerts.go
@@ -6,6 +6,7 @@ package main

 import (
 	"fmt"
+	"github.com/pkg/errors"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -32,7 +33,8 @@ func main() {
 	parser := flags.NewParser(&cfg, flags.Default)
 	_, err := parser.Parse()
 	if err != nil {
-		if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp {
+		var flagsErr *flags.Error
+		if ok := errors.As(err, &flagsErr); !ok || flagsErr.Type != flags.ErrHelp {
 			parser.WriteHelp(os.Stderr)
 		}
 		return
--- a/cmd/kaspactl/config.go
+++ b/cmd/kaspactl/config.go
@@ -7,9 +7,9 @@ package main
 import (
 	"fmt"
 	"github.com/kaspanet/kaspad/config"
+	"github.com/kaspanet/kaspad/version"
 	"github.com/pkg/errors"
 	"io/ioutil"
-	"net"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -36,11 +36,6 @@ var (
 	activeConfig       *ConfigFlags
 )

-// ActiveConfig returns the active configuration struct
-func ActiveConfig() *ConfigFlags {
-	return activeConfig
-}
-
 // listCommands categorizes and lists all of the usable commands along with
 // their one-line usage.
 func listCommands() {
@@ -108,28 +103,6 @@ type ConfigFlags struct {
 	config.NetworkFlags
 }

-// normalizeAddress returns addr with the passed default port appended if
-// there is not already a port specified.
-func normalizeAddress(addr string, useTestNet, useSimNet, useDevNet bool) string {
-	_, _, err := net.SplitHostPort(addr)
-	if err != nil {
-		var defaultPort string
-		switch {
-		case useDevNet:
-			fallthrough
-		case useTestNet:
-			defaultPort = "18334"
-		case useSimNet:
-			defaultPort = "18556"
-		default:
-			defaultPort = "8334"
-		}
-
-		return net.JoinHostPort(addr, defaultPort)
-	}
-	return addr
-}
-
 // cleanAndExpandPath expands environement variables and leading ~ in the
 // passed path, cleans the result, and returns it.
 func cleanAndExpandPath(path string) string {
@@ -172,7 +145,8 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	preParser := flags.NewParser(preCfg, flags.HelpFlag)
 	_, err := preParser.Parse()
 	if err != nil {
-		if e, ok := err.(*flags.Error); ok && e.Type == flags.ErrHelp {
+		var flagsErr *flags.Error
+		if ok := errors.As(err, &flagsErr); ok && flagsErr.Type == flags.ErrHelp {
 			fmt.Fprintln(os.Stderr, err)
 			fmt.Fprintln(os.Stderr, "")
 			fmt.Fprintln(os.Stderr, "The special parameter `-` "+
@@ -188,7 +162,7 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	appName = strings.TrimSuffix(appName, filepath.Ext(appName))
 	usageMessage := fmt.Sprintf("Use %s -h to show options", appName)
 	if preCfg.ShowVersion {
-		fmt.Println(appName, "version", version())
+		fmt.Println(appName, "version", version.Version())
 		os.Exit(0)
 	}

@@ -216,7 +190,7 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	parser := flags.NewParser(activeConfig, flags.Default)
 	err = flags.NewIniParser(parser).ParseFile(preCfg.ConfigFile)
 	if err != nil {
-		if _, ok := err.(*os.PathError); !ok {
+		if pErr := &(os.PathError{}); !errors.As(err, &pErr) {
 			fmt.Fprintf(os.Stderr, "Error parsing config file: %s\n",
 				err)
 			fmt.Fprintln(os.Stderr, usageMessage)
@@ -227,7 +201,8 @@ func loadConfig() (*ConfigFlags, []string, error) {
 	// Parse command line options again to ensure they take precedence.
 	remainingArgs, err := parser.Parse()
 	if err != nil {
-		if e, ok := err.(*flags.Error); !ok || e.Type != flags.ErrHelp {
+		var flagsErr *flags.Error
+		if ok := errors.As(err, &flagsErr); !ok || flagsErr.Type != flags.ErrHelp {
 			fmt.Fprintln(os.Stderr, usageMessage)
 		}
 		return nil, nil, err
@@ -242,8 +217,10 @@ func loadConfig() (*ConfigFlags, []string, error) {

 	// Add default port to RPC server based on --testnet and --simnet flags
 	// if needed.
-	activeConfig.RPCServer = normalizeAddress(activeConfig.RPCServer, activeConfig.TestNet,
-		activeConfig.SimNet, activeConfig.DevNet)
+	activeConfig.RPCServer, err = activeConfig.NetParams().NormalizeRPCServerAddress(activeConfig.RPCServer)
+	if err != nil {
+		return nil, nil, err
+	}

 	return activeConfig, remainingArgs, nil
 }
--- a/cmd/kaspactl/httpclient.go
+++ b/cmd/kaspactl/httpclient.go
@@ -95,11 +95,12 @@ func sendPostRequest(marshalledJSON []byte, cfg *ConfigFlags) ([]byte, error) {
 	}

 	// Read the raw bytes and close the response.
-	respBytes, err := ioutil.ReadAll(httpResponse.Body)
-	httpResponse.Body.Close()
+	respBytes, err := func() ([]byte, error) {
+		defer httpResponse.Body.Close()
+		return ioutil.ReadAll(httpResponse.Body)
+	}()
 	if err != nil {
-		err = errors.Errorf("error reading json reply: %s", err)
-		return nil, err
+		return nil, errors.Wrap(err, "error reading json reply")
 	}

 	// Handle unsuccessful HTTP responses
--- a/cmd/kaspactl/kaspactl.go
+++ b/cmd/kaspactl/kaspactl.go
@@ -5,6 +5,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"github.com/pkg/errors"
 	"io"
 	"os"
 	"path/filepath"
@@ -110,9 +111,10 @@ func main() {
 		// rpcmodel.Error as it reallistcally will always be since the
 		// NewCommand function is only supposed to return errors of that
 		// type.
-		if jerr, ok := err.(rpcmodel.Error); ok {
+		var rpcModelErr rpcmodel.Error
+		if ok := errors.As(err, &rpcModelErr); ok {
 			fmt.Fprintf(os.Stderr, "%s error: %s (command code: %s)\n",
-				method, err, jerr.ErrorCode)
+				method, err, rpcModelErr.ErrorCode)
 			commandUsage(method)
 			os.Exit(1)
 		}
--- a/cmd/kaspactl/version.go
+++ b/cmd/kaspactl/version.go
@@ -1,75 +0,0 @@
-// Copyright (c) 2013 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"strings"
-)
-
-// semanticAlphabet
-const semanticAlphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-"
-
-// These constants define the application version and follow the semantic
-// versioning 2.0.0 spec (http://semver.org/).
-const (
-	appMajor uint = 0
-	appMinor uint = 12
-	appPatch uint = 0
-
-	// appPreRelease MUST only contain characters from semanticAlphabet
-	// per the semantic versioning spec.
-	appPreRelease = "beta"
-)
-
-// appBuild is defined as a variable so it can be overridden during the build
-// process with '-ldflags "-X main.appBuild foo' if needed. It MUST only
-// contain characters from semanticAlphabet per the semantic versioning spec.
-var appBuild string
-
-// version returns the application version as a properly formed string per the
-// semantic versioning 2.0.0 spec (http://semver.org/).
-func version() string {
-	// Start with the major, minor, and patch versions.
-	version := fmt.Sprintf("%d.%d.%d", appMajor, appMinor, appPatch)
-
-	// Append pre-release version if there is one. The hyphen called for
-	// by the semantic versioning spec is automatically appended and should
-	// not be contained in the pre-release string. The pre-release version
-	// is not appended if it contains invalid characters.
-	preRelease := normalizeVerString(appPreRelease)
-	if preRelease != "" {
-		version = fmt.Sprintf("%s-%s", version, preRelease)
-	}
-
-	// Append build metadata if there is any. The plus called for
-	// by the semantic versioning spec is automatically appended and should
-	// not be contained in the build metadata string. The build metadata
-	// string is not appended if it contains invalid characters.
-	build := normalizeVerString(appBuild)
-	if build != "" {
-		version = fmt.Sprintf("%s+%s", version, build)
-	}
-
-	return version
-}
-
-// normalizeVerString returns the passed string stripped of all characters which
-// are not valid according to the semantic versioning guidelines for pre-release
-// version and build metadata strings. In particular they MUST only contain
-// characters in semanticAlphabet.
-func normalizeVerString(str string) string {
-	var result bytes.Buffer
-	for _, r := range str {
-		if strings.ContainsRune(semanticAlphabet, r) {
-			// Ignoring the error here since it can only fail if
-			// the the system is out of memory and there are much
-			// bigger issues at that point.
-			_, _ = result.WriteRune(r)
-		}
-	}
-	return result.String()
-}
--- a/cmd/kaspaminer/client.go
+++ b/cmd/kaspaminer/client.go
@@ -0,0 +1,81 @@
+package main
+
+import (
+	"github.com/kaspanet/kaspad/rpcclient"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/wire"
+	"github.com/pkg/errors"
+	"io/ioutil"
+	"time"
+)
+
+type minerClient struct {
+	*rpcclient.Client
+	onBlockAdded chan struct{}
+}
+
+func newMinerClient(connCfg *rpcclient.ConnConfig) (*minerClient, error) {
+	client := &minerClient{
+		onBlockAdded: make(chan struct{}, 1),
+	}
+	notificationHandlers := &rpcclient.NotificationHandlers{
+		OnFilteredBlockAdded: func(_ uint64, header *wire.BlockHeader,
+			txs []*util.Tx) {
+			client.onBlockAdded <- struct{}{}
+		},
+	}
+	var err error
+	client.Client, err = rpcclient.New(connCfg, notificationHandlers)
+	if err != nil {
+		return nil, errors.Errorf("Error connecting to address %s: %s", connCfg.Host, err)
+	}
+
+	if err = client.NotifyBlocks(); err != nil {
+		return nil, errors.Errorf("Error while registering client %s for block notifications: %s", client.Host(), err)
+	}
+	return client, nil
+}
+
+func connectToServer(cfg *configFlags) (*minerClient, error) {
+	cert, err := readCert(cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	rpcAddr, err := cfg.NetParams().NormalizeRPCServerAddress(cfg.RPCServer)
+	if err != nil {
+		return nil, err
+	}
+
+	connCfg := &rpcclient.ConnConfig{
+		Host:           rpcAddr,
+		Endpoint:       "ws",
+		User:           cfg.RPCUser,
+		Pass:           cfg.RPCPassword,
+		DisableTLS:     cfg.DisableTLS,
+		RequestTimeout: time.Second * 10,
+		Certificates:   cert,
+	}
+
+	client, err := newMinerClient(connCfg)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Infof("Connected to server %s", client.Host())
+
+	return client, nil
+}
+
+func readCert(cfg *configFlags) ([]byte, error) {
+	if cfg.DisableTLS {
+		return nil, nil
+	}
+
+	cert, err := ioutil.ReadFile(cfg.RPCCert)
+	if err != nil {
+		return nil, errors.Errorf("Error reading certificates file: %s", err)
+	}
+
+	return cert, nil
+}
--- a/Show More
+++ b/Show More