[NOD-1388] Use isInPastOfAny in addValidTip instead of just checking the parents (#930 )

* [NOD-1388] Write a deterministic test that reproduces the crash. * [NOD-1388] Fix a typo. * [NOD-1388] Use isInPastOfAny in addValidTip instead of just checking the parents. * [NOD-1388] Add a json representation of the crashing DAG. * [NOD-1388] Remove crash_test.go. * [NOD-1388] Change variable name, add a comment. * [NOD-1388] Rephrase a comment.
[NOD-1390] Add timeout to kaspactl (#929 )
2026-02-21 19:22:53 +00:00 · 2020-09-16 12:06:09 +03:00 · 2020-09-14 12:33:42 +03:00 · 2020-09-14 12:19:46 +03:00 · 2020-09-14 12:18:51 +03:00 · 2020-09-13 18:12:13 +03:00
1009 changed files with 72467 additions and 127801 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -2,7 +2,7 @@
 *~

 # Databases
-btcd.db
+kaspad.db
 *-shm
 *-wal

@@ -38,6 +38,7 @@ _testmain.go
 .vscode
 debug
 debug.test
+__debug_bin

 # CI
 version.txt
--- 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, testnet3, 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
-      testnet3 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/Gopkg.lock
+++ b/Gopkg.lock
@@ -1,105 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  name = "bou.ke/monkey"
-  packages = ["."]
-  revision = "bdf6dea004c6fd1cdf4b25da8ad45a606c09409a"
-  version = "v1.0.1"
-
-[[projects]]
-  name = "github.com/aead/siphash"
-  packages = ["."]
-  revision = "83563a290f60225eb120d724600b9690c3fb536f"
-  version = "v1.0.1"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/btcsuite/btclog"
-  packages = ["."]
-  revision = "84c8d2346e9fc8c7b947e243b9c24e6df9fd206a"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/btcsuite/go-socks"
-  packages = ["socks"]
-  revision = "4720035b7bfd2a9bb130b1c184f8bbe41b6f0d0f"
-
-[[projects]]
-  name = "github.com/btcsuite/goleveldb"
-  packages = ["leveldb","leveldb/cache","leveldb/comparer","leveldb/errors","leveldb/filter","leveldb/iterator","leveldb/journal","leveldb/memdb","leveldb/opt","leveldb/storage","leveldb/table","leveldb/util"]
-  revision = "3fd0373267b6461dbefe91cef614278064d05465"
-  version = "v1.0.0"
-
-[[projects]]
-  name = "github.com/btcsuite/snappy-go"
-  packages = ["."]
-  revision = "b3db38edf0a9a11a115eb6b022d8c946024a9ac0"
-  version = "v1.0.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/btcsuite/websocket"
-  packages = ["."]
-  revision = "31079b6807923eb23992c421b114992b95131b55"
-
-[[projects]]
-  name = "github.com/btcsuite/winsvc"
-  packages = ["eventlog","mgr","registry","svc","winapi"]
-  revision = "f8fb11f83f7e860e3769a08e6811d1b399a43722"
-  version = "v1.0.0"
-
-[[projects]]
-  name = "github.com/davecgh/go-spew"
-  packages = ["spew"]
-  revision = "8991bc29aa16c548c550c7ff78260e27b9ab7c73"
-  version = "v1.1.1"
-
-[[projects]]
-  name = "github.com/jessevdk/go-flags"
-  packages = ["."]
-  revision = "c6ca198ec95c841fdb89fc0de7496fed11ab854e"
-  version = "v1.4.0"
-
-[[projects]]
-  name = "github.com/jrick/logrotate"
-  packages = ["rotator"]
-  revision = "a93b200c26cbae3bb09dd0dc2c7c7fe1468a034a"
-  version = "v1.0.0"
-
-[[projects]]
-  branch = "master"
-  name = "github.com/kkdai/bstream"
-  packages = ["."]
-  revision = "b3251f7901ec4dd4ec66b3210e8f4bd5c0f1c5a3"
-
-[[projects]]
-  name = "github.com/miekg/dns"
-  packages = ["."]
-  revision = "cc8cd02140663157ce797c6650488d6c8563f31f"
-  version = "v1.1.6"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/crypto"
-  packages = ["ed25519","ed25519/internal/edwards25519","ripemd160"]
-  revision = "c2843e01d9a2bc60bb26ad24e09734fdc2d9ec58"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/net"
-  packages = ["bpf","internal/iana","internal/socket","ipv4","ipv6"]
-  revision = "d8887717615a059821345a5c23649351b52a1c0b"
-
-[[projects]]
-  branch = "master"
-  name = "golang.org/x/sys"
-  packages = ["unix"]
-  revision = "fead79001313d15903fb4605b4a1b781532cd93e"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  inputs-digest = "00392a00928f96fc94e2c8c65ce3a98cc6f5e2f93dda64d3c4502f2f38026e96"
-  solver-name = "gps-cdcl"
-  solver-version = 1
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -1,78 +0,0 @@
-
-# Gopkg.toml example
-#
-# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
-# for detailed Gopkg.toml documentation.
-#
-# required = ["github.com/user/thing/cmd/thing"]
-# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
-#
-# [[constraint]]
-#   name = "github.com/user/project"
-#   version = "1.0.0"
-#
-# [[constraint]]
-#   name = "github.com/user/project2"
-#   branch = "dev"
-#   source = "github.com/myfork/project2"
-#
-# [[override]]
-#  name = "github.com/x/y"
-#  version = "2.4.0"
-
-
-[[constraint]]
-  name = "bou.ke/monkey"
-  version = "1.0.1"
-
-[[constraint]]
-  name = "github.com/aead/siphash"
-  version = "1.0.1"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/btcsuite/btclog"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/btcsuite/go-socks"
-
-[[constraint]]
-  name = "github.com/btcsuite/goleveldb"
-  version = "1.0.0"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/btcsuite/websocket"
-
-[[constraint]]
-  name = "github.com/btcsuite/winsvc"
-  version = "1.0.0"
-
-[[constraint]]
-  name = "github.com/davecgh/go-spew"
-  version = "1.1.1"
-
-[[constraint]]
-  name = "github.com/jessevdk/go-flags"
-  version = "1.4.0"
-
-[[constraint]]
-  name = "github.com/jrick/logrotate"
-  version = "1.0.0"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/kkdai/bstream"
-
-[[constraint]]
-  name = "github.com/miekg/dns"
-  version = "1.1.6"
-
-[[constraint]]
-  branch = "master"
-  name = "golang.org/x/crypto"
-
-[prune]
-  go-tests = true
-  unused-packages = true
--- 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/3
+++ b/3
@@ -1,8 +1,9 @@
 ISC License

-Copyright (c) 2018-2019 DAGLabs
+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
@@ -1,49 +1,24 @@
-btcd
+
+Kaspad
+====
+Warning: This is pre-alpha software. There's no guarantee anything works.
 ====

-[![Build Status](https://travis-ci.org/btcsuite/btcd.png?branch=master)](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/daglabs/btcd)
+[![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)

-btcd is an alternative full node bitcoin implementation written in Go (golang).
+Kaspad is the reference full node Kaspa implementation written in Go (golang).

-This project is currently under active development and is in a Beta state.  It
-is extremely stable and has been in production use since October 2013.
-
-It properly downloads, validates, and serves the block chain using the exact
-rules (including consensus bugs) for block acceptance as Bitcoin Core.  We have
-taken great care to avoid btcd causing a fork to the block chain.  It includes a
-full block validation testing framework which contains all of the 'official'
-block acceptance tests (and some additional ones) that is run on every pull
-request to help ensure it properly follows consensus.  Also, it passes all of
-the JSON test data in the Bitcoin Core code.
-
-It also properly relays newly mined blocks, maintains a transaction pool, and
-relays individual transactions that have not yet made it into a block.  It
-ensures all individual transactions admitted to the pool follow the rules
-required by the block chain and also includes more strict checks which filter
-transactions based on miner requirements ("standard" transactions).
-
-One key difference between btcd and Bitcoin Core is that btcd does *NOT* include
-wallet functionality and this was a very intentional design decision.  See the
-blog entry [here](https://blog.conformal.com/btcd-not-your-moms-bitcoin-daemon)
-for more details.  This means you can't actually make or receive payments
-directly with btcd.  That functionality is provided by the
-[btcwallet](https://github.com/btcsuite/btcwallet) and
-[Paymetheus](https://github.com/btcsuite/Paymetheus) (Windows-only) projects
-which are both under active development.
+This project is currently under active development and is in a pre-Alpha state. 
+Some things still don't work and APIs are far from finalized. The code is provided for reference only.

 ## Requirements

-[Go](http://golang.org) 1.8 or newer.
+Latest version of [Go](http://golang.org) (currently 1.13).

 ## Installation

-#### Windows - MSI Available
-
-https://github.com/daglabs/btcd/releases
-
-#### Linux/BSD/MacOSX/POSIX - Build from Source
+#### Build from Source

 - Install Go according to the installation instructions here:
  http://golang.org/doc/install
@@ -55,92 +30,48 @@ $ go version
 $ go env GOROOT GOPATH
 ```

-NOTE: The `GOROOT` and `GOPATH` above must not be the same path.  It is
+NOTE: The `GOROOT` and `GOPATH` above must not be the same path. It is
 recommended that `GOPATH` is set to a directory in your home directory such as
-`~/goprojects` to avoid write permission issues.  It is also recommended to add
+`~/dev/go` to avoid write permission issues. It is also recommended to add
 `$GOPATH/bin` to your `PATH` at this point.

- Run the following commands to obtain btcd, all dependencies, and install it:
+- Run the following commands to obtain and install kaspad including all dependencies:

 ```bash
-$ # Install dep: https://golang.github.io/dep/docs/installation.html
-$ git clone https://github.com/daglabs/btcd $GOPATH/src/github.com/daglabs/btcd
-$ cd $GOPATH/src/github.com/daglabs/btcd
-$ dep ensure
+$ git clone https://github.com/kaspanet/kaspad $GOPATH/src/github.com/kaspanet/kaspad
+$ cd $GOPATH/src/github.com/kaspanet/kaspad
 $ go install . ./cmd/...
 ```

- btcd (and utilities) will now be installed in ```$GOPATH/bin```.  If you did
+- Kaspad (and utilities) should now be installed in `$GOPATH/bin`. If you did
  not already add the bin directory to your system path during Go installation,
-  we recommend you do so now.
+  you are encouraged to do so now.

-## Updating
-
-#### Windows
-
-Install a newer MSI
-
-#### Linux/BSD/MacOSX/POSIX - Build from Source
-
- Run the following commands to update btcd, all dependencies, and install it:
-
-```bash
-$ cd $GOPATH/src/github.com/daglabs/btcd
-$ git pull && dep ensure
-$ go install . ./cmd/...
-```

 ## Getting Started

-btcd has several configuration options available to tweak how it runs, but all
-of the basic operations described in the intro section work with zero
-configuration.
-
-#### Windows (Installed from MSI)
-
-Launch btcd from your Start menu.
+Kaspad has several configuration options available to tweak how it runs, but all
+of the basic operations work with zero configuration.

 #### Linux/BSD/POSIX/Source

 ```bash
-$ ./btcd
+$ ./kaspad
 ```

-## IRC
-
- irc.freenode.net
- channel #btcd
- [webchat](https://webchat.freenode.net/?channels=btcd)
+## Discord
+Join our discord server using the following link: https://discord.gg/WmGhhzk

 ## Issue Tracker

-The [integrated github issue tracker](https://github.com/daglabs/btcd/issues)
+The [integrated github issue tracker](https://github.com/kaspanet/kaspad/issues)
 is used for this project.

 ## Documentation

-The documentation is a work-in-progress.  It is located in the [docs](https://github.com/daglabs/btcd/tree/master/docs) folder.
-
-## GPG Verification Key
-
-All official release tags are signed by Conformal so users can ensure the code
-has not been tampered with and is coming from the btcsuite developers.  To
-verify the signature perform the following:
-
- Download the Conformal public key:
-  https://raw.githubusercontent.com/btcsuite/btcd/master/release/GIT-GPG-KEY-conformal.txt
-
- Import the public key into your GPG keyring:
-  ```bash
-  gpg --import GIT-GPG-KEY-conformal.txt
-  ```
-
- Verify the release tag with the following command where `TAG_NAME` is a
-  placeholder for the specific tag:
-  ```bash
-  git tag -v TAG_NAME
-  ```
+The documentation is a work-in-progress. It is located in the [docs](https://github.com/kaspanet/kaspad/tree/master/docs) folder.

 ## License

-btcd 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
--- 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,38 +0,0 @@
-// 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 Bitcoin address manager.
-
-Address Manager Overview
-
-In order maintain the peer-to-peer Bitcoin network, there needs to be a source
-of addresses to connect to as nodes come and go.  The Bitcoin protocol provides
-the getaddr and addr messages to allow peers to communicate known addresses with
-each other.  However, there needs to a mechanism to store those results and
-select peers from them.  It is also important to note that remote peers can't
-be trusted to send valid peers nor attempt to provide you with only peers they
-control with malicious intent.
-
-With that in mind, this package provides a concurrency safe address manager for
-caching and selecting peers in a non-deterministic manner.  The general idea is
-the caller adds addresses to the address manager and notifies it when addresses
-are connected, known good, and attempted.  The caller also requests addresses as
-it needs them.
-
-The address manager internally segregates the addresses into groups and
-non-deterministically selects groups in a cryptographically random manner.  This
-reduce the chances multiple addresses from the same nets are selected which
-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.
-*/
-package addrmgr
--- a/addrmgr/internal_test.go
+++ b/addrmgr/internal_test.go
@@ -1,25 +0,0 @@
-// Copyright (c) 2013-2015 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package addrmgr
-
-import (
-	"time"
-
-	"github.com/daglabs/btcd/wire"
-)
-
-func TstKnownAddressIsBad(ka *KnownAddress) bool {
-	return ka.isBad()
-}
-
-func TstKnownAddressChance(ka *KnownAddress) float64 {
-	return ka.chance()
-}
-
-func TstNewKnownAddress(na *wire.NetAddress, attempts int,
-	lastattempt, lastsuccess time.Time, tried bool, refs int) *KnownAddress {
-	return &KnownAddress{na: na, attempts: attempts, lastattempt: lastattempt,
-		lastsuccess: lastsuccess, tried: tried, refs: refs}
-}
--- a/addrmgr/knownaddress_test.go
+++ b/addrmgr/knownaddress_test.go
@@ -1,114 +0,0 @@
-// Copyright (c) 2013-2015 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package addrmgr_test
-
-import (
-	"math"
-	"testing"
-	"time"
-
-	"github.com/daglabs/btcd/addrmgr"
-	"github.com/daglabs/btcd/wire"
-)
-
-func TestChance(t *testing.T) {
-	now := time.Unix(time.Now().Unix(), 0)
-	var tests = []struct {
-		addr     *addrmgr.KnownAddress
-		expected float64
-	}{
-		{
-			//Test normal case
-			addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
-				0, time.Now().Add(-30*time.Minute), time.Now(), false, 0),
-			1.0,
-		}, {
-			//Test case in which lastseen < 0
-			addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(20 * time.Second)},
-				0, time.Now().Add(-30*time.Minute), time.Now(), false, 0),
-			1.0,
-		}, {
-			//Test case in which lastattempt < 0
-			addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
-				0, time.Now().Add(30*time.Minute), time.Now(), false, 0),
-			1.0 * .01,
-		}, {
-			//Test case in which lastattempt < ten minutes
-			addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
-				0, time.Now().Add(-5*time.Minute), time.Now(), false, 0),
-			1.0 * .01,
-		}, {
-			//Test case with several failed attempts.
-			addrmgr.TstNewKnownAddress(&wire.NetAddress{Timestamp: now.Add(-35 * time.Second)},
-				2, time.Now().Add(-30*time.Minute), time.Now(), false, 0),
-			1 / 1.5 / 1.5,
-		},
-	}
-
-	err := .0001
-	for i, test := range tests {
-		chance := addrmgr.TstKnownAddressChance(test.addr)
-		if math.Abs(test.expected-chance) >= err {
-			t.Errorf("case %d: got %f, expected %f", i, chance, test.expected)
-		}
-	}
-}
-
-func TestIsBad(t *testing.T) {
-	now := time.Unix(time.Now().Unix(), 0)
-	future := now.Add(35 * time.Minute)
-	monthOld := now.Add(-43 * time.Hour * 24)
-	secondsOld := now.Add(-2 * time.Second)
-	minutesOld := now.Add(-27 * time.Minute)
-	hoursOld := now.Add(-5 * time.Hour)
-	zeroTime := time.Time{}
-
-	futureNa := &wire.NetAddress{Timestamp: future}
-	minutesOldNa := &wire.NetAddress{Timestamp: minutesOld}
-	monthOldNa := &wire.NetAddress{Timestamp: monthOld}
-	currentNa := &wire.NetAddress{Timestamp: secondsOld}
-
-	//Test addresses that have been tried in the last minute.
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(futureNa, 3, secondsOld, zeroTime, false, 0)) {
-		t.Errorf("test case 1: addresses that have been tried in the last minute are not bad.")
-	}
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(monthOldNa, 3, secondsOld, zeroTime, false, 0)) {
-		t.Errorf("test case 2: addresses that have been tried in the last minute are not bad.")
-	}
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(currentNa, 3, secondsOld, zeroTime, false, 0)) {
-		t.Errorf("test case 3: addresses that have been tried in the last minute are not bad.")
-	}
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(currentNa, 3, secondsOld, monthOld, true, 0)) {
-		t.Errorf("test case 4: addresses that have been tried in the last minute are not bad.")
-	}
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(currentNa, 2, secondsOld, secondsOld, true, 0)) {
-		t.Errorf("test case 5: addresses that have been tried in the last minute are not bad.")
-	}
-
-	//Test address that claims to be from the future.
-	if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(futureNa, 0, minutesOld, hoursOld, true, 0)) {
-		t.Errorf("test case 6: addresses that claim to be from the future are bad.")
-	}
-
-	//Test address that has not been seen in over a month.
-	if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(monthOldNa, 0, minutesOld, hoursOld, true, 0)) {
-		t.Errorf("test case 7: addresses more than a month old are bad.")
-	}
-
-	//It has failed at least three times and never succeeded.
-	if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(minutesOldNa, 3, minutesOld, zeroTime, true, 0)) {
-		t.Errorf("test case 8: addresses that have never succeeded are bad.")
-	}
-
-	//It has failed ten times in the last week
-	if !addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(minutesOldNa, 10, minutesOld, monthOld, true, 0)) {
-		t.Errorf("test case 9: addresses that have not succeeded in too long are bad.")
-	}
-
-	//Test an address that should work.
-	if addrmgr.TstKnownAddressIsBad(addrmgr.TstNewKnownAddress(minutesOldNa, 2, minutesOld, hoursOld, true, 0)) {
-		t.Errorf("test case 10: This should be a valid address.")
-	}
-}
--- a/addrmgr/log.go
+++ b/addrmgr/log.go
@@ -1,19 +0,0 @@
-// 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 addrmgr
-
-import (
-	"github.com/btcsuite/btclog"
-	"github.com/daglabs/btcd/logger"
-)
-
-// log is a logger that is initialized with no output filters.  This
-// means the package will not perform any logging by default until the caller
-// requests it.
-var log btclog.Logger
-
-func init() {
-	log, _ = logger.Get(logger.SubsystemTags.ADXR)
-}
--- 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/app/app.go
+++ b/app/app.go
@@ -0,0 +1,260 @@
+package app
+
+import (
+	"fmt"
+	"sync/atomic"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol"
+	"github.com/kaspanet/kaspad/app/rpc"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain/blockdag/indexers"
+	"github.com/kaspanet/kaspad/domain/mempool"
+	"github.com/kaspanet/kaspad/domain/mining"
+	"github.com/kaspanet/kaspad/domain/txscript"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
+	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/dnsseed"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/panics"
+)
+
+// App is a wrapper for all the kaspad services
+type App struct {
+	cfg               *config.Config
+	addressManager    *addressmanager.AddressManager
+	protocolManager   *protocol.Manager
+	rpcManager        *rpc.Manager
+	connectionManager *connmanager.ConnectionManager
+	netAdapter        *netadapter.NetAdapter
+
+	started, shutdown int32
+}
+
+// Start launches all the kaspad services.
+func (a *App) Start() {
+	// Already started?
+	if atomic.AddInt32(&a.started, 1) != 1 {
+		return
+	}
+
+	log.Trace("Starting kaspad")
+
+	err := a.netAdapter.Start()
+	if err != nil {
+		panics.Exit(log, fmt.Sprintf("Error starting the net adapter: %+v", err))
+	}
+
+	a.maybeSeedFromDNS()
+
+	a.connectionManager.Start()
+}
+
+// Stop gracefully shuts down all the kaspad services.
+func (a *App) Stop() {
+	// Make sure this only happens once.
+	if atomic.AddInt32(&a.shutdown, 1) != 1 {
+		log.Infof("Kaspad is already in the process of shutting down")
+		return
+	}
+
+	log.Warnf("Kaspad shutting down")
+
+	a.connectionManager.Stop()
+
+	err := a.netAdapter.Stop()
+	if err != nil {
+		log.Errorf("Error stopping the net adapter: %+v", err)
+	}
+
+	err = a.addressManager.Stop()
+	if err != nil {
+		log.Errorf("Error stopping address manager: %s", err)
+	}
+
+	return
+}
+
+// New returns a new App instance configured to listen on addr for the
+// kaspa network type specified by dagParams. Use start to begin accepting
+// connections from peers.
+func New(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrupt <-chan struct{}) (*App, error) {
+	indexManager, acceptanceIndex := setupIndexes(cfg)
+
+	sigCache := txscript.NewSigCache(cfg.SigCacheMaxSize)
+
+	// Create a new block DAG instance with the appropriate configuration.
+	dag, err := setupDAG(cfg, databaseContext, interrupt, sigCache, indexManager)
+	if err != nil {
+		return nil, err
+	}
+
+	txMempool := setupMempool(cfg, dag, sigCache)
+
+	netAdapter, err := netadapter.NewNetAdapter(cfg)
+	if err != nil {
+		return nil, err
+	}
+	addressManager, err := addressmanager.New(cfg, databaseContext)
+	if err != nil {
+		return nil, err
+	}
+	connectionManager, err := connmanager.New(cfg, netAdapter, addressManager)
+	if err != nil {
+		return nil, err
+	}
+	protocolManager, err := protocol.NewManager(cfg, dag, netAdapter, addressManager, txMempool, connectionManager)
+	if err != nil {
+		return nil, err
+	}
+	rpcManager := setupRPC(cfg, txMempool, dag, sigCache, netAdapter, protocolManager, connectionManager, addressManager, acceptanceIndex)
+
+	return &App{
+		cfg:               cfg,
+		protocolManager:   protocolManager,
+		rpcManager:        rpcManager,
+		connectionManager: connectionManager,
+		netAdapter:        netAdapter,
+		addressManager:    addressManager,
+	}, nil
+}
+
+func setupRPC(
+	cfg *config.Config,
+	txMempool *mempool.TxPool,
+	dag *blockdag.BlockDAG,
+	sigCache *txscript.SigCache,
+	netAdapter *netadapter.NetAdapter,
+	protocolManager *protocol.Manager,
+	connectionManager *connmanager.ConnectionManager,
+	addressManager *addressmanager.AddressManager,
+	acceptanceIndex *indexers.AcceptanceIndex) *rpc.Manager {
+
+	blockTemplateGenerator := mining.NewBlkTmplGenerator(&mining.Policy{BlockMaxMass: cfg.BlockMaxMass}, txMempool, dag, sigCache)
+	rpcManager := rpc.NewManager(cfg, netAdapter, dag, protocolManager, connectionManager, blockTemplateGenerator, txMempool, addressManager, acceptanceIndex)
+	protocolManager.SetOnBlockAddedToDAGHandler(rpcManager.NotifyBlockAddedToDAG)
+	protocolManager.SetOnTransactionAddedToMempoolHandler(rpcManager.NotifyTransactionAddedToMempool)
+	dag.Subscribe(func(notification *blockdag.Notification) {
+		err := handleBlockDAGNotifications(notification, acceptanceIndex, rpcManager)
+		if err != nil {
+			panic(err)
+		}
+	})
+	return rpcManager
+}
+
+func handleBlockDAGNotifications(notification *blockdag.Notification,
+	acceptanceIndex *indexers.AcceptanceIndex, rpcManager *rpc.Manager) error {
+
+	switch notification.Type {
+	case blockdag.NTChainChanged:
+		if acceptanceIndex == nil {
+			return nil
+		}
+		chainChangedNotificationData := notification.Data.(*blockdag.ChainChangedNotificationData)
+		err := rpcManager.NotifyChainChanged(chainChangedNotificationData.RemovedChainBlockHashes,
+			chainChangedNotificationData.AddedChainBlockHashes)
+		if err != nil {
+			return err
+		}
+	case blockdag.NTFinalityConflict:
+		finalityConflictNotificationData := notification.Data.(*blockdag.FinalityConflictNotificationData)
+		err := rpcManager.NotifyFinalityConflict(finalityConflictNotificationData.ViolatingBlockHash.String())
+		if err != nil {
+			return err
+		}
+	case blockdag.NTFinalityConflictResolved:
+		finalityConflictResolvedNotificationData := notification.Data.(*blockdag.FinalityConflictResolvedNotificationData)
+		err := rpcManager.NotifyFinalityConflictResolved(finalityConflictResolvedNotificationData.FinalityBlockHash.String())
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (a *App) maybeSeedFromDNS() {
+	if !a.cfg.DisableDNSSeed {
+		dnsseed.SeedFromDNS(a.cfg.NetParams(), a.cfg.DNSSeed, appmessage.SFNodeNetwork, false, nil,
+			a.cfg.Lookup, func(addresses []*appmessage.NetAddress) {
+				// Kaspad uses a lookup of the dns seeder here. Since seeder returns
+				// IPs of nodes and not its own IP, we can not know real IP of
+				// source. So we'll take first returned address as source.
+				a.addressManager.AddAddresses(addresses, addresses[0], nil)
+			})
+	}
+
+	if a.cfg.GRPCSeed != "" {
+		dnsseed.SeedFromGRPC(a.cfg.NetParams(), a.cfg.GRPCSeed, appmessage.SFNodeNetwork, false, nil,
+			func(addresses []*appmessage.NetAddress) {
+				a.addressManager.AddAddresses(addresses, addresses[0], nil)
+			})
+	}
+}
+func setupDAG(cfg *config.Config, databaseContext *dbaccess.DatabaseContext, interrupt <-chan struct{},
+	sigCache *txscript.SigCache, indexManager blockdag.IndexManager) (*blockdag.BlockDAG, error) {
+
+	dag, err := blockdag.New(&blockdag.Config{
+		Interrupt:       interrupt,
+		DatabaseContext: databaseContext,
+		DAGParams:       cfg.NetParams(),
+		TimeSource:      blockdag.NewTimeSource(),
+		SigCache:        sigCache,
+		IndexManager:    indexManager,
+		SubnetworkID:    cfg.SubnetworkID,
+	})
+	return dag, err
+}
+
+func setupIndexes(cfg *config.Config) (blockdag.IndexManager, *indexers.AcceptanceIndex) {
+	// Create indexes if needed.
+	var indexes []indexers.Indexer
+	var acceptanceIndex *indexers.AcceptanceIndex
+	if cfg.AcceptanceIndex {
+		log.Info("acceptance index is enabled")
+		acceptanceIndex = indexers.NewAcceptanceIndex()
+		indexes = append(indexes, acceptanceIndex)
+	}
+
+	// Create an index manager if any of the optional indexes are enabled.
+	if len(indexes) < 0 {
+		return nil, nil
+	}
+	indexManager := indexers.NewManager(indexes)
+	return indexManager, acceptanceIndex
+}
+
+func setupMempool(cfg *config.Config, dag *blockdag.BlockDAG, sigCache *txscript.SigCache) *mempool.TxPool {
+	mempoolConfig := mempool.Config{
+		Policy: mempool.Policy{
+			AcceptNonStd:    cfg.RelayNonStd,
+			MaxOrphanTxs:    cfg.MaxOrphanTxs,
+			MaxOrphanTxSize: config.DefaultMaxOrphanTxSize,
+			MinRelayTxFee:   cfg.MinRelayTxFee,
+			MaxTxVersion:    1,
+		},
+		CalcSequenceLockNoLock: func(tx *util.Tx, utxoSet blockdag.UTXOSet) (*blockdag.SequenceLock, error) {
+			return dag.CalcSequenceLockNoLock(tx, utxoSet)
+		},
+		SigCache: sigCache,
+		DAG:      dag,
+	}
+
+	return mempool.New(&mempoolConfig)
+}
+
+// P2PNodeID returns the network ID associated with this App
+func (a *App) P2PNodeID() *id.ID {
+	return a.netAdapter.ID()
+}
+
+// AddressManager returns the AddressManager associated with this App
+func (a *App) AddressManager() *addressmanager.AddressManager {
+	return a.addressManager
+}
--- a/app/appmessage/README.md
+++ b/app/appmessage/README.md
@@ -0,0 +1,72 @@
+wire
+====
+
+[![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/wire)
+=======
+
+Package wire implements the kaspa wire protocol.
+
+## Kaspa Message Overview
+
+The kaspa protocol consists of exchanging messages between peers. Each message
+is preceded by a header which identifies information about it such as which
+kaspa network it is a part of, its type, how big it is, and a checksum to
+verify validity. All encoding and decoding of message headers is handled by this
+package.
+
+To accomplish this, there is a generic interface for kaspa messages named
+`Message` which allows messages of any type to be read, written, or passed
+around through channels, functions, etc. In addition, concrete implementations
+of most all kaspa messages are provided. All of the details of marshalling and 
+unmarshalling to and from the wire using kaspa encoding are handled so the 
+caller doesn't have to concern themselves with the specifics.
+
+## Reading Messages Example
+
+In order to unmarshal kaspa messages from the wire, use the `ReadMessage`
+function. It accepts any `io.Reader`, but typically this will be a `net.Conn`
+to a remote node running a kaspa peer. Example syntax is:
+
+```Go
+	// Use the most recent protocol version supported by the package and the
+	// main kaspa network.
+	pver := wire.ProtocolVersion
+	kaspanet := wire.Mainnet
+
+	// Reads and validates the next kaspa message from conn using the
+	// protocol version pver and the kaspa network kaspanet. The returns
+	// are a appmessage.Message, a []byte which contains the unmarshalled
+	// raw payload, and a possible error.
+	msg, rawPayload, err := wire.ReadMessage(conn, pver, kaspanet)
+	if err != nil {
+		// Log and handle the error
+	}
+```
+
+See the package documentation for details on determining the message type.
+
+## Writing Messages Example
+
+In order to marshal kaspa messages to the wire, use the `WriteMessage`
+function. It accepts any `io.Writer`, but typically this will be a `net.Conn`
+to a remote node running a kaspa peer. Example syntax to request addresses
+from a remote peer is:
+
+```Go
+	// Use the most recent protocol version supported by the package and the
+	// main bitcoin network.
+	pver := wire.ProtocolVersion
+	kaspanet := wire.Mainnet
+
+	// Create a new getaddr kaspa message.
+	msg := wire.NewMsgGetAddr()
+
+	// Writes a kaspa message msg to conn using the protocol version
+	// pver, and the kaspa network kaspanet. The return is a possible
+	// error.
+	err := wire.WriteMessage(conn, msg, pver, kaspanet)
+	if err != nil {
+		// Log and handle the error
+	}
+```
--- a/app/appmessage/base_message.go
+++ b/app/appmessage/base_message.go
@@ -0,0 +1,24 @@
+package appmessage
+
+import "time"
+
+type baseMessage struct {
+	messageNumber uint64
+	receivedAt    time.Time
+}
+
+func (b *baseMessage) MessageNumber() uint64 {
+	return b.messageNumber
+}
+
+func (b *baseMessage) SetMessageNumber(messageNumber uint64) {
+	b.messageNumber = messageNumber
+}
+
+func (b *baseMessage) ReceivedAt() time.Time {
+	return b.receivedAt
+}
+
+func (b *baseMessage) SetReceivedAt(receivedAt time.Time) {
+	b.receivedAt = receivedAt
+}
--- a/app/appmessage/bench_test.go
+++ b/app/appmessage/bench_test.go
@@ -2,26 +2,24 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
 	"bytes"
 	"compress/bzip2"
-	"fmt"
 	"io/ioutil"
 	"math"
-	"net"
 	"os"
 	"testing"

-	"github.com/daglabs/btcd/dagconfig/daghash"
+	"github.com/kaspanet/kaspad/util/daghash"
 )

 // genesisCoinbaseTx is the coinbase transaction for the genesis blocks for
-// the main network, regression test network, and test network (version 3).
+// the main network and test network.
 var genesisCoinbaseTxIns = []*TxIn{
 	{
-		PreviousOutPoint: OutPoint{
+		PreviousOutpoint: Outpoint{
 			TxID:  daghash.TxID{},
 			Index: 0xffffffff,
 		},
@@ -43,7 +41,7 @@ var genesisCoinbaseTxIns = []*TxIn{
 var genesisCoinbaseTxOuts = []*TxOut{
 	{
 		Value: 0x12a05f200,
-		PkScript: []byte{
+		ScriptPubKey: []byte{
 			0x41, 0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, /* |A.g....U| */
 			0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, /* |H'.g..q0| */
 			0xb7, 0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, /* |..\..(.9| */
@@ -172,9 +170,9 @@ func BenchmarkWriteVarStr10(b *testing.B) {
 	}
 }

-// BenchmarkReadOutPoint performs a benchmark on how long it takes to read a
-// transaction output point.
-func BenchmarkReadOutPoint(b *testing.B) {
+// BenchmarkReadOutpoint performs a benchmark on how long it takes to read a
+// transaction outpoint.
+func BenchmarkReadOutpoint(b *testing.B) {
 	buf := []byte{
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -183,22 +181,22 @@ func BenchmarkReadOutPoint(b *testing.B) {
 		0xff, 0xff, 0xff, 0xff, // Previous output index
 	}
 	r := bytes.NewReader(buf)
-	var op OutPoint
+	var op Outpoint
 	for i := 0; i < b.N; i++ {
 		r.Seek(0, 0)
-		readOutPoint(r, 0, 0, &op)
+		readOutpoint(r, 0, 0, &op)
 	}
 }

-// BenchmarkWriteOutPoint performs a benchmark on how long it takes to write a
-// transaction output point.
-func BenchmarkWriteOutPoint(b *testing.B) {
-	op := &OutPoint{
+// BenchmarkWriteOutpoint performs a benchmark on how long it takes to write a
+// transaction outpoint.
+func BenchmarkWriteOutpoint(b *testing.B) {
+	op := &Outpoint{
 		TxID:  daghash.TxID{},
 		Index: 0,
 	}
 	for i := 0; i < b.N; i++ {
-		writeOutPoint(ioutil.Discard, 0, 0, op)
+		writeOutpoint(ioutil.Discard, 0, 0, op)
 	}
 }

@@ -207,7 +205,7 @@ func BenchmarkWriteOutPoint(b *testing.B) {
 func BenchmarkReadTxOut(b *testing.B) {
 	buf := []byte{
 		0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, // Transaction amount
-		0x43, // Varint for length of pk script
+		0x43, // Varint for length of scriptPubKey
 		0x41, // OP_DATA_65
 		0x04, 0x96, 0xb5, 0x38, 0xe8, 0x53, 0x51, 0x9c,
 		0x72, 0x6a, 0x2c, 0x91, 0xe6, 0x1e, 0xc1, 0x16,
@@ -225,7 +223,7 @@ func BenchmarkReadTxOut(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		r.Seek(0, 0)
 		readTxOut(r, 0, 0, &txOut)
-		scriptPool.Return(txOut.PkScript)
+		scriptPool.Return(txOut.ScriptPubKey)
 	}
 }

@@ -285,7 +283,7 @@ func BenchmarkDeserializeTxSmall(b *testing.B) {
 		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // Sequence
 		0x01,                                           // Varint for number of output transactions
 		0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, // Transaction amount
-		0x43, // Varint for length of pk script
+		0x43, // Varint for length of scriptPubKey
 		0x41, // OP_DATA_65
 		0x04, 0x96, 0xb5, 0x38, 0xe8, 0x53, 0x51, 0x9c,
 		0x72, 0x6a, 0x2c, 0x91, 0xe6, 0x1e, 0xc1, 0x16,
@@ -311,8 +309,6 @@ func BenchmarkDeserializeTxSmall(b *testing.B) {
 // BenchmarkDeserializeTxLarge performs a benchmark on how long it takes to
 // deserialize a very large transaction.
 func BenchmarkDeserializeTxLarge(b *testing.B) {
-	// tx bb41a757f405890fb0f5856228e23b715702d714d59bf2b1feb70d8b2b4e3e08
-	// from the main block chain.
 	fi, err := os.Open("testdata/megatx.bin.bz2")
 	if err != nil {
 		b.Fatalf("Failed to read transaction data: %v", err)
@@ -356,7 +352,7 @@ func BenchmarkReadBlockHeader(b *testing.B) {
 		0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a, // MerkleRoot
 		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
 		0xff, 0xff, 0x00, 0x1d, // Bits
-		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
+		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 		0x00, // TxnCount Varint
 	}
 	r := bytes.NewReader(buf)
@@ -376,230 +372,6 @@ func BenchmarkWriteBlockHeader(b *testing.B) {
 	}
 }

-// BenchmarkDecodeGetHeaders performs a benchmark on how long it takes to
-// decode a getheaders message with the maximum number of block locator hashes.
-func BenchmarkDecodeGetHeaders(b *testing.B) {
-	// Create a message with the maximum number of block locators.
-	pver := ProtocolVersion
-	var m MsgGetHeaders
-	for i := 0; i < MaxBlockLocatorsPerMsg; i++ {
-		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
-		if err != nil {
-			b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-		}
-		m.AddBlockLocatorHash(hash)
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.BtcEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgGetHeaders.BtcEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgGetHeaders
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.BtcDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeHeaders performs a benchmark on how long it takes to
-// decode a headers message with the maximum number of headers and maximum number of
-// parent hashes per header.
-func BenchmarkDecodeHeaders(b *testing.B) {
-	// Create a message with the maximum number of headers.
-	pver := ProtocolVersion
-	var m MsgHeaders
-	for i := 0; i < MaxBlockHeadersPerMsg; i++ {
-		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
-		if err != nil {
-			b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-		}
-		parentHashes := make([]*daghash.Hash, MaxNumParentBlocks)
-		for j := byte(0); j < MaxNumParentBlocks; j++ {
-			hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x%x", i, j))
-			if err != nil {
-				b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-			}
-			parentHashes[i] = hash
-		}
-		m.AddBlockHeader(NewBlockHeader(1, parentHashes, hash, hash, 0, uint64(i)))
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.BtcEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgHeaders.BtcEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgHeaders
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.BtcDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeGetBlocks performs a benchmark on how long it takes to
-// decode a getblocks message with the maximum number of block locator hashes.
-func BenchmarkDecodeGetBlocks(b *testing.B) {
-	// Create a message with the maximum number of block locators.
-	pver := ProtocolVersion
-	var m MsgGetBlocks
-	for i := 0; i < MaxBlockLocatorsPerMsg; i++ {
-		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
-		if err != nil {
-			b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-		}
-		m.AddBlockLocatorHash(hash)
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.BtcEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgGetBlocks.BtcEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgGetBlocks
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.BtcDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeAddr performs a benchmark on how long it takes to decode an
-// addr message with the maximum number of addresses.
-func BenchmarkDecodeAddr(b *testing.B) {
-	// Create a message with the maximum number of addresses.
-	pver := ProtocolVersion
-	ip := net.ParseIP("127.0.0.1")
-	ma := NewMsgAddr(false, nil)
-	for port := uint16(0); port < MaxAddrPerMsg; port++ {
-		ma.AddAddress(NewNetAddressIPPort(ip, port, SFNodeNetwork))
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := ma.BtcEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgAddr.BtcEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgAddr
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.BtcDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeInv performs a benchmark on how long it takes to decode an inv
-// message with the maximum number of entries.
-func BenchmarkDecodeInv(b *testing.B) {
-	// Create a message with the maximum number of entries.
-	pver := ProtocolVersion
-	var m MsgInv
-	for i := 0; i < MaxInvPerMsg; i++ {
-		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
-		if err != nil {
-			b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-		}
-		m.AddInvVect(NewInvVect(InvTypeBlock, hash))
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.BtcEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgInv.BtcEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgInv
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.BtcDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeNotFound performs a benchmark on how long it takes to decode
-// a notfound message with the maximum number of entries.
-func BenchmarkDecodeNotFound(b *testing.B) {
-	// Create a message with the maximum number of entries.
-	pver := ProtocolVersion
-	var m MsgNotFound
-	for i := 0; i < MaxInvPerMsg; i++ {
-		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
-		if err != nil {
-			b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-		}
-		m.AddInvVect(NewInvVect(InvTypeBlock, hash))
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.BtcEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgNotFound.BtcEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgNotFound
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.BtcDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeMerkleBlock performs a benchmark on how long it takes to
-// decode a reasonably sized merkleblock message.
-func BenchmarkDecodeMerkleBlock(b *testing.B) {
-	// Create a message with random data.
-	pver := ProtocolVersion
-	var m MsgMerkleBlock
-	hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", 10000))
-	if err != nil {
-		b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-	}
-	m.Header = *NewBlockHeader(1, []*daghash.Hash{hash}, hash, hash, 0, uint64(10000))
-	for i := 0; i < 105; i++ {
-		hash, err := daghash.NewHashFromStr(fmt.Sprintf("%x", i))
-		if err != nil {
-			b.Fatalf("NewHashFromStr: unexpected error: %v", err)
-		}
-		m.AddTxHash(hash)
-		if i%8 == 0 {
-			m.Flags = append(m.Flags, uint8(i))
-		}
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.BtcEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgMerkleBlock.BtcEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgMerkleBlock
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.BtcDecode(r, pver)
-	}
-}
-
 // BenchmarkTxHash performs a benchmark on how long it takes to hash a
 // transaction.
 func BenchmarkTxHash(b *testing.B) {
@@ -639,3 +411,21 @@ func BenchmarkDoubleHashH(b *testing.B) {
 		_ = daghash.DoubleHashH(txBytes)
 	}
 }
+
+// BenchmarkDoubleHashWriter performs a benchmark on how long it takes to perform
+// a double hash via the writer returning a daghash.Hash.
+func BenchmarkDoubleHashWriter(b *testing.B) {
+	var buf bytes.Buffer
+	err := genesisCoinbaseTx.Serialize(&buf)
+	if err != nil {
+		b.Fatalf("Serialize: unexpected error: %+v", err)
+	}
+	txBytes := buf.Bytes()
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		writer := daghash.NewDoubleHashWriter()
+		_, _ = writer.Write(txBytes)
+		writer.Finalize()
+	}
+}
--- a/app/appmessage/common.go
+++ b/app/appmessage/common.go
@@ -2,23 +2,27 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
 	"encoding/binary"
 	"fmt"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util/binaryserializer"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"github.com/pkg/errors"
 	"io"
 	"math"
-	"time"
-
-	"github.com/daglabs/btcd/dagconfig/daghash"
-	"github.com/daglabs/btcd/util/binaryserializer"
-	"github.com/daglabs/btcd/util/subnetworkid"
 )

 // MaxVarIntPayload is the maximum payload size for a variable length integer.
 const MaxVarIntPayload = 9

+// MaxInvPerMsg is the maximum number of inventory vectors that can be in any type of kaspa inv message.
+const MaxInvPerMsg = 1 << 17
+
 var (
 	// littleEndian is a convenience variable since binary.LittleEndian is
 	// quite long.
@@ -34,10 +38,13 @@ var (
 var errNonCanonicalVarInt = "non-canonical varint %x - discriminant %x must " +
 	"encode a value greater than %x"

-// int64Time represents a unix timestamp encoded with an int64.  It is used as
-// a way to signal the readElement function how to decode a timestamp into a Go
-// time.Time since it is otherwise ambiguous.
-type int64Time time.Time
+// errNoEncodingForType signifies that there's no encoding for the given type.
+var errNoEncodingForType = errors.New("there's no encoding for this type")
+
+// int64Time represents a unix timestamp with milliseconds precision encoded with
+// an int64. It is used as a way to signal the readElement function how to decode
+// a timestamp into a Go mstime.Time since it is otherwise ambiguous.
+type int64Time mstime.Time

 // ReadElement reads the next sequence of bytes from r using little endian
 // depending on the concrete type of element pointed to.
@@ -77,6 +84,14 @@ func ReadElement(r io.Reader, element interface{}) error {
 		*e = rv
 		return nil

+	case *uint8:
+		rv, err := binaryserializer.Uint8(r)
+		if err != nil {
+			return err
+		}
+		*e = rv
+		return nil
+
 	case *bool:
 		rv, err := binaryserializer.Uint8(r)
 		if err != nil {
@@ -95,7 +110,7 @@ func ReadElement(r io.Reader, element interface{}) error {
 		if err != nil {
 			return err
 		}
-		*e = int64Time(time.Unix(int64(rv), 0))
+		*e = int64Time(mstime.UnixMilliseconds(int64(rv)))
 		return nil

 	// Message header checksum.
@@ -107,11 +122,12 @@ func ReadElement(r io.Reader, element interface{}) error {
 		return nil

 	// Message header command.
-	case *[CommandSize]uint8:
-		_, err := io.ReadFull(r, e[:])
+	case *MessageCommand:
+		rv, err := binaryserializer.Uint32(r, littleEndian)
 		if err != nil {
 			return err
 		}
+		*e = MessageCommand(rv)
 		return nil

 	// IP address.
@@ -129,6 +145,9 @@ func ReadElement(r io.Reader, element interface{}) error {
 		}
 		return nil

+	case *id.ID:
+		return e.Deserialize(r)
+
 	case *subnetworkid.SubnetworkID:
 		_, err := io.ReadFull(r, e[:])
 		if err != nil {
@@ -144,45 +163,19 @@ func ReadElement(r io.Reader, element interface{}) error {
 		*e = ServiceFlag(rv)
 		return nil

-	case *InvType:
+	case *KaspaNet:
 		rv, err := binaryserializer.Uint32(r, littleEndian)
 		if err != nil {
 			return err
 		}
-		*e = InvType(rv)
-		return nil
-
-	case *BitcoinNet:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
-		if err != nil {
-			return err
-		}
-		*e = BitcoinNet(rv)
-		return nil
-
-	case *BloomUpdateType:
-		rv, err := binaryserializer.Uint8(r)
-		if err != nil {
-			return err
-		}
-		*e = BloomUpdateType(rv)
-		return nil
-
-	case *RejectCode:
-		rv, err := binaryserializer.Uint8(r)
-		if err != nil {
-			return err
-		}
-		*e = RejectCode(rv)
+		*e = KaspaNet(rv)
 		return nil
 	}

-	// Fall back to the slower binary.Read if a fast path was not available
-	// above.
-	return binary.Read(r, littleEndian, element)
+	return errors.Wrapf(errNoEncodingForType, "couldn't find a way to read type %T", element)
 }

-// readElements reads multiple items from r.  It is equivalent to multiple
+// readElements reads multiple items from r. It is equivalent to multiple
 // calls to readElement.
 func readElements(r io.Reader, elements ...interface{}) error {
 	for _, element := range elements {
@@ -227,6 +220,13 @@ func WriteElement(w io.Writer, element interface{}) error {
 		}
 		return nil

+	case uint8:
+		err := binaryserializer.PutUint8(w, e)
+		if err != nil {
+			return err
+		}
+		return nil
+
 	case bool:
 		var err error
 		if e {
@@ -248,8 +248,8 @@ func WriteElement(w io.Writer, element interface{}) error {
 		return nil

 	// Message header command.
-	case [CommandSize]uint8:
-		_, err := w.Write(e[:])
+	case MessageCommand:
+		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
 		if err != nil {
 			return err
 		}
@@ -270,6 +270,9 @@ func WriteElement(w io.Writer, element interface{}) error {
 		}
 		return nil

+	case *id.ID:
+		return e.Serialize(w)
+
 	case *subnetworkid.SubnetworkID:
 		_, err := w.Write(e[:])
 		if err != nil {
@@ -284,41 +287,18 @@ func WriteElement(w io.Writer, element interface{}) error {
 		}
 		return nil

-	case InvType:
+	case KaspaNet:
 		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
 		if err != nil {
 			return err
 		}
 		return nil
-
-	case BitcoinNet:
-		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case BloomUpdateType:
-		err := binaryserializer.PutUint8(w, uint8(e))
-		if err != nil {
-			return err
-		}
-		return nil
-
-	case RejectCode:
-		err := binaryserializer.PutUint8(w, uint8(e))
-		if err != nil {
-			return err
-		}
-		return nil
 	}

-	// Fall back to the slower binary.Write if a fast path was not available
-	// above.
-	return binary.Write(w, littleEndian, element)
+	return errors.Wrapf(errNoEncodingForType, "couldn't find a way to write type %T", element)
 }

-// writeElements writes multiple items to w.  It is equivalent to multiple
+// writeElements writes multiple items to w. It is equivalent to multiple
 // calls to writeElement.
 func writeElements(w io.Writer, elements ...interface{}) error {
 	for _, element := range elements {
@@ -350,7 +330,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 		// encoded using fewer bytes.
 		min := uint64(0x100000000)
 		if rv < min {
-			return 0, messageError("ReadVarInt", fmt.Sprintf(
+			return 0, messageError("readVarInt", fmt.Sprintf(
 				errNonCanonicalVarInt, rv, discriminant, min))
 		}

@@ -365,7 +345,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 		// encoded using fewer bytes.
 		min := uint64(0x10000)
 		if rv < min {
-			return 0, messageError("ReadVarInt", fmt.Sprintf(
+			return 0, messageError("readVarInt", fmt.Sprintf(
 				errNonCanonicalVarInt, rv, discriminant, min))
 		}

@@ -380,7 +360,7 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 		// encoded using fewer bytes.
 		min := uint64(0xfd)
 		if rv < min {
-			return 0, messageError("ReadVarInt", fmt.Sprintf(
+			return 0, messageError("readVarInt", fmt.Sprintf(
 				errNonCanonicalVarInt, rv, discriminant, min))
 		}

@@ -395,30 +375,31 @@ func ReadVarInt(r io.Reader) (uint64, error) {
 // on its value.
 func WriteVarInt(w io.Writer, val uint64) error {
 	if val < 0xfd {
-		return binaryserializer.PutUint8(w, uint8(val))
+		_, err := w.Write([]byte{uint8(val)})
+		return errors.WithStack(err)
 	}

 	if val <= math.MaxUint16 {
-		err := binaryserializer.PutUint8(w, 0xfd)
-		if err != nil {
-			return err
-		}
-		return binaryserializer.PutUint16(w, littleEndian, uint16(val))
+		var buf [3]byte
+		buf[0] = 0xfd
+		littleEndian.PutUint16(buf[1:], uint16(val))
+		_, err := w.Write(buf[:])
+		return errors.WithStack(err)
 	}

 	if val <= math.MaxUint32 {
-		err := binaryserializer.PutUint8(w, 0xfe)
-		if err != nil {
-			return err
-		}
-		return binaryserializer.PutUint32(w, littleEndian, uint32(val))
+		var buf [5]byte
+		buf[0] = 0xfe
+		littleEndian.PutUint32(buf[1:], uint32(val))
+		_, err := w.Write(buf[:])
+		return errors.WithStack(err)
 	}

-	err := binaryserializer.PutUint8(w, 0xff)
-	if err != nil {
-		return err
-	}
-	return binaryserializer.PutUint64(w, littleEndian, val)
+	var buf [9]byte
+	buf[0] = 0xff
+	littleEndian.PutUint64(buf[1:], val)
+	_, err := w.Write(buf[:])
+	return errors.WithStack(err)
 }

 // VarIntSerializeSize returns the number of bytes it would take to serialize
@@ -445,9 +426,9 @@ func VarIntSerializeSize(val uint64) int {
 }

 // ReadVarString reads a variable length string from r and returns it as a Go
-// string.  A variable length string is encoded as a variable length integer
+// string. A variable length string is encoded as a variable length integer
 // containing the length of the string followed by the bytes that represent the
-// string itself.  An error is returned if the length is greater than the
+// string itself. An error is returned if the length is greater than the
 // maximum block payload size since it helps protect against memory exhaustion
 // attacks and forced panics through malformed messages.
 func ReadVarString(r io.Reader, pver uint32) (string, error) {
@@ -457,7 +438,7 @@ func ReadVarString(r io.Reader, pver uint32) (string, error) {
 	}

 	// Prevent variable length strings that are larger than the maximum
-	// message size.  It would be possible to cause memory exhaustion and
+	// message size. It would be possible to cause memory exhaustion and
 	// panics without a sane upper bound on this count.
 	if count > MaxMessagePayload {
 		str := fmt.Sprintf("variable length string is too long "+
@@ -485,11 +466,11 @@ func WriteVarString(w io.Writer, str string) error {
 	return err
 }

-// ReadVarBytes reads a variable length byte array.  A byte array is encoded
+// ReadVarBytes reads a variable length byte array. A byte array is encoded
 // as a varInt containing the length of the array followed by the bytes
-// themselves.  An error is returned if the length is greater than the
+// themselves. An error is returned if the length is greater than the
 // passed maxAllowed parameter which helps protect against memory exhaustion
-// attacks and forced panics through malformed messages.  The fieldName
+// attacks and forced panics through malformed messages. The fieldName
 // parameter is only used for the error message so it provides more context in
 // the error.
 func ReadVarBytes(r io.Reader, pver uint32, maxAllowed uint32,
@@ -500,7 +481,7 @@ func ReadVarBytes(r io.Reader, pver uint32, maxAllowed uint32,
 		return nil, err
 	}

-	// Prevent byte array larger than the max message size.  It would
+	// Prevent byte array larger than the max message size. It would
 	// be possible to cause memory exhaustion and panics without a sane
 	// upper bound on this count.
 	if count > uint64(maxAllowed) {
--- a/app/appmessage/common_test.go
+++ b/app/appmessage/common_test.go
@@ -2,62 +2,68 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
 	"bytes"
+	"github.com/pkg/errors"
 	"io"
 	"reflect"
 	"strings"
 	"testing"

-	"github.com/daglabs/btcd/dagconfig/daghash"
 	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/util/daghash"
 )

-// mainNetGenesisHash is the hash of the first block in the block chain for the
+// mainnetGenesisHash is the hash of the first block in the block DAG for the
 // main network (genesis block).
-var mainNetGenesisHash = &daghash.Hash{ // Make go vet happy.
-	0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72,
-	0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-	0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-	0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
+var mainnetGenesisHash = &daghash.Hash{
+	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25,
+	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+	0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
 }

-// simNetGenesisHash is the hash of the first block in the block chain for the
+// simnetGenesisHash is the hash of the first block in the block DAG for the
 // simulation test network.
-var simNetGenesisHash = &daghash.Hash{ // Make go vet happy.
+var simnetGenesisHash = &daghash.Hash{
 	0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a,
 	0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 	0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
 	0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
 }

-// mainNetGenesisMerkleRoot is the hash of the first transaction in the genesis
+// mainnetGenesisMerkleRoot is the hash of the first transaction in the genesis
 // block for the main network.
-var mainNetGenesisMerkleRoot = &daghash.Hash{ // Make go vet happy.
+var mainnetGenesisMerkleRoot = &daghash.Hash{
 	0x4a, 0x5e, 0x1e, 0x4b, 0xaa, 0xb8, 0x9f, 0x3a,
 	0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 	0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
 }

-var exampleIDMerkleRoot = &daghash.Hash{
-	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
-	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
+var exampleAcceptedIDMerkleRoot = &daghash.Hash{
 	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
+	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
+	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
 }

-// TestElementWire tests wire encode and decode for various element types.  This
+var exampleUTXOCommitment = &daghash.Hash{
+	0x10, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
+	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
+	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
+	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
+}
+
+// TestElementEncoding tests appmessage encode and decode for various element types. This
 // is mainly to test the "fast" paths in readElement and writeElement which use
 // type assertions to avoid reflection when possible.
-func TestElementWire(t *testing.T) {
-	type writeElementReflect int32
-
+func TestElementEncoding(t *testing.T) {
 	tests := []struct {
 		in  interface{} // Value to encode
-		buf []byte      // Wire encoding
+		buf []byte      // Encoded value
 	}{
 		{int32(1), []byte{0x01, 0x00, 0x00, 0x00}},
 		{uint32(256), []byte{0x00, 0x01, 0x00, 0x00}},
@@ -82,13 +88,9 @@ func TestElementWire(t *testing.T) {
 			[]byte{0x01, 0x02, 0x03, 0x04},
 		},
 		{
-			[CommandSize]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c,
-			},
+			MessageCommand(0x10),
 			[]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c,
+				0x10, 0x00, 0x00, 0x00,
 			},
 		},
 		{
@@ -102,7 +104,7 @@ func TestElementWire(t *testing.T) {
 			},
 		},
 		{
-			(*daghash.Hash)(&[daghash.HashSize]byte{ // Make go vet happy.
+			(*daghash.Hash)(&[daghash.HashSize]byte{
 				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
@@ -120,23 +122,14 @@ func TestElementWire(t *testing.T) {
 			[]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 		},
 		{
-			InvType(InvTypeTx),
-			[]byte{0x01, 0x00, 0x00, 0x00},
-		},
-		{
-			BitcoinNet(MainNet),
-			[]byte{0xf9, 0xbe, 0xb4, 0xd9},
-		},
-		// Type not supported by the "fast" path and requires reflection.
-		{
-			writeElementReflect(1),
-			[]byte{0x01, 0x00, 0x00, 0x00},
+			KaspaNet(Mainnet),
+			[]byte{0x1d, 0xf7, 0xdc, 0x3d},
 		},
 	}

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Write to wire format.
+		// Write to appmessage format.
 		var buf bytes.Buffer
 		err := WriteElement(&buf, test.in)
 		if err != nil {
@@ -149,7 +142,7 @@ func TestElementWire(t *testing.T) {
 			continue
 		}

-		// Read from wire format.
+		// Read from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		val := test.in
 		if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
@@ -172,9 +165,11 @@ func TestElementWire(t *testing.T) {
 	}
 }

-// TestElementWireErrors performs negative tests against wire encode and decode
+// TestElementEncodingErrors performs negative tests against appmessage encode and decode
 // of various element types to confirm error paths work correctly.
-func TestElementWireErrors(t *testing.T) {
+func TestElementEncodingErrors(t *testing.T) {
+	type writeElementReflect int32
+
 	tests := []struct {
 		in       interface{} // Value to encode
 		max      int         // Max size of fixed buffer to induce errors
@@ -187,10 +182,7 @@ func TestElementWireErrors(t *testing.T) {
 		{true, 0, io.ErrShortWrite, io.EOF},
 		{[4]byte{0x01, 0x02, 0x03, 0x04}, 0, io.ErrShortWrite, io.EOF},
 		{
-			[CommandSize]byte{
-				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-				0x09, 0x0a, 0x0b, 0x0c,
-			},
+			MessageCommand(10),
 			0, io.ErrShortWrite, io.EOF,
 		},
 		{
@@ -201,7 +193,7 @@ func TestElementWireErrors(t *testing.T) {
 			0, io.ErrShortWrite, io.EOF,
 		},
 		{
-			(*daghash.Hash)(&[daghash.HashSize]byte{ // Make go vet happy.
+			(*daghash.Hash)(&[daghash.HashSize]byte{
 				0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 				0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
 				0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
@@ -210,29 +202,30 @@ func TestElementWireErrors(t *testing.T) {
 			0, io.ErrShortWrite, io.EOF,
 		},
 		{ServiceFlag(SFNodeNetwork), 0, io.ErrShortWrite, io.EOF},
-		{InvType(InvTypeTx), 0, io.ErrShortWrite, io.EOF},
-		{BitcoinNet(MainNet), 0, io.ErrShortWrite, io.EOF},
+		{KaspaNet(Mainnet), 0, io.ErrShortWrite, io.EOF},
+		// Type with no supported encoding.
+		{writeElementReflect(0), 0, errNoEncodingForType, errNoEncodingForType},
 	}

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
 		err := WriteElement(w, test.in)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("writeElement #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}

-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, nil)
 		val := test.in
 		if reflect.ValueOf(test.in).Kind() != reflect.Ptr {
 			val = reflect.New(reflect.TypeOf(test.in)).Interface()
 		}
 		err = ReadElement(r, val)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("readElement #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -240,43 +233,42 @@ func TestElementWireErrors(t *testing.T) {
 	}
 }

-// TestVarIntWire tests wire encode and decode for variable length integers.
-func TestVarIntWire(t *testing.T) {
+// TestVarIntEncoding tests appmessage encode and decode for variable length integers.
+func TestVarIntEncoding(t *testing.T) {
 	tests := []struct {
-		in  uint64 // Value to encode
-		out uint64 // Expected decoded value
-		buf []byte // Wire encoding
+		value uint64 // Value to encode
+		buf   []byte // Encoded value
 	}{
 		// Latest protocol version.
 		// Single byte
-		{0, 0, []byte{0x00}},
+		{0, []byte{0x00}},
 		// Max single byte
-		{0xfc, 0xfc, []byte{0xfc}},
+		{0xfc, []byte{0xfc}},
 		// Min 2-byte
-		{0xfd, 0xfd, []byte{0xfd, 0x0fd, 0x00}},
+		{0xfd, []byte{0xfd, 0x0fd, 0x00}},
 		// Max 2-byte
-		{0xffff, 0xffff, []byte{0xfd, 0xff, 0xff}},
+		{0xffff, []byte{0xfd, 0xff, 0xff}},
 		// Min 4-byte
-		{0x10000, 0x10000, []byte{0xfe, 0x00, 0x00, 0x01, 0x00}},
+		{0x10000, []byte{0xfe, 0x00, 0x00, 0x01, 0x00}},
 		// Max 4-byte
-		{0xffffffff, 0xffffffff, []byte{0xfe, 0xff, 0xff, 0xff, 0xff}},
+		{0xffffffff, []byte{0xfe, 0xff, 0xff, 0xff, 0xff}},
 		// Min 8-byte
 		{
-			0x100000000, 0x100000000,
+			0x100000000,
 			[]byte{0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00},
 		},
 		// Max 8-byte
 		{
-			0xffffffffffffffff, 0xffffffffffffffff,
+			0xffffffffffffffff,
 			[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
 		},
 	}

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
-		var buf bytes.Buffer
-		err := WriteVarInt(&buf, test.in)
+		// Encode to appmessage format.
+		buf := &bytes.Buffer{}
+		err := WriteVarInt(buf, test.value)
 		if err != nil {
 			t.Errorf("WriteVarInt #%d error %v", i, err)
 			continue
@@ -287,27 +279,27 @@ func TestVarIntWire(t *testing.T) {
 			continue
 		}

-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		val, err := ReadVarInt(rbuf)
 		if err != nil {
 			t.Errorf("ReadVarInt #%d error %v", i, err)
 			continue
 		}
-		if val != test.out {
-			t.Errorf("ReadVarInt #%d\n got: %d want: %d", i,
-				val, test.out)
+		if val != test.value {
+			t.Errorf("ReadVarInt #%d\n got: %x want: %x", i,
+				val, test.value)
 			continue
 		}
 	}
 }

-// TestVarIntWireErrors performs negative tests against wire encode and decode
+// TestVarIntEncodingErrors performs negative tests against appmessage encode and decode
 // of variable length integers to confirm error paths work correctly.
-func TestVarIntWireErrors(t *testing.T) {
+func TestVarIntEncodingErrors(t *testing.T) {
 	tests := []struct {
 		in       uint64 // Value to encode
-		buf      []byte // Wire encoding
+		buf      []byte // Encoded value
 		max      int    // Max size of fixed buffer to induce errors
 		writeErr error  // Expected write error
 		readErr  error  // Expected read error
@@ -327,19 +319,19 @@ func TestVarIntWireErrors(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
 		err := WriteVarInt(w, test.in)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("WriteVarInt #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}

-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, test.buf)
 		_, err = ReadVarInt(r)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("ReadVarInt #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -355,7 +347,7 @@ func TestVarIntNonCanonical(t *testing.T) {
 	tests := []struct {
 		name string // Test name for easier identification
 		in   []byte // Value to decode
-		pver uint32 // Protocol version for wire encoding
+		pver uint32 // Protocol version for appmessage encoding
 	}{
 		{
 			"0 encoded with 3 bytes", []byte{0xfd, 0x00, 0x00},
@@ -387,10 +379,10 @@ func TestVarIntNonCanonical(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.in)
 		val, err := ReadVarInt(rbuf)
-		if _, ok := err.(*MessageError); !ok {
+		if msgErr := &(MessageError{}); !errors.As(err, &msgErr) {
 			t.Errorf("ReadVarInt #%d (%s) unexpected error %v", i,
 				test.name, err)
 			continue
@@ -403,7 +395,7 @@ func TestVarIntNonCanonical(t *testing.T) {
 	}
 }

-// TestVarIntWire tests the serialize size for variable length integers.
+// TestVarIntEncoding tests the serialize size for variable length integers.
 func TestVarIntSerializeSize(t *testing.T) {
 	tests := []struct {
 		val  uint64 // Value to get the serialized size for
@@ -438,8 +430,8 @@ func TestVarIntSerializeSize(t *testing.T) {
 	}
 }

-// TestVarStringWire tests wire encode and decode for variable length strings.
-func TestVarStringWire(t *testing.T) {
+// TestVarStringEncoding tests appmessage encode and decode for variable length strings.
+func TestVarStringEncoding(t *testing.T) {
 	pver := ProtocolVersion

 	// str256 is a string that takes a 2-byte varint to encode.
@@ -448,8 +440,8 @@ func TestVarStringWire(t *testing.T) {
 	tests := []struct {
 		in   string // String to encode
 		out  string // String to decoded value
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 	}{
 		// Latest protocol version.
 		// Empty string
@@ -462,7 +454,7 @@ func TestVarStringWire(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		var buf bytes.Buffer
 		err := WriteVarString(&buf, test.in)
 		if err != nil {
@@ -475,7 +467,7 @@ func TestVarStringWire(t *testing.T) {
 			continue
 		}

-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		val, err := ReadVarString(rbuf, test.pver)
 		if err != nil {
@@ -490,9 +482,9 @@ func TestVarStringWire(t *testing.T) {
 	}
 }

-// TestVarStringWireErrors performs negative tests against wire encode and
+// TestVarStringEncodingErrors performs negative tests against appmessage encode and
 // decode of variable length strings to confirm error paths work correctly.
-func TestVarStringWireErrors(t *testing.T) {
+func TestVarStringEncodingErrors(t *testing.T) {
 	pver := ProtocolVersion

 	// str256 is a string that takes a 2-byte varint to encode.
@@ -500,8 +492,8 @@ func TestVarStringWireErrors(t *testing.T) {

 	tests := []struct {
 		in       string // Value to encode
-		buf      []byte // Wire encoding
-		pver     uint32 // Protocol version for wire encoding
+		buf      []byte // Encoded value
+		pver     uint32 // Protocol version for appmessage encoding
 		max      int    // Max size of fixed buffer to induce errors
 		writeErr error  // Expected write error
 		readErr  error  // Expected read error
@@ -517,19 +509,19 @@ func TestVarStringWireErrors(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
 		err := WriteVarString(w, test.in)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("WriteVarString #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}

-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, test.buf)
 		_, err = ReadVarString(r, test.pver)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("ReadVarString #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -539,14 +531,14 @@ func TestVarStringWireErrors(t *testing.T) {

 // TestVarStringOverflowErrors performs tests to ensure deserializing variable
 // length strings intentionally crafted to use large values for the string
-// length are handled properly.  This could otherwise potentially be used as an
+// length are handled properly. This could otherwise potentially be used as an
 // attack vector.
 func TestVarStringOverflowErrors(t *testing.T) {
 	pver := ProtocolVersion

 	tests := []struct {
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 		err  error  // Expected error
 	}{
 		{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
@@ -557,7 +549,7 @@ func TestVarStringOverflowErrors(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		_, err := ReadVarString(rbuf, test.pver)
 		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@@ -569,8 +561,8 @@ func TestVarStringOverflowErrors(t *testing.T) {

 }

-// TestVarBytesWire tests wire encode and decode for variable length byte array.
-func TestVarBytesWire(t *testing.T) {
+// TestVarBytesEncoding tests appmessage encode and decode for variable length byte array.
+func TestVarBytesEncoding(t *testing.T) {
 	pver := ProtocolVersion

 	// bytes256 is a byte array that takes a 2-byte varint to encode.
@@ -578,8 +570,8 @@ func TestVarBytesWire(t *testing.T) {

 	tests := []struct {
 		in   []byte // Byte Array to write
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 	}{
 		// Latest protocol version.
 		// Empty byte array
@@ -592,7 +584,7 @@ func TestVarBytesWire(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		var buf bytes.Buffer
 		err := WriteVarBytes(&buf, test.pver, test.in)
 		if err != nil {
@@ -605,7 +597,7 @@ func TestVarBytesWire(t *testing.T) {
 			continue
 		}

-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		val, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
 			"test payload")
@@ -621,9 +613,9 @@ func TestVarBytesWire(t *testing.T) {
 	}
 }

-// TestVarBytesWireErrors performs negative tests against wire encode and
+// TestVarBytesEncodingErrors performs negative tests against appmessage encode and
 // decode of variable length byte arrays to confirm error paths work correctly.
-func TestVarBytesWireErrors(t *testing.T) {
+func TestVarBytesEncodingErrors(t *testing.T) {
 	pver := ProtocolVersion

 	// bytes256 is a byte array that takes a 2-byte varint to encode.
@@ -631,8 +623,8 @@ func TestVarBytesWireErrors(t *testing.T) {

 	tests := []struct {
 		in       []byte // Byte Array to write
-		buf      []byte // Wire encoding
-		pver     uint32 // Protocol version for wire encoding
+		buf      []byte // Encoded value
+		pver     uint32 // Protocol version for appmessage encoding
 		max      int    // Max size of fixed buffer to induce errors
 		writeErr error  // Expected write error
 		readErr  error  // Expected read error
@@ -648,20 +640,20 @@ func TestVarBytesWireErrors(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
 		err := WriteVarBytes(w, test.pver, test.in)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("WriteVarBytes #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}

-		// Decode from wire format.
+		// Decode from appmessage format.
 		r := newFixedReader(test.max, test.buf)
 		_, err = ReadVarBytes(r, test.pver, MaxMessagePayload,
 			"test payload")
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("ReadVarBytes #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -671,14 +663,14 @@ func TestVarBytesWireErrors(t *testing.T) {

 // TestVarBytesOverflowErrors performs tests to ensure deserializing variable
 // length byte arrays intentionally crafted to use large values for the array
-// length are handled properly.  This could otherwise potentially be used as an
+// length are handled properly. This could otherwise potentially be used as an
 // attack vector.
 func TestVarBytesOverflowErrors(t *testing.T) {
 	pver := ProtocolVersion

 	tests := []struct {
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 		err  error  // Expected error
 	}{
 		{[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
@@ -689,7 +681,7 @@ func TestVarBytesOverflowErrors(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Decode from wire format.
+		// Decode from appmessage format.
 		rbuf := bytes.NewReader(test.buf)
 		_, err := ReadVarBytes(rbuf, test.pver, MaxMessagePayload,
 			"test payload")
--- a/app/appmessage/doc.go
+++ b/app/appmessage/doc.go
@@ -0,0 +1,133 @@
+/*
+Package appmessage implements the kaspa appmessage protocol.
+
+At a high level, this package provides support for marshalling and unmarshalling
+supported kaspa messages to and from the appmessage. This package does not deal
+with the specifics of message handling such as what to do when a message is
+received. This provides the caller with a high level of flexibility.
+
+Kaspa Message Overview
+
+The kaspa protocol consists of exchanging messages between peers. Each
+message is preceded by a header which identifies information about it such as
+which kaspa network it is a part of, its type, how big it is, and a checksum
+to verify validity. All encoding and decoding of message headers is handled by
+this package.
+
+To accomplish this, there is a generic interface for kaspa messages named
+Message which allows messages of any type to be read, written, or passed around
+through channels, functions, etc. In addition, concrete implementations of most
+of the currently supported kaspa messages are provided. For these supported
+messages, all of the details of marshalling and unmarshalling to and from the
+appmessage using kaspa encoding are handled so the caller doesn't have to concern
+themselves with the specifics.
+
+Message Interaction
+
+The following provides a quick summary of how the kaspa messages are intended
+to interact with one another. As stated above, these interactions are not
+directly handled by this package.
+
+The initial handshake consists of two peers sending each other a version message
+(MsgVersion) followed by responding with a verack message (MsgVerAck). Both
+peers use the information in the version message (MsgVersion) to negotiate
+things such as protocol version and supported services with each other. Once
+the initial handshake is complete, the following chart indicates message
+interactions in no particular order.
+
+	Peer A Sends                            Peer B Responds
+	----------------------------------------------------------------------------
+	getaddr message (MsgRequestAddresses)       addr message (MsgAddresses)
+	getblockinvs message (MsgGetBlockInvs)  inv message (MsgInv)
+	inv message (MsgInv)                    getdata message (MsgGetData)
+	getdata message (MsgGetData)            block message (MsgBlock) -or-
+	                                        tx message (MsgTx) -or-
+	                                        notfound message (MsgNotFound)
+	ping message (MsgPing)                  pong message (MsgPong)
+
+Common Parameters
+
+There are several common parameters that arise when using this package to read
+and write kaspa messages. The following sections provide a quick overview of
+these parameters so the next sections can build on them.
+
+Protocol Version
+
+The protocol version should be negotiated with the remote peer at a higher
+level than this package via the version (MsgVersion) message exchange, however,
+this package provides the appmessage.ProtocolVersion constant which indicates the
+latest protocol version this package supports and is typically the value to use
+for all outbound connections before a potentially lower protocol version is
+negotiated.
+
+Kaspa Network
+
+The kaspa network is a magic number which is used to identify the start of a
+message and which kaspa network the message applies to. This package provides
+the following constants:
+
+    appmessage.Mainnet
+    appmessage.Testnet (Test network)
+    appmessage.Simnet  (Simulation test network)
+    appmessage.Devnet  (Development network)
+
+Determining Message Type
+
+As discussed in the kaspa message overview section, this package reads
+and writes kaspa messages using a generic interface named Message. In
+order to determine the actual concrete type of the message, use a type
+switch or type assertion. An example of a type switch follows:
+
+	// Assumes msg is already a valid concrete message such as one created
+	// via NewMsgVersion or read via ReadMessage.
+	switch msg := msg.(type) {
+	case *appmessage.MsgVersion:
+		// The message is a pointer to a MsgVersion struct.
+		fmt.Printf("Protocol version: %d", msg.ProtocolVersion)
+	case *appmessage.MsgBlock:
+		// The message is a pointer to a MsgBlock struct.
+		fmt.Printf("Number of tx in block: %d", msg.Header.TxnCount)
+	}
+
+Reading Messages
+
+In order to unmarshall kaspa messages from the appmessage, use the ReadMessage
+function. It accepts any io.Reader, but typically this will be a net.Conn to
+a remote node running a kaspa peer. Example syntax is:
+
+	// Reads and validates the next kaspa message from conn using the
+	// protocol version pver and the kaspa network kaspaNet. The returns
+	// are a appmessage.Message, a []byte which contains the unmarshalled
+	// raw payload, and a possible error.
+	msg, rawPayload, err := appmessage.ReadMessage(conn, pver, kaspaNet)
+	if err != nil {
+		// Log and handle the error
+	}
+
+Writing Messages
+
+In order to marshall kaspa messages to the appmessage, use the WriteMessage
+function. It accepts any io.Writer, but typically this will be a net.Conn to
+a remote node running a kaspa peer. Example syntax to request addresses
+from a remote peer is:
+
+	// Create a new getaddr kaspa message.
+	msg := appmessage.NewMsgRequestAddresses()
+
+	// Writes a kaspa message msg to conn using the protocol version
+	// pver, and the kaspa network kaspaNet. The return is a possible
+	// error.
+	err := appmessage.WriteMessage(conn, msg, pver, kaspaNet)
+	if err != nil {
+		// Log and handle the error
+	}
+
+Errors
+
+Errors returned by this package are either the raw errors provided by underlying
+calls to read/write from streams such as io.EOF, io.ErrUnexpectedEOF, and
+io.ErrShortWrite, or of type appmessage.MessageError. This allows the caller to
+differentiate between general IO errors and malformed messages through type
+assertions.
+*/
+package appmessage
--- a/app/appmessage/error.go
+++ b/app/appmessage/error.go
@@ -2,14 +2,14 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
 	"fmt"
 )

 // MessageError describes an issue with a message.
-// An example of some potential issues are messages from the wrong bitcoin
+// An example of some potential issues are messages from the wrong kaspa
 // network, invalid commands, mismatched checksums, and exceeding max payloads.
 //
 // This provides a mechanism for the caller to type assert the error to
@@ -32,3 +32,16 @@ func (e *MessageError) Error() string {
 func messageError(f string, desc string) *MessageError {
 	return &MessageError{Func: f, Description: desc}
 }
+
+// RPCError represents an error arriving from the RPC
+type RPCError struct {
+	Message string
+}
+
+// RPCErrorf formats according to a format specifier and returns the string
+// as an RPCError.
+func RPCErrorf(format string, args ...interface{}) *RPCError {
+	return &RPCError{
+		Message: fmt.Sprintf(format, args...),
+	}
+}
--- a/app/appmessage/fixedIO_test.go
+++ b/app/appmessage/fixedIO_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
 	"bytes"
@@ -16,7 +16,7 @@ type fixedWriter struct {
 	pos int
 }

-// Write writes the contents of p to w.  When the contents of p would cause
+// Write writes the contents of p to w. When the contents of p would cause
 // the writer to exceed the maximum allowed size of the fixed writer,
 // io.ErrShortWrite is returned and the writer is left unchanged.
 //
@@ -52,7 +52,7 @@ type fixedReader struct {
 	iobuf *bytes.Buffer
 }

-// Read reads the next len(p) bytes from the fixed reader.  When the number of
+// Read reads the next len(p) bytes from the fixed reader. When the number of
 // bytes read would exceed the maximum number of allowed bytes to be read from
 // the fixed writer, an error is returned.
 //
--- a/app/appmessage/message.go
+++ b/app/appmessage/message.go
@@ -0,0 +1,185 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"fmt"
+	"time"
+)
+
+// MaxMessagePayload is the maximum bytes a message can be regardless of other
+// individual limits imposed by messages themselves.
+const MaxMessagePayload = 1024 * 1024 * 32 // 32MB
+
+// MessageCommand is a number in the header of a message that represents its type.
+type MessageCommand uint32
+
+func (cmd MessageCommand) String() string {
+	cmdString, ok := ProtocolMessageCommandToString[cmd]
+	if !ok {
+		cmdString, ok = RPCMessageCommandToString[cmd]
+	}
+	if !ok {
+		cmdString = "unknown command"
+	}
+	return fmt.Sprintf("%s [code %d]", cmdString, uint8(cmd))
+}
+
+// Commands used in kaspa message headers which describe the type of message.
+const (
+	// protocol
+	CmdVersion MessageCommand = iota
+	CmdVerAck
+	CmdRequestAddresses
+	CmdAddresses
+	CmdRequestIBDBlocks
+	CmdBlock
+	CmdTx
+	CmdPing
+	CmdPong
+	CmdRequestBlockLocator
+	CmdBlockLocator
+	CmdSelectedTip
+	CmdRequestSelectedTip
+	CmdInvRelayBlock
+	CmdRequestRelayBlocks
+	CmdInvTransaction
+	CmdRequestTransactions
+	CmdIBDBlock
+	CmdRequestNextIBDBlocks
+	CmdDoneIBDBlocks
+	CmdTransactionNotFound
+	CmdReject
+
+	// rpc
+	CmdGetCurrentNetworkRequestMessage
+	CmdGetCurrentNetworkResponseMessage
+	CmdSubmitBlockRequestMessage
+	CmdSubmitBlockResponseMessage
+	CmdGetBlockTemplateRequestMessage
+	CmdGetBlockTemplateResponseMessage
+	CmdGetBlockTemplateTransactionMessage
+	CmdNotifyBlockAddedRequestMessage
+	CmdNotifyBlockAddedResponseMessage
+	CmdBlockAddedNotificationMessage
+	CmdGetPeerAddressesRequestMessage
+	CmdGetPeerAddressesResponseMessage
+	CmdGetSelectedTipHashRequestMessage
+	CmdGetSelectedTipHashResponseMessage
+	CmdGetMempoolEntryRequestMessage
+	CmdGetMempoolEntryResponseMessage
+	CmdGetConnectedPeerInfoRequestMessage
+	CmdGetConnectedPeerInfoResponseMessage
+	CmdAddPeerRequestMessage
+	CmdAddPeerResponseMessage
+	CmdSubmitTransactionRequestMessage
+	CmdSubmitTransactionResponseMessage
+	CmdNotifyChainChangedRequestMessage
+	CmdNotifyChainChangedResponseMessage
+	CmdChainChangedNotificationMessage
+	CmdGetBlockRequestMessage
+	CmdGetBlockResponseMessage
+	CmdGetSubnetworkRequestMessage
+	CmdGetSubnetworkResponseMessage
+	CmdGetChainFromBlockRequestMessage
+	CmdGetChainFromBlockResponseMessage
+	CmdGetBlocksRequestMessage
+	CmdGetBlocksResponseMessage
+	CmdGetBlockCountRequestMessage
+	CmdGetBlockCountResponseMessage
+	CmdGetBlockDAGInfoRequestMessage
+	CmdGetBlockDAGInfoResponseMessage
+	CmdResolveFinalityConflictRequestMessage
+	CmdResolveFinalityConflictResponseMessage
+	CmdNotifyFinalityConflictsRequestMessage
+	CmdNotifyFinalityConflictsResponseMessage
+	CmdFinalityConflictNotificationMessage
+	CmdFinalityConflictResolvedNotificationMessage
+)
+
+// ProtocolMessageCommandToString maps all MessageCommands to their string representation
+var ProtocolMessageCommandToString = map[MessageCommand]string{
+	CmdVersion:              "Version",
+	CmdVerAck:               "VerAck",
+	CmdRequestAddresses:     "RequestAddresses",
+	CmdAddresses:            "Addresses",
+	CmdRequestIBDBlocks:     "RequestBlocks",
+	CmdBlock:                "Block",
+	CmdTx:                   "Tx",
+	CmdPing:                 "Ping",
+	CmdPong:                 "Pong",
+	CmdRequestBlockLocator:  "RequestBlockLocator",
+	CmdBlockLocator:         "BlockLocator",
+	CmdSelectedTip:          "SelectedTip",
+	CmdRequestSelectedTip:   "RequestSelectedTip",
+	CmdInvRelayBlock:        "InvRelayBlock",
+	CmdRequestRelayBlocks:   "RequestRelayBlocks",
+	CmdInvTransaction:       "InvTransaction",
+	CmdRequestTransactions:  "RequestTransactions",
+	CmdIBDBlock:             "IBDBlock",
+	CmdRequestNextIBDBlocks: "RequestNextIBDBlocks",
+	CmdDoneIBDBlocks:        "DoneIBDBlocks",
+	CmdTransactionNotFound:  "TransactionNotFound",
+	CmdReject:               "Reject",
+}
+
+// RPCMessageCommandToString maps all MessageCommands to their string representation
+var RPCMessageCommandToString = map[MessageCommand]string{
+	CmdGetCurrentNetworkRequestMessage:             "GetCurrentNetworkRequest",
+	CmdGetCurrentNetworkResponseMessage:            "GetCurrentNetworkResponse",
+	CmdSubmitBlockRequestMessage:                   "SubmitBlockRequest",
+	CmdSubmitBlockResponseMessage:                  "SubmitBlockResponse",
+	CmdGetBlockTemplateRequestMessage:              "GetBlockTemplateRequest",
+	CmdGetBlockTemplateResponseMessage:             "GetBlockTemplateResponse",
+	CmdGetBlockTemplateTransactionMessage:          "CmdGetBlockTemplateTransaction",
+	CmdNotifyBlockAddedRequestMessage:              "NotifyBlockAddedRequest",
+	CmdNotifyBlockAddedResponseMessage:             "NotifyBlockAddedResponse",
+	CmdBlockAddedNotificationMessage:               "BlockAddedNotification",
+	CmdGetPeerAddressesRequestMessage:              "GetPeerAddressesRequest",
+	CmdGetPeerAddressesResponseMessage:             "GetPeerAddressesResponse",
+	CmdGetSelectedTipHashRequestMessage:            "GetSelectedTipHashRequest",
+	CmdGetSelectedTipHashResponseMessage:           "GetSelectedTipHashResponse",
+	CmdGetMempoolEntryRequestMessage:               "GetMempoolEntryRequest",
+	CmdGetMempoolEntryResponseMessage:              "GetMempoolEntryResponse",
+	CmdGetConnectedPeerInfoRequestMessage:          "GetConnectedPeerInfoRequest",
+	CmdGetConnectedPeerInfoResponseMessage:         "GetConnectedPeerInfoResponse",
+	CmdAddPeerRequestMessage:                       "AddPeerRequest",
+	CmdAddPeerResponseMessage:                      "AddPeerResponse",
+	CmdSubmitTransactionRequestMessage:             "SubmitTransactionRequest",
+	CmdSubmitTransactionResponseMessage:            "SubmitTransactionResponse",
+	CmdNotifyChainChangedRequestMessage:            "NotifyChainChangedRequest",
+	CmdNotifyChainChangedResponseMessage:           "NotifyChainChangedResponse",
+	CmdChainChangedNotificationMessage:             "ChainChangedNotification",
+	CmdGetBlockRequestMessage:                      "GetBlockRequest",
+	CmdGetBlockResponseMessage:                     "GetBlockResponse",
+	CmdGetSubnetworkRequestMessage:                 "GetSubnetworkRequest",
+	CmdGetSubnetworkResponseMessage:                "GetSubnetworkResponse",
+	CmdGetChainFromBlockRequestMessage:             "GetChainFromBlockRequest",
+	CmdGetChainFromBlockResponseMessage:            "GetChainFromBlockResponse",
+	CmdGetBlocksRequestMessage:                     "GetBlocksRequest",
+	CmdGetBlocksResponseMessage:                    "GetBlocksResponse",
+	CmdGetBlockCountRequestMessage:                 "GetBlockCountRequest",
+	CmdGetBlockCountResponseMessage:                "GetBlockCountResponse",
+	CmdGetBlockDAGInfoRequestMessage:               "GetBlockDAGInfoRequest",
+	CmdGetBlockDAGInfoResponseMessage:              "GetBlockDAGInfoResponse",
+	CmdResolveFinalityConflictRequestMessage:       "ResolveFinalityConflictRequest",
+	CmdResolveFinalityConflictResponseMessage:      "ResolveFinalityConflictResponse",
+	CmdNotifyFinalityConflictsRequestMessage:       "NotifyFinalityConflictsRequest",
+	CmdNotifyFinalityConflictsResponseMessage:      "NotifyFinalityConflictsResponse",
+	CmdFinalityConflictNotificationMessage:         "FinalityConflictNotification",
+	CmdFinalityConflictResolvedNotificationMessage: "FinalityConflictResolvedNotification",
+}
+
+// Message is an interface that describes a kaspa message. A type that
+// implements Message has complete control over the representation of its data
+// and may therefore contain additional or fewer fields than those which
+// are used directly in the protocol encoded message.
+type Message interface {
+	Command() MessageCommand
+	MessageNumber() uint64
+	SetMessageNumber(index uint64)
+	ReceivedAt() time.Time
+	SetReceivedAt(receivedAt time.Time)
+}
--- a/app/appmessage/p2p_blockheader.go
+++ b/app/appmessage/p2p_blockheader.go
@@ -2,23 +2,25 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
-	"bytes"
+	"fmt"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/pkg/errors"
 	"io"
-	"time"
-
-	"github.com/daglabs/btcd/dagconfig/daghash"
+	"math"
 )

 // BaseBlockHeaderPayload is the base number of bytes a block header can be,
 // not including the list of parent block headers.
 // Version 4 bytes + Timestamp 8 bytes + Bits 4 bytes + Nonce 8 bytes +
-// + NumParentBlocks 1 byte + HashMerkleRoot hash + IDMerkleRoot hash.
+// + NumParentBlocks 1 byte + HashMerkleRoot hash +
+// + AcceptedIDMerkleRoot hash + UTXOCommitment hash.
 // To get total size of block header len(ParentHashes) * daghash.HashSize should be
 // added to this value
-const BaseBlockHeaderPayload = 25 + 2*(daghash.HashSize)
+const BaseBlockHeaderPayload = 25 + 3*(daghash.HashSize)

 // MaxNumParentBlocks is the maximum number of parent blocks a block can reference.
 // Currently set to 255 as the maximum number NumParentBlocks can be due to it being a byte
@@ -28,10 +30,10 @@ const MaxNumParentBlocks = 255
 // BaseBlockHeaderPayload + up to MaxNumParentBlocks hashes of parent blocks
 const MaxBlockHeaderPayload = BaseBlockHeaderPayload + (MaxNumParentBlocks * daghash.HashSize)

-// BlockHeader defines information about a block and is used in the bitcoin
+// BlockHeader defines information about a block and is used in the kaspa
 // block (MsgBlock) and headers (MsgHeader) messages.
 type BlockHeader struct {
-	// Version of the block.  This is not the same as the protocol version.
+	// Version of the block. This is not the same as the protocol version.
 	Version int32

 	// Hashes of the parent block headers in the blockDAG.
@@ -40,11 +42,15 @@ type BlockHeader struct {
 	// HashMerkleRoot is the merkle tree reference to hash of all transactions for the block.
 	HashMerkleRoot *daghash.Hash

-	// IDMerkleRoot is the merkle tree reference to hash of all transactions' IDs for the block.
-	IDMerkleRoot *daghash.Hash
+	// AcceptedIDMerkleRoot is merkle tree reference to hash all transactions
+	// accepted form the block.Blues
+	AcceptedIDMerkleRoot *daghash.Hash
+
+	// UTXOCommitment is an ECMH UTXO commitment to the block UTXO.
+	UTXOCommitment *daghash.Hash

 	// Time the block was created.
-	Timestamp time.Time
+	Timestamp mstime.Time

 	// Difficulty target for the block.
 	Bits uint32
@@ -55,28 +61,28 @@ type BlockHeader struct {

 // NumParentBlocks return the number of entries in ParentHashes
 func (h *BlockHeader) NumParentBlocks() byte {
-	return byte(len(h.ParentHashes))
+	numParents := len(h.ParentHashes)
+	if numParents > math.MaxUint8 {
+		panic(errors.Errorf("number of parents is %d, which is more than one byte can fit", numParents))
+	}
+	return byte(numParents)
 }

 // BlockHash computes the block identifier hash for the given block header.
 func (h *BlockHeader) BlockHash() *daghash.Hash {
 	// Encode the header and double sha256 everything prior to the number of
-	// transactions.  Ignore the error returns since there is no way the
-	// encode could fail except being out of memory which would cause a
-	// run-time panic.
-	buf := bytes.NewBuffer(make([]byte, 0, BaseBlockHeaderPayload+h.NumParentBlocks()))
-	_ = writeBlockHeader(buf, 0, h)
-
-	return daghash.DoubleHashP(buf.Bytes())
-}
-
-// SelectedParentHash returns the hash of the selected block header.
-func (h *BlockHeader) SelectedParentHash() *daghash.Hash {
-	if h.NumParentBlocks() == 0 {
-		return nil
+	// transactions.
+	writer := daghash.NewDoubleHashWriter()
+	err := writeBlockHeader(writer, 0, h)
+	if err != nil {
+		// It seems like this could only happen if the writer returned an error.
+		// and this writer should never return an error (no allocations or possible failures)
+		// the only non-writer error path here is unknown types in `WriteElement`
+		panic(fmt.Sprintf("BlockHash() failed. this should never fail unless BlockHeader was changed. err: %+v", err))
 	}

-	return h.ParentHashes[0]
+	res := writer.Finalize()
+	return &res
 }

 // IsGenesis returns true iff this block is a genesis block
@@ -84,19 +90,19 @@ func (h *BlockHeader) IsGenesis() bool {
 	return h.NumParentBlocks() == 0
 }

-// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
 // This is part of the Message interface implementation.
 // See Deserialize for decoding block headers stored to disk, such as in a
-// database, as opposed to decoding block headers from the wire.
-func (h *BlockHeader) BtcDecode(r io.Reader, pver uint32) error {
+// database, as opposed to decoding block headers from the appmessage.
+func (h *BlockHeader) KaspaDecode(r io.Reader, pver uint32) error {
 	return readBlockHeader(r, pver, h)
 }

-// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
 // This is part of the Message interface implementation.
 // See Serialize for encoding block headers to be stored to disk, such as in a
-// database, as opposed to encoding block headers for the wire.
-func (h *BlockHeader) BtcEncode(w io.Writer, pver uint32) error {
+// database, as opposed to encoding block headers for the appmessage.
+func (h *BlockHeader) KaspaEncode(w io.Writer, pver uint32) error {
 	return writeBlockHeader(w, pver, h)
 }

@@ -104,8 +110,8 @@ func (h *BlockHeader) BtcEncode(w io.Writer, pver uint32) error {
 // that is suitable for long-term storage such as a database while respecting
 // the Version field.
 func (h *BlockHeader) Deserialize(r io.Reader) error {
-	// At the current time, there is no difference between the wire encoding
-	// at protocol version 0 and the stable long-term storage format.  As
+	// At the current time, there is no difference between the appmessage encoding
+	// at protocol version 0 and the stable long-term storage format. As
 	// a result, make use of readBlockHeader.
 	return readBlockHeader(r, 0, h)
 }
@@ -114,8 +120,8 @@ func (h *BlockHeader) Deserialize(r io.Reader) error {
 // that is suitable for long-term storage such as a database while respecting
 // the Version field.
 func (h *BlockHeader) Serialize(w io.Writer) error {
-	// At the current time, there is no difference between the wire encoding
-	// at protocol version 0 and the stable long-term storage format.  As
+	// At the current time, there is no difference between the appmessage encoding
+	// at protocol version 0 and the stable long-term storage format. As
 	// a result, make use of writeBlockHeader.
 	return writeBlockHeader(w, 0, h)
 }
@@ -127,27 +133,28 @@ func (h *BlockHeader) SerializeSize() int {
 }

 // NewBlockHeader returns a new BlockHeader using the provided version, previous
-// block hash, hash merkle root, ID merkle root difficulty bits, and nonce used to generate the
+// block hash, hash merkle root, accepted ID merkle root, difficulty bits, and nonce used to generate the
 // block with defaults or calclulated values for the remaining fields.
 func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot *daghash.Hash,
-	idMerkleRoot *daghash.Hash, bits uint32, nonce uint64) *BlockHeader {
+	acceptedIDMerkleRoot *daghash.Hash, utxoCommitment *daghash.Hash, bits uint32, nonce uint64) *BlockHeader {

-	// Limit the timestamp to one second precision since the protocol
+	// Limit the timestamp to one millisecond precision since the protocol
 	// doesn't support better.
 	return &BlockHeader{
-		Version:        version,
-		ParentHashes:   parentHashes,
-		HashMerkleRoot: hashMerkleRoot,
-		IDMerkleRoot:   idMerkleRoot,
-		Timestamp:      time.Unix(time.Now().Unix(), 0),
-		Bits:           bits,
-		Nonce:          nonce,
+		Version:              version,
+		ParentHashes:         parentHashes,
+		HashMerkleRoot:       hashMerkleRoot,
+		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
+		UTXOCommitment:       utxoCommitment,
+		Timestamp:            mstime.Now(),
+		Bits:                 bits,
+		Nonce:                nonce,
 	}
 }

-// readBlockHeader reads a bitcoin block header from r.  See Deserialize for
+// readBlockHeader reads a kaspa block header from r. See Deserialize for
 // decoding block headers stored to disk, such as in a database, as opposed to
-// decoding from the wire.
+// decoding from the appmessage.
 func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
 	var numParentBlocks byte
 	err := readElements(r, &bh.Version, &numParentBlocks)
@@ -165,15 +172,17 @@ func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
 		bh.ParentHashes[i] = hash
 	}
 	bh.HashMerkleRoot = &daghash.Hash{}
-	bh.IDMerkleRoot = &daghash.Hash{}
-	return readElements(r, bh.HashMerkleRoot, bh.IDMerkleRoot, (*int64Time)(&bh.Timestamp), &bh.Bits, &bh.Nonce)
+	bh.AcceptedIDMerkleRoot = &daghash.Hash{}
+	bh.UTXOCommitment = &daghash.Hash{}
+	return readElements(r, bh.HashMerkleRoot, bh.AcceptedIDMerkleRoot, bh.UTXOCommitment,
+		(*int64Time)(&bh.Timestamp), &bh.Bits, &bh.Nonce)
 }

-// writeBlockHeader writes a bitcoin block header to w.  See Serialize for
+// writeBlockHeader writes a kaspa block header to w. See Serialize for
 // encoding block headers to be stored to disk, such as in a database, as
-// opposed to encoding for the wire.
+// opposed to encoding for the appmessage.
 func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
-	sec := int64(bh.Timestamp.Unix())
+	timestamp := bh.Timestamp.UnixMilliseconds()
 	if err := writeElements(w, bh.Version, bh.NumParentBlocks()); err != nil {
 		return err
 	}
@@ -182,6 +191,5 @@ func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
 			return err
 		}
 	}
-	return writeElements(w, bh.HashMerkleRoot, bh.IDMerkleRoot,
-		sec, bh.Bits, bh.Nonce)
+	return writeElements(w, bh.HashMerkleRoot, bh.AcceptedIDMerkleRoot, bh.UTXOCommitment, timestamp, bh.Bits, bh.Nonce)
 }
--- a/app/appmessage/p2p_blockheader_test.go
+++ b/app/appmessage/p2p_blockheader_test.go
@@ -2,17 +2,16 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
 	"bytes"
+	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/kaspanet/kaspad/util/random"
 	"reflect"
 	"testing"
-	"time"
-
-	"github.com/daglabs/btcd/dagconfig/daghash"
-	"github.com/daglabs/btcd/util/random"
-	"github.com/davecgh/go-spew/spew"
 )

 // TestBlockHeader tests the BlockHeader API.
@@ -22,12 +21,12 @@ func TestBlockHeader(t *testing.T) {
 		t.Errorf("random.Uint64: Error generating nonce: %v", err)
 	}

-	hashes := []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash}
+	hashes := []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash}

-	merkleHash := mainNetGenesisMerkleRoot
-	idMerkleRoot := exampleIDMerkleRoot
+	merkleHash := mainnetGenesisMerkleRoot
+	acceptedIDMerkleRoot := exampleAcceptedIDMerkleRoot
 	bits := uint32(0x1d00ffff)
-	bh := NewBlockHeader(1, hashes, merkleHash, idMerkleRoot, bits, nonce)
+	bh := NewBlockHeader(1, hashes, merkleHash, acceptedIDMerkleRoot, exampleUTXOCommitment, bits, nonce)

 	// Ensure we get the same data back out.
 	if !reflect.DeepEqual(bh.ParentHashes, hashes) {
@@ -48,33 +47,34 @@ func TestBlockHeader(t *testing.T) {
 	}
 }

-// TestBlockHeaderWire tests the BlockHeader wire encode and decode for various
+// TestBlockHeaderEncoding tests the BlockHeader appmessage encode and decode for various
 // protocol versions.
-func TestBlockHeaderWire(t *testing.T) {
+func TestBlockHeaderEncoding(t *testing.T) {
 	nonce := uint64(123123) // 0x000000000001e0f3
 	pver := ProtocolVersion

 	// baseBlockHdr is used in the various tests as a baseline BlockHeader.
 	bits := uint32(0x1d00ffff)
 	baseBlockHdr := &BlockHeader{
-		Version:        1,
-		ParentHashes:   []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
-		HashMerkleRoot: mainNetGenesisMerkleRoot,
-		IDMerkleRoot:   exampleIDMerkleRoot,
-		Timestamp:      time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
-		Bits:           bits,
-		Nonce:          nonce,
+		Version:              1,
+		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot:       mainnetGenesisMerkleRoot,
+		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
+		UTXOCommitment:       exampleUTXOCommitment,
+		Timestamp:            mstime.UnixMilliseconds(0x17315ed0f99),
+		Bits:                 bits,
+		Nonce:                nonce,
 	}

-	// baseBlockHdrEncoded is the wire encoded bytes of baseBlockHdr.
+	// baseBlockHdrEncoded is the appmessage encoded bytes of baseBlockHdr.
 	baseBlockHdrEncoded := []byte{
 		0x01, 0x00, 0x00, 0x00, // Version 1
 		0x02,                                           // NumParentBlocks
-		0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainNetGenesisHash
-		0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-		0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-		0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simNetGenesisHash
+		0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainnetGenesisHash
+		0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+		0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+		0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
+		0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simnetGenesisHash
 		0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 		0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
 		0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
@@ -82,20 +82,24 @@ func TestBlockHeaderWire(t *testing.T) {
 		0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 		0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 		0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
-		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
-		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
+		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
-		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
+		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
+		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
+		0x10, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // UTXOCommitment
+		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
+		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
+		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
+		0x99, 0x0f, 0xed, 0x15, 0x73, 0x01, 0x00, 0x00, // Timestamp
 		0xff, 0xff, 0x00, 0x1d, // Bits
-		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
+		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 	}

 	tests := []struct {
 		in   *BlockHeader // Data to encode
 		out  *BlockHeader // Expected decoded data
-		buf  []byte       // Wire encoding
-		pver uint32       // Protocol version for wire encoding
+		buf  []byte       // Encoded data
+		pver uint32       // Protocol version for appmessage encoding
 	}{
 		// Latest protocol version.
 		{
@@ -108,7 +112,7 @@ func TestBlockHeaderWire(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		var buf bytes.Buffer
 		err := writeBlockHeader(&buf, test.pver, test.in)
 		if err != nil {
@@ -122,18 +126,18 @@ func TestBlockHeaderWire(t *testing.T) {
 		}

 		buf.Reset()
-		err = test.in.BtcEncode(&buf, pver)
+		err = test.in.KaspaEncode(&buf, pver)
 		if err != nil {
-			t.Errorf("BtcEncode #%d error %v", i, err)
+			t.Errorf("KaspaEncode #%d error %v", i, err)
 			continue
 		}
 		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("BtcEncode #%d\n got: %s want: %s", i,
+			t.Errorf("KaspaEncode #%d\n got: %s want: %s", i,
 				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
 			continue
 		}

-		// Decode the block header from wire format.
+		// Decode the block header from appmessage format.
 		var bh BlockHeader
 		rbuf := bytes.NewReader(test.buf)
 		err = readBlockHeader(rbuf, test.pver, &bh)
@@ -148,13 +152,13 @@ func TestBlockHeaderWire(t *testing.T) {
 		}

 		rbuf = bytes.NewReader(test.buf)
-		err = bh.BtcDecode(rbuf, pver)
+		err = bh.KaspaDecode(rbuf, pver)
 		if err != nil {
-			t.Errorf("BtcDecode #%d error %v", i, err)
+			t.Errorf("KaspaDecode #%d error %v", i, err)
 			continue
 		}
 		if !reflect.DeepEqual(&bh, test.out) {
-			t.Errorf("BtcDecode #%d\n got: %s want: %s", i,
+			t.Errorf("KaspaDecode #%d\n got: %s want: %s", i,
 				spew.Sdump(&bh), spew.Sdump(test.out))
 			continue
 		}
@@ -168,24 +172,25 @@ func TestBlockHeaderSerialize(t *testing.T) {
 	// baseBlockHdr is used in the various tests as a baseline BlockHeader.
 	bits := uint32(0x1d00ffff)
 	baseBlockHdr := &BlockHeader{
-		Version:        1,
-		ParentHashes:   []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
-		HashMerkleRoot: mainNetGenesisMerkleRoot,
-		IDMerkleRoot:   exampleIDMerkleRoot,
-		Timestamp:      time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
-		Bits:           bits,
-		Nonce:          nonce,
+		Version:              1,
+		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot:       mainnetGenesisMerkleRoot,
+		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
+		UTXOCommitment:       exampleUTXOCommitment,
+		Timestamp:            mstime.UnixMilliseconds(0x17315ed0f99),
+		Bits:                 bits,
+		Nonce:                nonce,
 	}

-	// baseBlockHdrEncoded is the wire encoded bytes of baseBlockHdr.
+	// baseBlockHdrEncoded is the appmessage encoded bytes of baseBlockHdr.
 	baseBlockHdrEncoded := []byte{
 		0x01, 0x00, 0x00, 0x00, // Version 1
 		0x02,                                           // NumParentBlocks
-		0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainNetGenesisHash
-		0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-		0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-		0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
-		0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simNetGenesisHash
+		0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainnetGenesisHash
+		0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+		0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+		0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
+		0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simnetGenesisHash
 		0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 		0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
 		0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
@@ -193,13 +198,17 @@ func TestBlockHeaderSerialize(t *testing.T) {
 		0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 		0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 		0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
-		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
-		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
+		0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
-		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
+		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
+		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
+		0x10, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // UTXOCommitment
+		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
+		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
+		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
+		0x99, 0x0f, 0xed, 0x15, 0x73, 0x01, 0x00, 0x00, // Timestamp
 		0xff, 0xff, 0x00, 0x1d, // Bits
-		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
+		0xf3, 0xe0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 	}

 	tests := []struct {
@@ -250,35 +259,37 @@ func TestBlockHeaderSerialize(t *testing.T) {
 func TestBlockHeaderSerializeSize(t *testing.T) {
 	nonce := uint64(123123) // 0x1e0f3
 	bits := uint32(0x1d00ffff)
-	timestamp := time.Unix(0x495fab29, 0) // 2009-01-03 12:15:05 -0600 CST
+	timestamp := mstime.UnixMilliseconds(0x495fab29000)
 	baseBlockHdr := &BlockHeader{
-		Version:        1,
-		ParentHashes:   []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
-		HashMerkleRoot: mainNetGenesisMerkleRoot,
-		IDMerkleRoot:   mainNetGenesisMerkleRoot,
-		Timestamp:      timestamp,
-		Bits:           bits,
-		Nonce:          nonce,
+		Version:              1,
+		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot:       mainnetGenesisMerkleRoot,
+		AcceptedIDMerkleRoot: &daghash.ZeroHash,
+		UTXOCommitment:       &daghash.ZeroHash,
+		Timestamp:            timestamp,
+		Bits:                 bits,
+		Nonce:                nonce,
 	}

 	genesisBlockHdr := &BlockHeader{
-		Version:        1,
-		ParentHashes:   []*daghash.Hash{},
-		HashMerkleRoot: mainNetGenesisMerkleRoot,
-		IDMerkleRoot:   mainNetGenesisMerkleRoot,
-		Timestamp:      timestamp,
-		Bits:           bits,
-		Nonce:          nonce,
+		Version:              1,
+		ParentHashes:         []*daghash.Hash{},
+		HashMerkleRoot:       mainnetGenesisMerkleRoot,
+		AcceptedIDMerkleRoot: &daghash.ZeroHash,
+		UTXOCommitment:       &daghash.ZeroHash,
+		Timestamp:            timestamp,
+		Bits:                 bits,
+		Nonce:                nonce,
 	}
 	tests := []struct {
 		in   *BlockHeader // Block header to encode
 		size int          // Expected serialized size
 	}{
 		// Block with no transactions.
-		{genesisBlockHdr, 89},
+		{genesisBlockHdr, 121},

 		// First block in the mainnet block DAG.
-		{baseBlockHdr, 153},
+		{baseBlockHdr, 185},
 	}

 	t.Logf("Running %d tests", len(tests))
@@ -296,12 +307,12 @@ func TestBlockHeaderSerializeSize(t *testing.T) {
 func TestIsGenesis(t *testing.T) {
 	nonce := uint64(123123) // 0x1e0f3
 	bits := uint32(0x1d00ffff)
-	timestamp := time.Unix(0x495fab29, 0) // 2009-01-03 12:15:05 -0600 CST
+	timestamp := mstime.UnixMilliseconds(0x495fab29000)

 	baseBlockHdr := &BlockHeader{
 		Version:        1,
-		ParentHashes:   []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
-		HashMerkleRoot: mainNetGenesisMerkleRoot,
+		ParentHashes:   []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot: mainnetGenesisMerkleRoot,
 		Timestamp:      timestamp,
 		Bits:           bits,
 		Nonce:          nonce,
@@ -309,7 +320,7 @@ func TestIsGenesis(t *testing.T) {
 	genesisBlockHdr := &BlockHeader{
 		Version:        1,
 		ParentHashes:   []*daghash.Hash{},
-		HashMerkleRoot: mainNetGenesisMerkleRoot,
+		HashMerkleRoot: mainnetGenesisMerkleRoot,
 		Timestamp:      timestamp,
 		Bits:           bits,
 		Nonce:          nonce,
--- a/app/appmessage/p2p_msgaddresses.go
+++ b/app/appmessage/p2p_msgaddresses.go
@@ -0,0 +1,75 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"fmt"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+)
+
+// MaxAddressesPerMsg is the maximum number of addresses that can be in a single
+// kaspa Addresses message (MsgAddresses).
+const MaxAddressesPerMsg = 1000
+
+// MsgAddresses implements the Message interface and represents a kaspa
+// Addresses message. It is used to provide a list of known active peers on the
+// network. An active peer is considered one that has transmitted a message
+// within the last 3 hours. Nodes which have not transmitted in that time
+// frame should be forgotten. Each message is limited to a maximum number of
+// addresses, which is currently 1000. As a result, multiple messages must
+// be used to relay the full list.
+//
+// Use the AddAddress function to build up the list of known addresses when
+// sending an Addresses message to another peer.
+type MsgAddresses struct {
+	baseMessage
+	IncludeAllSubnetworks bool
+	SubnetworkID          *subnetworkid.SubnetworkID
+	AddrList              []*NetAddress
+}
+
+// AddAddress adds a known active peer to the message.
+func (msg *MsgAddresses) AddAddress(na *NetAddress) error {
+	if len(msg.AddrList)+1 > MaxAddressesPerMsg {
+		str := fmt.Sprintf("too many addresses in message [max %d]",
+			MaxAddressesPerMsg)
+		return messageError("MsgAddresses.AddAddress", str)
+	}
+
+	msg.AddrList = append(msg.AddrList, na)
+	return nil
+}
+
+// AddAddresses adds multiple known active peers to the message.
+func (msg *MsgAddresses) AddAddresses(netAddrs ...*NetAddress) error {
+	for _, na := range netAddrs {
+		err := msg.AddAddress(na)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ClearAddresses removes all addresses from the message.
+func (msg *MsgAddresses) ClearAddresses() {
+	msg.AddrList = []*NetAddress{}
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgAddresses) Command() MessageCommand {
+	return CmdAddresses
+}
+
+// NewMsgAddresses returns a new kaspa Addresses message that conforms to the
+// Message interface. See MsgAddresses for details.
+func NewMsgAddresses(includeAllSubnetworks bool, subnetworkID *subnetworkid.SubnetworkID) *MsgAddresses {
+	return &MsgAddresses{
+		IncludeAllSubnetworks: includeAllSubnetworks,
+		SubnetworkID:          subnetworkID,
+		AddrList:              make([]*NetAddress, 0, MaxAddressesPerMsg),
+	}
+}
--- a/app/appmessage/p2p_msgaddresses_test.go
+++ b/app/appmessage/p2p_msgaddresses_test.go
@@ -0,0 +1,58 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"net"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+// TestAddresses tests the MsgAddresses API.
+func TestAddresses(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(3)
+	msg := NewMsgAddresses(false, nil)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgAddresses: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+
+	// Ensure NetAddresses are added properly.
+	tcpAddr := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 16111}
+	na := NewNetAddress(tcpAddr, SFNodeNetwork)
+	err := msg.AddAddress(na)
+	if err != nil {
+		t.Errorf("AddAddress: %v", err)
+	}
+	if msg.AddrList[0] != na {
+		t.Errorf("AddAddress: wrong address added - got %v, want %v",
+			spew.Sprint(msg.AddrList[0]), spew.Sprint(na))
+	}
+
+	// Ensure the address list is cleared properly.
+	msg.ClearAddresses()
+	if len(msg.AddrList) != 0 {
+		t.Errorf("ClearAddresses: address list is not empty - "+
+			"got %v [%v], want %v", len(msg.AddrList),
+			spew.Sprint(msg.AddrList[0]), 0)
+	}
+
+	// Ensure adding more than the max allowed addresses per message returns
+	// error.
+	for i := 0; i < MaxAddressesPerMsg+1; i++ {
+		err = msg.AddAddress(na)
+	}
+	if err == nil {
+		t.Errorf("AddAddress: expected error on too many addresses " +
+			"not received")
+	}
+	err = msg.AddAddresses(na)
+	if err == nil {
+		t.Errorf("AddAddresses: expected error on too many addresses " +
+			"not received")
+	}
+}
--- a/app/appmessage/p2p_msgblock.go
+++ b/app/appmessage/p2p_msgblock.go
@@ -2,34 +2,37 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
 	"bytes"
 	"fmt"
 	"io"

-	"github.com/daglabs/btcd/util/subnetworkid"
+	"github.com/kaspanet/kaspad/util/subnetworkid"

-	"github.com/daglabs/btcd/dagconfig/daghash"
+	"github.com/kaspanet/kaspad/util/daghash"
 )

 // defaultTransactionAlloc is the default size used for the backing array
-// for transactions.  The transaction array will dynamically grow as needed, but
+// for transactions. The transaction array will dynamically grow as needed, but
 // this figure is intended to provide enough space for the number of
 // transactions in the vast majority of blocks without needing to grow the
 // backing array multiple times.
 const defaultTransactionAlloc = 2048

-// MaxBlocksPerMsg is the maximum number of blocks allowed per message.
-const MaxBlocksPerMsg = 500
+// MaxMassAcceptedByBlock is the maximum total transaction mass a block may accept.
+const MaxMassAcceptedByBlock = 10000000

-// MaxBlockPayload is the maximum bytes a block message can be in bytes.
-const MaxBlockPayload = 1000000
+// MaxMassPerTx is the maximum total mass a transaction may have.
+const MaxMassPerTx = MaxMassAcceptedByBlock / 2

-// maxTxPerBlock is the maximum number of transactions that could
+// MaxTxPerBlock is the maximum number of transactions that could
 // possibly fit into a block.
-const maxTxPerBlock = (MaxBlockPayload / minTxPayload) + 1
+const MaxTxPerBlock = (MaxMassAcceptedByBlock / minTxPayload) + 1
+
+// MaxBlockParents is the maximum allowed number of parents for block.
+const MaxBlockParents = 10

 // TxLoc holds locator data for the offset and length of where a transaction is
 // located within a MsgBlock data buffer.
@@ -38,10 +41,11 @@ type TxLoc struct {
 	TxLen   int
 }

-// MsgBlock implements the Message interface and represents a bitcoin
-// block message.  It is used to deliver block and transaction information in
+// MsgBlock implements the Message interface and represents a kaspa
+// block message. It is used to deliver block and transaction information in
 // response to a getdata message (MsgGetData) for a given block hash.
 type MsgBlock struct {
+	baseMessage
 	Header       BlockHeader
 	Transactions []*MsgTx
 }
@@ -56,11 +60,11 @@ func (msg *MsgBlock) ClearTransactions() {
 	msg.Transactions = make([]*MsgTx, 0, defaultTransactionAlloc)
 }

-// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
 // This is part of the Message interface implementation.
 // See Deserialize for decoding blocks stored to disk, such as in a database, as
-// opposed to decoding blocks from the wire.
-func (msg *MsgBlock) BtcDecode(r io.Reader, pver uint32) error {
+// opposed to decoding blocks from the appmessage.
+func (msg *MsgBlock) KaspaDecode(r io.Reader, pver uint32) error {
 	err := readBlockHeader(r, pver, &msg.Header)
 	if err != nil {
 		return err
@@ -74,16 +78,16 @@ func (msg *MsgBlock) BtcDecode(r io.Reader, pver uint32) error {
 	// Prevent more transactions than could possibly fit into a block.
 	// It would be possible to cause memory exhaustion and panics without
 	// a sane upper bound on this count.
-	if txCount > maxTxPerBlock {
+	if txCount > MaxTxPerBlock {
 		str := fmt.Sprintf("too many transactions to fit into a block "+
-			"[count %d, max %d]", txCount, maxTxPerBlock)
-		return messageError("MsgBlock.BtcDecode", str)
+			"[count %d, max %d]", txCount, MaxTxPerBlock)
+		return messageError("MsgBlock.KaspaDecode", str)
 	}

 	msg.Transactions = make([]*MsgTx, 0, txCount)
 	for i := uint64(0); i < txCount; i++ {
 		tx := MsgTx{}
-		err := tx.BtcDecode(r, pver)
+		err := tx.KaspaDecode(r, pver)
 		if err != nil {
 			return err
 		}
@@ -95,18 +99,18 @@ func (msg *MsgBlock) BtcDecode(r io.Reader, pver uint32) error {

 // Deserialize decodes a block from r into the receiver using a format that is
 // suitable for long-term storage such as a database while respecting the
-// Version field in the block.  This function differs from BtcDecode in that
-// BtcDecode decodes from the bitcoin wire protocol as it was sent across the
-// network.  The wire encoding can technically differ depending on the protocol
+// Version field in the block. This function differs from KaspaDecode in that
+// KaspaDecode decodes from the kaspa appmessage protocol as it was sent across the
+// network. The appmessage encoding can technically differ depending on the protocol
 // version and doesn't even really need to match the format of a stored block at
-// all.  As of the time this comment was written, the encoded block is the same
+// all. As of the time this comment was written, the encoded block is the same
 // in both instances, but there is a distinct difference and separating the two
 // allows the API to be flexible enough to deal with changes.
 func (msg *MsgBlock) Deserialize(r io.Reader) error {
-	// At the current time, there is no difference between the wire encoding
-	// at protocol version 0 and the stable long-term storage format.  As
-	// a result, make use of BtcDecode.
-	return msg.BtcDecode(r, 0)
+	// At the current time, there is no difference between the appmessage encoding
+	// at protocol version 0 and the stable long-term storage format. As
+	// a result, make use of KaspaDecode.
+	return msg.KaspaDecode(r, 0)
 }

 // DeserializeTxLoc decodes r in the same manner Deserialize does, but it takes
@@ -116,9 +120,9 @@ func (msg *MsgBlock) Deserialize(r io.Reader) error {
 func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
 	fullLen := r.Len()

-	// At the current time, there is no difference between the wire encoding
-	// at protocol version 0 and the stable long-term storage format.  As
-	// a result, make use of existing wire protocol functions.
+	// At the current time, there is no difference between the appmessage encoding
+	// at protocol version 0 and the stable long-term storage format. As
+	// a result, make use of existing appmessage protocol functions.
 	err := readBlockHeader(r, 0, &msg.Header)
 	if err != nil {
 		return nil, err
@@ -132,9 +136,9 @@ func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
 	// Prevent more transactions than could possibly fit into a block.
 	// It would be possible to cause memory exhaustion and panics without
 	// a sane upper bound on this count.
-	if txCount > maxTxPerBlock {
+	if txCount > MaxTxPerBlock {
 		str := fmt.Sprintf("too many transactions to fit into a block "+
-			"[count %d, max %d]", txCount, maxTxPerBlock)
+			"[count %d, max %d]", txCount, MaxTxPerBlock)
 		return nil, messageError("MsgBlock.DeserializeTxLoc", str)
 	}

@@ -156,11 +160,11 @@ func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
 	return txLocs, nil
 }

-// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
 // This is part of the Message interface implementation.
 // See Serialize for encoding blocks to be stored to disk, such as in a
-// database, as opposed to encoding blocks for the wire.
-func (msg *MsgBlock) BtcEncode(w io.Writer, pver uint32) error {
+// database, as opposed to encoding blocks for the appmessage.
+func (msg *MsgBlock) KaspaEncode(w io.Writer, pver uint32) error {
 	err := writeBlockHeader(w, pver, &msg.Header)
 	if err != nil {
 		return err
@@ -172,7 +176,7 @@ func (msg *MsgBlock) BtcEncode(w io.Writer, pver uint32) error {
 	}

 	for _, tx := range msg.Transactions {
-		err = tx.BtcEncode(w, pver)
+		err = tx.KaspaEncode(w, pver)
 		if err != nil {
 			return err
 		}
@@ -183,18 +187,18 @@ func (msg *MsgBlock) BtcEncode(w io.Writer, pver uint32) error {

 // Serialize encodes the block to w using a format that suitable for long-term
 // storage such as a database while respecting the Version field in the block.
-// This function differs from BtcEncode in that BtcEncode encodes the block to
-// the bitcoin wire protocol in order to be sent across the network.  The wire
+// This function differs from KaspaEncode in that KaspaEncode encodes the block to
+// the kaspa appmessage protocol in order to be sent across the network. The appmessage
 // encoding can technically differ depending on the protocol version and doesn't
-// even really need to match the format of a stored block at all.  As of the
+// even really need to match the format of a stored block at all. As of the
 // time this comment was written, the encoded block is the same in both
 // instances, but there is a distinct difference and separating the two allows
 // the API to be flexible enough to deal with changes.
 func (msg *MsgBlock) Serialize(w io.Writer) error {
-	// At the current time, there is no difference between the wire encoding
-	// at protocol version 0 and the stable long-term storage format.  As
-	// a result, make use of BtcEncode.
-	return msg.BtcEncode(w, 0)
+	// At the current time, there is no difference between the appmessage encoding
+	// at protocol version 0 and the stable long-term storage format. As
+	// a result, make use of KaspaEncode.
+	return msg.KaspaEncode(w, 0)
 }

 // SerializeSize returns the number of bytes it would take to serialize the
@@ -211,19 +215,16 @@ func (msg *MsgBlock) SerializeSize() int {
 	return n
 }

-// Command returns the protocol command string for the message.  This is part
+// Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.
-func (msg *MsgBlock) Command() string {
+func (msg *MsgBlock) Command() MessageCommand {
 	return CmdBlock
 }

 // MaxPayloadLength returns the maximum length the payload can be for the
-// receiver.  This is part of the Message interface implementation.
+// receiver. This is part of the Message interface implementation.
 func (msg *MsgBlock) MaxPayloadLength(pver uint32) uint32 {
-	// Block header at 80 bytes + transaction count + max transactions
-	// which can vary up to the MaxBlockPayload (including the block header
-	// and transaction count).
-	return MaxBlockPayload
+	return MaxMessagePayload
 }

 // BlockHash computes the block identifier hash for this block.
@@ -242,8 +243,8 @@ func (msg *MsgBlock) ConvertToPartial(subnetworkID *subnetworkid.SubnetworkID) {
 	}
 }

-// NewMsgBlock returns a new bitcoin block message that conforms to the
-// Message interface.  See MsgBlock for details.
+// NewMsgBlock returns a new kaspa block message that conforms to the
+// Message interface. See MsgBlock for details.
 func NewMsgBlock(blockHeader *BlockHeader) *MsgBlock {
 	return &MsgBlock{
 		Header:       *blockHeader,
--- a/app/appmessage/p2p_msgblock_test.go
+++ b/app/appmessage/p2p_msgblock_test.go
@@ -2,20 +2,20 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
 	"bytes"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+	"github.com/pkg/errors"
 	"io"
 	"math"
 	"reflect"
 	"testing"
-	"time"

-	"github.com/daglabs/btcd/util/subnetworkid"
-
-	"github.com/daglabs/btcd/dagconfig/daghash"
 	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/util/daghash"
 )

 // TestBlock tests the MsgBlock API.
@@ -25,13 +25,14 @@ func TestBlock(t *testing.T) {
 	// Block 1 header.
 	parentHashes := blockOne.Header.ParentHashes
 	hashMerkleRoot := blockOne.Header.HashMerkleRoot
-	idMerkleRoot := blockOne.Header.IDMerkleRoot
+	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
+	utxoCommitment := blockOne.Header.UTXOCommitment
 	bits := blockOne.Header.Bits
 	nonce := blockOne.Header.Nonce
-	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, idMerkleRoot, bits, nonce)
+	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)

 	// Ensure the command is expected value.
-	wantCmd := "block"
+	wantCmd := MessageCommand(5)
 	msg := NewMsgBlock(bh)
 	if cmd := msg.Command(); cmd != wantCmd {
 		t.Errorf("NewMsgBlock: wrong command - got %v want %v",
@@ -39,8 +40,7 @@ func TestBlock(t *testing.T) {
 	}

 	// Ensure max payload is expected value for latest protocol version.
-	// Num addresses (varInt) + max allowed addresses.
-	wantPayload := uint32(1000000)
+	wantPayload := uint32(1024 * 1024 * 32)
 	maxPayload := msg.MaxPayloadLength(pver)
 	if maxPayload != wantPayload {
 		t.Errorf("MaxPayloadLength: wrong max payload length for "+
@@ -74,7 +74,7 @@ func TestBlock(t *testing.T) {
 // TestBlockHash tests the ability to generate the hash of a block accurately.
 func TestBlockHash(t *testing.T) {
 	// Block 1 hash.
-	hashStr := "67ec32b619b4cda3255de5318c730e2e9f696d335427adfecae884aa41156b0f"
+	hashStr := "55d71bd49a8233bc9f0edbcbd0ad5d3eaebffe1fc6a6443a1c1f310fd02c11a5"
 	wantHash, err := daghash.NewHashFromStr(hashStr)
 	if err != nil {
 		t.Errorf("NewHashFromStr: %v", err)
@@ -144,15 +144,15 @@ func TestConvertToPartial(t *testing.T) {
 	}
 }

-// TestBlockWire tests the MsgBlock wire encode and decode for various numbers
+// TestBlockEncoding tests the MsgBlock appmessage encode and decode for various numbers
 // of transaction inputs and outputs and protocol versions.
-func TestBlockWire(t *testing.T) {
+func TestBlockEncoding(t *testing.T) {
 	tests := []struct {
 		in     *MsgBlock // Message to encode
 		out    *MsgBlock // Expected decoded message
-		buf    []byte    // Wire encoding
+		buf    []byte    // Encoded value
 		txLocs []TxLoc   // Expected transaction locations
-		pver   uint32    // Protocol version for wire encoding
+		pver   uint32    // Protocol version for appmessage encoding
 	}{
 		// Latest protocol version.
 		{
@@ -166,44 +166,44 @@ func TestBlockWire(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode the message to wire format.
+		// Encode the message to appmessage format.
 		var buf bytes.Buffer
-		err := test.in.BtcEncode(&buf, test.pver)
+		err := test.in.KaspaEncode(&buf, test.pver)
 		if err != nil {
-			t.Errorf("BtcEncode #%d error %v", i, err)
+			t.Errorf("KaspaEncode #%d error %v", i, err)
 			continue
 		}
 		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("BtcEncode #%d\n got: %s want: %s", i,
+			t.Errorf("KaspaEncode #%d\n got: %s want: %s", i,
 				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
 			continue
 		}

-		// Decode the message from wire format.
+		// Decode the message from appmessage format.
 		var msg MsgBlock
 		rbuf := bytes.NewReader(test.buf)
-		err = msg.BtcDecode(rbuf, test.pver)
+		err = msg.KaspaDecode(rbuf, test.pver)
 		if err != nil {
-			t.Errorf("BtcDecode #%d error %v", i, err)
+			t.Errorf("KaspaDecode #%d error %v", i, err)
 			continue
 		}
 		if !reflect.DeepEqual(&msg, test.out) {
-			t.Errorf("BtcDecode #%d\n got: %s want: %s", i,
+			t.Errorf("KaspaDecode #%d\n got: %s want: %s", i,
 				spew.Sdump(&msg), spew.Sdump(test.out))
 			continue
 		}
 	}
 }

-// TestBlockWireErrors performs negative tests against wire encode and decode
+// TestBlockEncodingErrors performs negative tests against appmessage encode and decode
 // of MsgBlock to confirm error paths work correctly.
-func TestBlockWireErrors(t *testing.T) {
+func TestBlockEncodingErrors(t *testing.T) {
 	pver := ProtocolVersion

 	tests := []struct {
 		in       *MsgBlock // Value to encode
-		buf      []byte    // Wire encoding
-		pver     uint32    // Protocol version for wire encoding
+		buf      []byte    // Encoded value
+		pver     uint32    // Protocol version for appmessage encoding
 		max      int       // Max size of fixed buffer to induce errors
 		writeErr error     // Expected write error
 		readErr  error     // Expected read error
@@ -218,37 +218,39 @@ func TestBlockWireErrors(t *testing.T) {
 		{&blockOne, blockOneBytes, pver, 37, io.ErrShortWrite, io.EOF},
 		// Force error in hash merkle root.
 		{&blockOne, blockOneBytes, pver, 69, io.ErrShortWrite, io.EOF},
-		// Force error in ID merkle root.
+		// Force error in accepted ID merkle root.
 		{&blockOne, blockOneBytes, pver, 101, io.ErrShortWrite, io.EOF},
-		// Force error in timestamp.
+		// Force error in utxo commitment.
 		{&blockOne, blockOneBytes, pver, 133, io.ErrShortWrite, io.EOF},
+		// Force error in timestamp.
+		{&blockOne, blockOneBytes, pver, 165, io.ErrShortWrite, io.EOF},
 		// Force error in difficulty bits.
-		{&blockOne, blockOneBytes, pver, 141, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 173, io.ErrShortWrite, io.EOF},
 		// Force error in header nonce.
-		{&blockOne, blockOneBytes, pver, 145, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 177, io.ErrShortWrite, io.EOF},
 		// Force error in transaction count.
-		{&blockOne, blockOneBytes, pver, 153, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 185, io.ErrShortWrite, io.EOF},
 		// Force error in transactions.
-		{&blockOne, blockOneBytes, pver, 154, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, pver, 186, io.ErrShortWrite, io.EOF},
 	}

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
-		err := test.in.BtcEncode(w, test.pver)
-		if err != test.writeErr {
-			t.Errorf("BtcEncode #%d wrong error got: %v, want: %v",
+		err := test.in.KaspaEncode(w, test.pver)
+		if !errors.Is(err, test.writeErr) {
+			t.Errorf("KaspaEncode #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}

-		// Decode from wire format.
+		// Decode from appmessage format.
 		var msg MsgBlock
 		r := newFixedReader(test.max, test.buf)
-		err = msg.BtcDecode(r, test.pver)
-		if err != test.readErr {
-			t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
+		err = msg.KaspaDecode(r, test.pver)
+		if !errors.Is(err, test.readErr) {
+			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
 		}
@@ -322,7 +324,7 @@ func TestBlockSerialize(t *testing.T) {
 	}
 }

-// TestBlockSerializeErrors performs negative tests against wire encode and
+// TestBlockSerializeErrors performs negative tests against appmessage encode and
 // decode of MsgBlock to confirm error paths work correctly.
 func TestBlockSerializeErrors(t *testing.T) {
 	tests := []struct {
@@ -342,18 +344,20 @@ func TestBlockSerializeErrors(t *testing.T) {
 		{&blockOne, blockOneBytes, 37, io.ErrShortWrite, io.EOF},
 		// Force error in hash merkle root.
 		{&blockOne, blockOneBytes, 69, io.ErrShortWrite, io.EOF},
-		// Force error in ID merkle root.
+		// Force error in accepted ID merkle root.
 		{&blockOne, blockOneBytes, 101, io.ErrShortWrite, io.EOF},
-		// Force error in timestamp.
+		// Force error in utxo commitment.
 		{&blockOne, blockOneBytes, 133, io.ErrShortWrite, io.EOF},
+		// Force error in timestamp.
+		{&blockOne, blockOneBytes, 165, io.ErrShortWrite, io.EOF},
 		// Force error in difficulty bits.
-		{&blockOne, blockOneBytes, 141, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 173, io.ErrShortWrite, io.EOF},
 		// Force error in header nonce.
-		{&blockOne, blockOneBytes, 145, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 177, io.ErrShortWrite, io.EOF},
 		// Force error in transaction count.
-		{&blockOne, blockOneBytes, 153, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 185, io.ErrShortWrite, io.EOF},
 		// Force error in transactions.
-		{&blockOne, blockOneBytes, 154, io.ErrShortWrite, io.EOF},
+		{&blockOne, blockOneBytes, 186, io.ErrShortWrite, io.EOF},
 	}

 	t.Logf("Running %d tests", len(tests))
@@ -361,7 +365,7 @@ func TestBlockSerializeErrors(t *testing.T) {
 		// Serialize the block.
 		w := newFixedWriter(test.max)
 		err := test.in.Serialize(w)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("Serialize #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
@@ -371,7 +375,7 @@ func TestBlockSerializeErrors(t *testing.T) {
 		var block MsgBlock
 		r := newFixedReader(test.max, test.buf)
 		err = block.Deserialize(r)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("Deserialize #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -380,7 +384,7 @@ func TestBlockSerializeErrors(t *testing.T) {
 		var txLocBlock MsgBlock
 		br := bytes.NewBuffer(test.buf[0:test.max])
 		_, err = txLocBlock.DeserializeTxLoc(br)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("DeserializeTxLoc #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -390,14 +394,14 @@ func TestBlockSerializeErrors(t *testing.T) {

 // TestBlockOverflowErrors  performs tests to ensure deserializing blocks which
 // are intentionally crafted to use large values for the number of transactions
-// are handled properly.  This could otherwise potentially be used as an attack
+// are handled properly. This could otherwise potentially be used as an attack
 // vector.
 func TestBlockOverflowErrors(t *testing.T) {
 	pver := ProtocolVersion

 	tests := []struct {
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 		err  error  // Expected error
 	}{
 		// Block that claims to have ~uint64(0) transactions.
@@ -405,11 +409,11 @@ func TestBlockOverflowErrors(t *testing.T) {
 			[]byte{
 				0x01, 0x00, 0x00, 0x00, // Version 1
 				0x02,                                           // NumParentBlocks
-				0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainNetGenesisHash
+				0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainnetGenesisHash
 				0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
 				0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
 				0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
-				0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simNetGenesisHash
+				0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simnetGenesisHash
 				0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 				0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
 				0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
@@ -417,13 +421,17 @@ func TestBlockOverflowErrors(t *testing.T) {
 				0x7a, 0xc7, 0x2c, 0x3e, 0x67, 0x76, 0x8f, 0x61,
 				0x7f, 0xc8, 0x1b, 0xc3, 0x88, 0x8a, 0x51, 0x32,
 				0x3a, 0x9f, 0xb8, 0xaa, 0x4b, 0x1e, 0x5e, 0x4a,
-				0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // IDMerkleRoot
-				0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-				0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
+				0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 				0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
+				0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
+				0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
+				0x10, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // UTXOCommitment
+				0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
+				0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
+				0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
 				0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
 				0xff, 0xff, 0x00, 0x1d, // Bits
-				0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
+				0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 				0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 				0xff, // TxnCount
 			}, pver, &MessageError{},
@@ -432,17 +440,17 @@ func TestBlockOverflowErrors(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Decode from wire format.
+		// Decode from appmessage format.
 		var msg MsgBlock
 		r := bytes.NewReader(test.buf)
-		err := msg.BtcDecode(r, test.pver)
+		err := msg.KaspaDecode(r, test.pver)
 		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
+			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
 				i, err, reflect.TypeOf(test.err))
 			continue
 		}

-		// Deserialize from wire format.
+		// Deserialize from appmessage format.
 		r = bytes.NewReader(test.buf)
 		err = msg.Deserialize(r)
 		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@@ -451,7 +459,7 @@ func TestBlockOverflowErrors(t *testing.T) {
 			continue
 		}

-		// Deserialize with transaction location info from wire format.
+		// Deserialize with transaction location info from appmessage format.
 		br := bytes.NewBuffer(test.buf)
 		_, err = msg.DeserializeTxLoc(br)
 		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@@ -473,9 +481,9 @@ func TestBlockSerializeSize(t *testing.T) {
 		size int       // Expected serialized size
 	}{
 		// Block with no transactions.
-		{noTxBlock, 154},
+		{noTxBlock, 186},

-		// First block in the mainnet block chain.
+		// First block in the mainnet block DAG.
 		{&blockOne, len(blockOneBytes)},
 	}

@@ -491,22 +499,23 @@ func TestBlockSerializeSize(t *testing.T) {
 	}
 }

-// blockOne is the first block in the mainnet block chain.
+// blockOne is the first block in the mainnet block DAG.
 var blockOne = MsgBlock{
 	Header: BlockHeader{
-		Version:        1,
-		ParentHashes:   []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
-		HashMerkleRoot: mainNetGenesisMerkleRoot,
-		IDMerkleRoot:   exampleIDMerkleRoot,
-		Timestamp:      time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
-		Bits:           0x1d00ffff,               // 486604799
-		Nonce:          0x9962e301,               // 2573394689
+		Version:              1,
+		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot:       mainnetGenesisMerkleRoot,
+		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
+		UTXOCommitment:       exampleUTXOCommitment,
+		Timestamp:            mstime.UnixMilliseconds(0x17315ed0f99),
+		Bits:                 0x1d00ffff, // 486604799
+		Nonce:                0x9962e301, // 2573394689
 	},
 	Transactions: []*MsgTx{
 		NewNativeMsgTx(1,
 			[]*TxIn{
 				{
-					PreviousOutPoint: OutPoint{
+					PreviousOutpoint: Outpoint{
 						TxID:  daghash.TxID{},
 						Index: 0xffffffff,
 					},
@@ -519,7 +528,7 @@ var blockOne = MsgBlock{
 			[]*TxOut{
 				{
 					Value: 0x12a05f200,
-					PkScript: []byte{
+					ScriptPubKey: []byte{
 						0x41, // OP_DATA_65
 						0x04, 0x96, 0xb5, 0x38, 0xe8, 0x53, 0x51, 0x9c,
 						0x72, 0x6a, 0x2c, 0x91, 0xe6, 0x1e, 0xc1, 0x16,
@@ -541,11 +550,11 @@ var blockOne = MsgBlock{
 var blockOneBytes = []byte{
 	0x01, 0x00, 0x00, 0x00, // Version 1
 	0x02,                                           // NumParentBlocks
-	0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, // mainNetGenesisHash
-	0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f,
-	0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c,
-	0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
-	0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simNetGenesisHash
+	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainnetGenesisHash
+	0x49, 0xd5, 0x1d, 0x4d, 0xee, 0xd7, 0xa4, 0x8b,
+	0xaf, 0xd3, 0x14, 0x4b, 0x56, 0x78, 0x98, 0xb1,
+	0x8c, 0xfd, 0x9f, 0x69, 0xdd, 0xcf, 0xbb, 0x63,
+	0xf6, 0x7a, 0xd7, 0x69, 0x5d, 0x9b, 0x66, 0x2a, // simnetGenesisHash
 	0x72, 0xff, 0x3d, 0x8e, 0xdb, 0xbb, 0x2d, 0xe0,
 	0xbf, 0xa6, 0x7b, 0x13, 0x97, 0x4b, 0xb9, 0x91,
 	0x0d, 0x11, 0x6d, 0x5c, 0xbd, 0x86, 0x3e, 0x68,
@@ -553,13 +562,17 @@ var blockOneBytes = []byte{
 	0x32, 0x51, 0x8a, 0x88, 0xc3, 0x1b, 0xc8, 0x7f,
 	0x61, 0x8f, 0x76, 0x67, 0x3e, 0x2c, 0xc7, 0x7a,
 	0xb2, 0x12, 0x7b, 0x7a, 0xfd, 0xed, 0xa3, 0x3b,
-	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63, // Fake IDMerkleRoot. TODO: (Ori) Replace to a real IDMerkleRoot
-	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C,
+	0x09, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // AcceptedIDMerkleRoot
 	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
-	0x61, 0xbc, 0x66, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
+	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
+	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
+	0x10, 0x3B, 0xC7, 0xE3, 0x67, 0x11, 0x7B, 0x3C, // UTXOCommitment
+	0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
+	0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
+	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
+	0x99, 0x0f, 0xed, 0x15, 0x73, 0x01, 0x00, 0x00, // Timestamp
 	0xff, 0xff, 0x00, 0x1d, // Bits
-	0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce. TODO: (Ori) Replace to a real nonce
+	0x01, 0xe3, 0x62, 0x99, 0x00, 0x00, 0x00, 0x00, // Fake Nonce
 	0x01,                   // TxnCount
 	0x01, 0x00, 0x00, 0x00, // Version
 	0x01, // Varint for number of transaction inputs
@@ -573,7 +586,7 @@ var blockOneBytes = []byte{
 	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // Sequence
 	0x01,                                           // Varint for number of transaction outputs
 	0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, // Transaction amount
-	0x43, // Varint for length of pk script
+	0x43, // Varint for length of scriptPubKey
 	0x41, // OP_DATA_65
 	0x04, 0x96, 0xb5, 0x38, 0xe8, 0x53, 0x51, 0x9c,
 	0x72, 0x6a, 0x2c, 0x91, 0xe6, 0x1e, 0xc1, 0x16,
@@ -593,5 +606,5 @@ var blockOneBytes = []byte{

 // Transaction location information for block one transactions.
 var blockOneTxLocs = []TxLoc{
-	{TxStart: 154, TxLen: 162},
+	{TxStart: 186, TxLen: 162},
 }
--- a/app/appmessage/p2p_msgblocklocator.go
+++ b/app/appmessage/p2p_msgblocklocator.go
@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MaxBlockLocatorsPerMsg is the maximum number of block locator hashes allowed
+// per message.
+const MaxBlockLocatorsPerMsg = 500
+
+// MsgBlockLocator implements the Message interface and represents a kaspa
+// locator message. It is used to find the blockLocator of a peer that is
+// syncing with you.
+type MsgBlockLocator struct {
+	baseMessage
+	BlockLocatorHashes []*daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgBlockLocator) Command() MessageCommand {
+	return CmdBlockLocator
+}
+
+// NewMsgBlockLocator returns a new kaspa locator message that conforms to
+// the Message interface. See MsgBlockLocator for details.
+func NewMsgBlockLocator(locatorHashes []*daghash.Hash) *MsgBlockLocator {
+	return &MsgBlockLocator{
+		BlockLocatorHashes: locatorHashes,
+	}
+}
--- a/app/appmessage/p2p_msgblocklocator_test.go
+++ b/app/appmessage/p2p_msgblocklocator_test.go
@@ -0,0 +1,34 @@
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// TestBlockLocator tests the MsgBlockLocator API.
+func TestBlockLocator(t *testing.T) {
+	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
+	locatorHash, err := daghash.NewHashFromStr(hashStr)
+	if err != nil {
+		t.Errorf("NewHashFromStr: %v", err)
+	}
+
+	msg := NewMsgBlockLocator([]*daghash.Hash{locatorHash})
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(10)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgBlockLocator: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+
+	// Ensure block locator hashes are added properly.
+	if msg.BlockLocatorHashes[0] != locatorHash {
+		t.Errorf("AddBlockLocatorHash: wrong block locator added - "+
+			"got %v, want %v",
+			spew.Sprint(msg.BlockLocatorHashes[0]),
+			spew.Sprint(locatorHash))
+	}
+}
--- a/app/appmessage/p2p_msgdoneibdblocks.go
+++ b/app/appmessage/p2p_msgdoneibdblocks.go
@@ -0,0 +1,22 @@
+package appmessage
+
+// MsgDoneIBDBlocks implements the Message interface and represents a kaspa
+// DoneIBDBlocks message. It is used to notify the IBD syncing peer that the
+// syncer sent all the requested blocks.
+//
+// This message has no payload.
+type MsgDoneIBDBlocks struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgDoneIBDBlocks) Command() MessageCommand {
+	return CmdDoneIBDBlocks
+}
+
+// NewMsgDoneIBDBlocks returns a new kaspa DoneIBDBlocks message that conforms to the
+// Message interface.
+func NewMsgDoneIBDBlocks() *MsgDoneIBDBlocks {
+	return &MsgDoneIBDBlocks{}
+}
--- a/app/appmessage/p2p_msgibdblock.go
+++ b/app/appmessage/p2p_msgibdblock.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+// MsgIBDBlock implements the Message interface and represents a kaspa
+// ibdblock message. It is used to deliver block and transaction information in
+// response to a RequestIBDBlocks message (MsgRequestIBDBlocks).
+type MsgIBDBlock struct {
+	baseMessage
+	*MsgBlock
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgIBDBlock) Command() MessageCommand {
+	return CmdIBDBlock
+}
+
+// MaxPayloadLength returns the maximum length the payload can be for the
+// receiver. This is part of the Message interface implementation.
+func (msg *MsgIBDBlock) MaxPayloadLength(pver uint32) uint32 {
+	return MaxMessagePayload
+}
+
+// NewMsgIBDBlock returns a new kaspa ibdblock message that conforms to the
+// Message interface. See MsgIBDBlock for details.
+func NewMsgIBDBlock(msgBlock *MsgBlock) *MsgIBDBlock {
+	return &MsgIBDBlock{MsgBlock: msgBlock}
+}
--- a/app/appmessage/p2p_msgibdblock_test.go
+++ b/app/appmessage/p2p_msgibdblock_test.go
@@ -0,0 +1,118 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+
+	"github.com/davecgh/go-spew/spew"
+)
+
+// TestIBDBlock tests the MsgIBDBlock API.
+func TestIBDBlock(t *testing.T) {
+	pver := ProtocolVersion
+
+	// Block 1 header.
+	parentHashes := blockOne.Header.ParentHashes
+	hashMerkleRoot := blockOne.Header.HashMerkleRoot
+	acceptedIDMerkleRoot := blockOne.Header.AcceptedIDMerkleRoot
+	utxoCommitment := blockOne.Header.UTXOCommitment
+	bits := blockOne.Header.Bits
+	nonce := blockOne.Header.Nonce
+	bh := NewBlockHeader(1, parentHashes, hashMerkleRoot, acceptedIDMerkleRoot, utxoCommitment, bits, nonce)
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(17)
+	msg := NewMsgIBDBlock(NewMsgBlock(bh))
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgIBDBlock: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+
+	// Ensure max payload is expected value for latest protocol version.
+	wantPayload := uint32(1024 * 1024 * 32)
+	maxPayload := msg.MaxPayloadLength(pver)
+	if maxPayload != wantPayload {
+		t.Errorf("MaxPayloadLength: wrong max payload length for "+
+			"protocol version %d - got %v, want %v", pver,
+			maxPayload, wantPayload)
+	}
+
+	// Ensure we get the same block header data back out.
+	if !reflect.DeepEqual(&msg.Header, bh) {
+		t.Errorf("NewMsgIBDBlock: wrong block header - got %v, want %v",
+			spew.Sdump(&msg.Header), spew.Sdump(bh))
+	}
+
+	// Ensure transactions are added properly.
+	tx := blockOne.Transactions[0].Copy()
+	msg.AddTransaction(tx)
+	if !reflect.DeepEqual(msg.Transactions, blockOne.Transactions) {
+		t.Errorf("AddTransaction: wrong transactions - got %v, want %v",
+			spew.Sdump(msg.Transactions),
+			spew.Sdump(blockOne.Transactions))
+	}
+
+	// Ensure transactions are properly cleared.
+	msg.ClearTransactions()
+	if len(msg.Transactions) != 0 {
+		t.Errorf("ClearTransactions: wrong transactions - got %v, want %v",
+			len(msg.Transactions), 0)
+	}
+}
+
+// TestIBDBlockEncoding tests the MsgIBDBlock appmessage encode and decode for various numbers
+// of transaction inputs and outputs and protocol versions.
+func TestIBDBlockEncoding(t *testing.T) {
+	tests := []struct {
+		in     *MsgIBDBlock // Message to encode
+		out    *MsgIBDBlock // Expected decoded message
+		buf    []byte       // Encoded value
+		txLocs []TxLoc      // Expected transaction locations
+		pver   uint32       // Protocol version for appmessage encoding
+	}{
+		// Latest protocol version.
+		{
+			&MsgIBDBlock{MsgBlock: &blockOne},
+			&MsgIBDBlock{MsgBlock: &blockOne},
+			blockOneBytes,
+			blockOneTxLocs,
+			ProtocolVersion,
+		},
+	}
+
+	t.Logf("Running %d tests", len(tests))
+	for i, test := range tests {
+		// Encode the message to appmessage format.
+		var buf bytes.Buffer
+		err := test.in.KaspaEncode(&buf, test.pver)
+		if err != nil {
+			t.Errorf("KaspaEncode #%d error %v", i, err)
+			continue
+		}
+		if !bytes.Equal(buf.Bytes(), test.buf) {
+			t.Errorf("KaspaEncode #%d\n got: %s want: %s", i,
+				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
+			continue
+		}
+
+		// Decode the message from appmessage format.
+		var msg MsgIBDBlock
+		msg.MsgBlock = new(MsgBlock)
+		rbuf := bytes.NewReader(test.buf)
+		err = msg.KaspaDecode(rbuf, test.pver)
+		if err != nil {
+			t.Errorf("KaspaDecode #%d error %v", i, err)
+			continue
+		}
+		if !reflect.DeepEqual(&msg, test.out) {
+			t.Errorf("KaspaDecode #%d\n got: %s want: %s", i,
+				spew.Sdump(&msg), spew.Sdump(test.out))
+			continue
+		}
+	}
+}
--- a/app/appmessage/p2p_msginvrelayblock.go
+++ b/app/appmessage/p2p_msginvrelayblock.go
@@ -0,0 +1,27 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgInvRelayBlock implements the Message interface and represents a kaspa
+// block inventory message. It is used to notify the network about new block
+// by sending their hash, and let the receiving node decide if it needs it.
+type MsgInvRelayBlock struct {
+	baseMessage
+	Hash *daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgInvRelayBlock) Command() MessageCommand {
+	return CmdInvRelayBlock
+}
+
+// NewMsgInvBlock returns a new kaspa invrelblk message that conforms to
+// the Message interface. See MsgInvRelayBlock for details.
+func NewMsgInvBlock(hash *daghash.Hash) *MsgInvRelayBlock {
+	return &MsgInvRelayBlock{
+		Hash: hash,
+	}
+}
--- a/app/appmessage/p2p_msginvtransaction.go
+++ b/app/appmessage/p2p_msginvtransaction.go
@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MaxInvPerTxInvMsg is the maximum number of hashes that can
+// be in a single CmdInvTransaction message.
+const MaxInvPerTxInvMsg = MaxInvPerMsg
+
+// MsgInvTransaction implements the Message interface and represents a kaspa
+// TxInv message. It is used to notify the network about new transactions
+// by sending their ID, and let the receiving node decide if it needs it.
+type MsgInvTransaction struct {
+	baseMessage
+	TxIDs []*daghash.TxID
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgInvTransaction) Command() MessageCommand {
+	return CmdInvTransaction
+}
+
+// NewMsgInvTransaction returns a new kaspa TxInv message that conforms to
+// the Message interface. See MsgInvTransaction for details.
+func NewMsgInvTransaction(ids []*daghash.TxID) *MsgInvTransaction {
+	return &MsgInvTransaction{
+		TxIDs: ids,
+	}
+}
--- a/app/appmessage/p2p_msgping.go
+++ b/app/appmessage/p2p_msgping.go
@@ -0,0 +1,37 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+// MsgPing implements the Message interface and represents a kaspa ping
+// message.
+//
+// For versions BIP0031Version and earlier, it is used primarily to confirm
+// that a connection is still valid. A transmission error is typically
+// interpreted as a closed connection and that the peer should be removed.
+// For versions AFTER BIP0031Version it contains an identifier which can be
+// returned in the pong message to determine network timing.
+//
+// The payload for this message just consists of a nonce used for identifying
+// it later.
+type MsgPing struct {
+	baseMessage
+	// Unique value associated with message that is used to identify
+	// specific ping message.
+	Nonce uint64
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgPing) Command() MessageCommand {
+	return CmdPing
+}
+
+// NewMsgPing returns a new kaspa ping message that conforms to the Message
+// interface. See MsgPing for details.
+func NewMsgPing(nonce uint64) *MsgPing {
+	return &MsgPing{
+		Nonce: nonce,
+	}
+}
--- a/app/appmessage/p2p_msgping_test.go
+++ b/app/appmessage/p2p_msgping_test.go
@@ -0,0 +1,32 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/util/random"
+)
+
+// TestPing tests the MsgPing API against the latest protocol version.
+func TestPing(t *testing.T) {
+	// Ensure we get the same nonce back out.
+	nonce, err := random.Uint64()
+	if err != nil {
+		t.Errorf("random.Uint64: Error generating nonce: %v", err)
+	}
+	msg := NewMsgPing(nonce)
+	if msg.Nonce != nonce {
+		t.Errorf("NewMsgPing: wrong nonce - got %v, want %v",
+			msg.Nonce, nonce)
+	}
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(7)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgPing: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}
--- a/app/appmessage/p2p_msgpong.go
+++ b/app/appmessage/p2p_msgpong.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+// MsgPong implements the Message interface and represents a kaspa pong
+// message which is used primarily to confirm that a connection is still valid
+// in response to a kaspa ping message (MsgPing).
+//
+// This message was not added until protocol versions AFTER BIP0031Version.
+type MsgPong struct {
+	baseMessage
+	// Unique value associated with message that is used to identify
+	// specific ping message.
+	Nonce uint64
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgPong) Command() MessageCommand {
+	return CmdPong
+}
+
+// NewMsgPong returns a new kaspa pong message that conforms to the Message
+// interface. See MsgPong for details.
+func NewMsgPong(nonce uint64) *MsgPong {
+	return &MsgPong{
+		Nonce: nonce,
+	}
+}
--- a/app/appmessage/p2p_msgpong_test.go
+++ b/app/appmessage/p2p_msgpong_test.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/util/random"
+)
+
+// TestPongLatest tests the MsgPong API against the latest protocol version.
+func TestPongLatest(t *testing.T) {
+	nonce, err := random.Uint64()
+	if err != nil {
+		t.Errorf("random.Uint64: error generating nonce: %v", err)
+	}
+	msg := NewMsgPong(nonce)
+	if msg.Nonce != nonce {
+		t.Errorf("NewMsgPong: wrong nonce - got %v, want %v",
+			msg.Nonce, nonce)
+	}
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(8)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgPong: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}
--- a/app/appmessage/p2p_msgreject.go
+++ b/app/appmessage/p2p_msgreject.go
@@ -0,0 +1,22 @@
+package appmessage
+
+// MsgReject implements the Message interface and represents a kaspa
+// Reject message. It is used to notify peers why they are banned.
+type MsgReject struct {
+	baseMessage
+	Reason string
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgReject) Command() MessageCommand {
+	return CmdReject
+}
+
+// NewMsgReject returns a new kaspa Reject message that conforms to the
+// Message interface.
+func NewMsgReject(reason string) *MsgReject {
+	return &MsgReject{
+		Reason: reason,
+	}
+}
--- a/app/appmessage/p2p_msgrequestaddresses.go
+++ b/app/appmessage/p2p_msgrequestaddresses.go
@@ -0,0 +1,36 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+)
+
+// MsgRequestAddresses implements the Message interface and represents a kaspa
+// RequestAddresses message. It is used to request a list of known active peers on the
+// network from a peer to help identify potential nodes. The list is returned
+// via one or more addr messages (MsgAddresses).
+//
+// This message has no payload.
+type MsgRequestAddresses struct {
+	baseMessage
+	IncludeAllSubnetworks bool
+	SubnetworkID          *subnetworkid.SubnetworkID
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestAddresses) Command() MessageCommand {
+	return CmdRequestAddresses
+}
+
+// NewMsgRequestAddresses returns a new kaspa RequestAddresses message that conforms to the
+// Message interface. See MsgRequestAddresses for details.
+func NewMsgRequestAddresses(includeAllSubnetworks bool, subnetworkID *subnetworkid.SubnetworkID) *MsgRequestAddresses {
+	return &MsgRequestAddresses{
+		IncludeAllSubnetworks: includeAllSubnetworks,
+		SubnetworkID:          subnetworkID,
+	}
+}
--- a/app/appmessage/p2p_msgrequestaddresses_test.go
+++ b/app/appmessage/p2p_msgrequestaddresses_test.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+)
+
+// TestRequestAddresses tests the MsgRequestAddresses API.
+func TestRequestAddresses(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(2)
+	msg := NewMsgRequestAddresses(false, nil)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgRequestAddresses: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}
--- a/app/appmessage/p2p_msgrequestblocklocator.go
+++ b/app/appmessage/p2p_msgrequestblocklocator.go
@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgRequestBlockLocator implements the Message interface and represents a kaspa
+// RequestBlockLocator message. It is used to request a block locator between high
+// and low hash.
+// The locator is returned via a locator message (MsgBlockLocator).
+type MsgRequestBlockLocator struct {
+	baseMessage
+	HighHash *daghash.Hash
+	LowHash  *daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestBlockLocator) Command() MessageCommand {
+	return CmdRequestBlockLocator
+}
+
+// NewMsgRequestBlockLocator returns a new RequestBlockLocator message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgRequestBlockLocator(highHash, lowHash *daghash.Hash) *MsgRequestBlockLocator {
+	return &MsgRequestBlockLocator{
+		HighHash: highHash,
+		LowHash:  lowHash,
+	}
+}
--- a/app/appmessage/p2p_msgrequestblocklocator_test.go
+++ b/app/appmessage/p2p_msgrequestblocklocator_test.go
@@ -0,0 +1,24 @@
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// TestRequestBlockLocator tests the MsgRequestBlockLocator API.
+func TestRequestBlockLocator(t *testing.T) {
+	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
+	highHash, err := daghash.NewHashFromStr(hashStr)
+	if err != nil {
+		t.Errorf("NewHashFromStr: %v", err)
+	}
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(9)
+	msg := NewMsgRequestBlockLocator(highHash, &daghash.ZeroHash)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgRequestBlockLocator: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}
--- a/app/appmessage/p2p_msgrequestibdblocks.go
+++ b/app/appmessage/p2p_msgrequestibdblocks.go
@@ -0,0 +1,34 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgRequestIBDBlocks implements the Message interface and represents a kaspa
+// RequestIBDBlocks message. It is used to request a list of blocks starting after the
+// low hash and until the high hash.
+type MsgRequestIBDBlocks struct {
+	baseMessage
+	LowHash  *daghash.Hash
+	HighHash *daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestIBDBlocks) Command() MessageCommand {
+	return CmdRequestIBDBlocks
+}
+
+// NewMsgRequstIBDBlocks returns a new kaspa RequestIBDBlocks message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgRequstIBDBlocks(lowHash, highHash *daghash.Hash) *MsgRequestIBDBlocks {
+	return &MsgRequestIBDBlocks{
+		LowHash:  lowHash,
+		HighHash: highHash,
+	}
+}
--- a/app/appmessage/p2p_msgrequestibdblocks_test.go
+++ b/app/appmessage/p2p_msgrequestibdblocks_test.go
@@ -0,0 +1,40 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// TestRequstIBDBlocks tests the MsgRequestIBDBlocks API.
+func TestRequstIBDBlocks(t *testing.T) {
+	hashStr := "000000000002e7ad7b9eef9479e4aabc65cb831269cc20d2632c13684406dee0"
+	lowHash, err := daghash.NewHashFromStr(hashStr)
+	if err != nil {
+		t.Errorf("NewHashFromStr: %v", err)
+	}
+
+	hashStr = "3ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
+	highHash, err := daghash.NewHashFromStr(hashStr)
+	if err != nil {
+		t.Errorf("NewHashFromStr: %v", err)
+	}
+
+	// Ensure we get the same data back out.
+	msg := NewMsgRequstIBDBlocks(lowHash, highHash)
+	if !msg.HighHash.IsEqual(highHash) {
+		t.Errorf("NewMsgRequstIBDBlocks: wrong high hash - got %v, want %v",
+			msg.HighHash, highHash)
+	}
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(4)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgRequstIBDBlocks: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}
--- a/app/appmessage/p2p_msgrequestnextibdblocks.go
+++ b/app/appmessage/p2p_msgrequestnextibdblocks.go
@@ -0,0 +1,22 @@
+package appmessage
+
+// MsgRequestNextIBDBlocks implements the Message interface and represents a kaspa
+// RequestNextIBDBlocks message. It is used to notify the IBD syncer peer to send
+// more blocks.
+//
+// This message has no payload.
+type MsgRequestNextIBDBlocks struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestNextIBDBlocks) Command() MessageCommand {
+	return CmdRequestNextIBDBlocks
+}
+
+// NewMsgRequestNextIBDBlocks returns a new kaspa RequestNextIBDBlocks message that conforms to the
+// Message interface.
+func NewMsgRequestNextIBDBlocks() *MsgRequestNextIBDBlocks {
+	return &MsgRequestNextIBDBlocks{}
+}
--- a/app/appmessage/p2p_msgrequestrelayblocks.go
+++ b/app/appmessage/p2p_msgrequestrelayblocks.go
@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgRequestRelayBlocksHashes is the maximum number of hashes that can
+// be in a single RequestRelayBlocks message.
+const MsgRequestRelayBlocksHashes = MaxInvPerMsg
+
+// MsgRequestRelayBlocks implements the Message interface and represents a kaspa
+// RequestRelayBlocks message. It is used to request blocks as part of the block
+// relay protocol.
+type MsgRequestRelayBlocks struct {
+	baseMessage
+	Hashes []*daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestRelayBlocks) Command() MessageCommand {
+	return CmdRequestRelayBlocks
+}
+
+// NewMsgRequestRelayBlocks returns a new kaspa RequestRelayBlocks message that conforms to
+// the Message interface. See MsgRequestRelayBlocks for details.
+func NewMsgRequestRelayBlocks(hashes []*daghash.Hash) *MsgRequestRelayBlocks {
+	return &MsgRequestRelayBlocks{
+		Hashes: hashes,
+	}
+}
--- a/app/appmessage/p2p_msgrequestselectedtip.go
+++ b/app/appmessage/p2p_msgrequestselectedtip.go
@@ -0,0 +1,21 @@
+package appmessage
+
+// MsgRequestSelectedTip implements the Message interface and represents a kaspa
+// RequestSelectedTip message. It is used to request the selected tip of another peer.
+//
+// This message has no payload.
+type MsgRequestSelectedTip struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestSelectedTip) Command() MessageCommand {
+	return CmdRequestSelectedTip
+}
+
+// NewMsgRequestSelectedTip returns a new kaspa RequestSelectedTip message that conforms to the
+// Message interface.
+func NewMsgRequestSelectedTip() *MsgRequestSelectedTip {
+	return &MsgRequestSelectedTip{}
+}
--- a/app/appmessage/p2p_msgrequestselectedtip_test.go
+++ b/app/appmessage/p2p_msgrequestselectedtip_test.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+)
+
+// TestRequestSelectedTip tests the MsgRequestSelectedTip API.
+func TestRequestSelectedTip(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(12)
+	msg := NewMsgRequestSelectedTip()
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgRequestSelectedTip: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}
--- a/app/appmessage/p2p_msgrequesttransactions.go
+++ b/app/appmessage/p2p_msgrequesttransactions.go
@@ -0,0 +1,31 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MaxInvPerRequestTransactionsMsg is the maximum number of hashes that can
+// be in a single CmdInvTransaction message.
+const MaxInvPerRequestTransactionsMsg = MaxInvPerMsg
+
+// MsgRequestTransactions implements the Message interface and represents a kaspa
+// RequestTransactions message. It is used to request transactions as part of the
+// transactions relay protocol.
+type MsgRequestTransactions struct {
+	baseMessage
+	IDs []*daghash.TxID
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgRequestTransactions) Command() MessageCommand {
+	return CmdRequestTransactions
+}
+
+// NewMsgRequestTransactions returns a new kaspa RequestTransactions message that conforms to
+// the Message interface. See MsgRequestTransactions for details.
+func NewMsgRequestTransactions(ids []*daghash.TxID) *MsgRequestTransactions {
+	return &MsgRequestTransactions{
+		IDs: ids,
+	}
+}
--- a/app/appmessage/p2p_msgselectedtip.go
+++ b/app/appmessage/p2p_msgselectedtip.go
@@ -0,0 +1,28 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgSelectedTip implements the Message interface and represents a kaspa
+// selectedtip message. It is used to answer getseltip messages and tell
+// the asking peer what is the selected tip of this peer.
+type MsgSelectedTip struct {
+	baseMessage
+	// The selected tip hash of the generator of the message.
+	SelectedTipHash *daghash.Hash
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgSelectedTip) Command() MessageCommand {
+	return CmdSelectedTip
+}
+
+// NewMsgSelectedTip returns a new kaspa selectedtip message that conforms to the
+// Message interface.
+func NewMsgSelectedTip(selectedTipHash *daghash.Hash) *MsgSelectedTip {
+	return &MsgSelectedTip{
+		SelectedTipHash: selectedTipHash,
+	}
+}
--- a/app/appmessage/p2p_msgselectedtip_test.go
+++ b/app/appmessage/p2p_msgselectedtip_test.go
@@ -0,0 +1,18 @@
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+	"testing"
+)
+
+// TestSelectedTip tests the MsgSelectedTip API.
+func TestSelectedTip(t *testing.T) {
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(11)
+	msg := NewMsgSelectedTip(&daghash.ZeroHash)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgSelectedTip: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}
--- a/app/appmessage/p2p_msgtransactionnotfound.go
+++ b/app/appmessage/p2p_msgtransactionnotfound.go
@@ -0,0 +1,30 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// MsgTransactionNotFound defines a kaspa TransactionNotFound message which is sent in response to
+// a RequestTransactions message if any of the requested data in not available on the peer.
+type MsgTransactionNotFound struct {
+	baseMessage
+	ID *daghash.TxID
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgTransactionNotFound) Command() MessageCommand {
+	return CmdTransactionNotFound
+}
+
+// NewMsgTransactionNotFound returns a new kaspa transactionsnotfound message that conforms to the
+// Message interface. See MsgTransactionNotFound for details.
+func NewMsgTransactionNotFound(id *daghash.TxID) *MsgTransactionNotFound {
+	return &MsgTransactionNotFound{
+		ID: id,
+	}
+}
--- a/app/appmessage/p2p_msgtx.go
+++ b/app/appmessage/p2p_msgtx.go
@@ -2,19 +2,18 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
-	"bytes"
 	"encoding/binary"
 	"fmt"
 	"io"
 	"math"
 	"strconv"

-	"github.com/daglabs/btcd/dagconfig/daghash"
-	"github.com/daglabs/btcd/util/binaryserializer"
-	"github.com/daglabs/btcd/util/subnetworkid"
+	"github.com/kaspanet/kaspad/util/binaryserializer"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
 )

 const (
@@ -44,21 +43,21 @@ const (
 	SequenceLockTimeMask = 0x0000ffff

 	// SequenceLockTimeGranularity is the defined time based granularity
-	// for seconds-based relative time locks. When converting from seconds
+	// for milliseconds-based relative time locks. When converting from milliseconds
 	// to a sequence number, the value is right shifted by this amount,
-	// therefore the granularity of relative time locks in 512 or 2^9
-	// seconds. Enforced relative lock times are multiples of 512 seconds.
-	SequenceLockTimeGranularity = 9
+	// therefore the granularity of relative time locks in 524288 or 2^19
+	// seconds. Enforced relative lock times are multiples of 524288 milliseconds.
+	SequenceLockTimeGranularity = 19

 	// defaultTxInOutAlloc is the default size used for the backing array for
-	// transaction inputs and outputs.  The array will dynamically grow as needed,
+	// transaction inputs and outputs. The array will dynamically grow as needed,
 	// but this figure is intended to provide enough space for the number of
 	// inputs and outputs in a typical transaction without needing to grow the
 	// backing array multiple times.
 	defaultTxInOutAlloc = 15

 	// minTxInPayload is the minimum payload size for a transaction input.
-	// PreviousOutPoint.TxID + PreviousOutPoint.Index 4 bytes + Varint for
+	// PreviousOutpoint.TxID + PreviousOutpoint.Index 4 bytes + Varint for
 	// SignatureScript length 1 byte + Sequence 4 bytes.
 	minTxInPayload = 9 + daghash.HashSize

@@ -67,14 +66,14 @@ const (
 	maxTxInPerMessage = (MaxMessagePayload / minTxInPayload) + 1

 	// MinTxOutPayload is the minimum payload size for a transaction output.
-	// Value 8 bytes + Varint for PkScript length 1 byte.
+	// Value 8 bytes + Varint for ScriptPubKey length 1 byte.
 	MinTxOutPayload = 9

 	// maxTxOutPerMessage is the maximum number of transactions outputs that
 	// a transaction which fits into a message could possibly have.
 	maxTxOutPerMessage = (MaxMessagePayload / MinTxOutPayload) + 1

-	// minTxPayload is the minimum payload size for a transaction.  Note
+	// minTxPayload is the minimum payload size for a transaction. Note
 	// that any realistically usable transaction must have at least one
 	// input or output, but that is a rule enforced at a higher layer, so
 	// it is intentionally not included here.
@@ -84,17 +83,17 @@ const (
 	minTxPayload = 10

 	// freeListMaxScriptSize is the size of each buffer in the free list
-	// that	is used for deserializing scripts from the wire before they are
-	// concatenated into a single contiguous buffers.  This value was chosen
+	// that	is used for deserializing scripts from the appmessage before they are
+	// concatenated into a single contiguous buffers. This value was chosen
 	// because it is slightly more than twice the size of the vast majority
-	// of all "standard" scripts.  Larger scripts are still deserialized
+	// of all "standard" scripts. Larger scripts are still deserialized
 	// properly as the free list will simply be bypassed for them.
 	freeListMaxScriptSize = 512

 	// freeListMaxItems is the number of buffers to keep in the free list
-	// to use for script deserialization.  This value allows up to 100
+	// to use for script deserialization. This value allows up to 100
 	// scripts per transaction being simultaneously deserialized by 125
-	// peers.  Thus, the peak usage of the free list is 12,500 * 512 =
+	// peers. Thus, the peak usage of the free list is 12,500 * 512 =
 	// 6,400,000 bytes.
 	freeListMaxItems = 12500
 )
@@ -113,7 +112,7 @@ const (

 // scriptFreeList defines a free list of byte slices (up to the maximum number
 // defined by the freeListMaxItems constant) that have a cap according to the
-// freeListMaxScriptSize constant.  It is used to provide temporary buffers for
+// freeListMaxScriptSize constant. It is used to provide temporary buffers for
 // deserializing scripts in order to greatly reduce the number of allocations
 // required.
 //
@@ -122,10 +121,10 @@ const (
 type scriptFreeList chan []byte

 // Borrow returns a byte slice from the free list with a length according the
-// provided size.  A new buffer is allocated if there are any items available.
+// provided size. A new buffer is allocated if there are any items available.
 //
 // When the size is larger than the max size allowed for items on the free list
-// a new buffer of the appropriate size is allocated and returned.  It is safe
+// a new buffer of the appropriate size is allocated and returned. It is safe
 // to attempt to return said buffer via the Return function as it will be
 // ignored and allowed to go the garbage collector.
 func (c scriptFreeList) Borrow(size uint64) []byte {
@@ -143,8 +142,8 @@ func (c scriptFreeList) Borrow(size uint64) []byte {
 }

 // Return puts the provided byte slice back on the free list when it has a cap
-// of the expected length.  The buffer is expected to have been obtained via
-// the Borrow function.  Any slices that are not of the appropriate size, such
+// of the expected length. The buffer is expected to have been obtained via
+// the Borrow function. Any slices that are not of the appropriate size, such
 // as those whose size is greater than the largest allowed free list item size
 // are simply ignored so they can go to the garbage collector.
 func (c scriptFreeList) Return(buf []byte) {
@@ -154,7 +153,7 @@ func (c scriptFreeList) Return(buf []byte) {
 		return
 	}

-	// Return the buffer to the free list when it's not full.  Otherwise let
+	// Return the buffer to the free list when it's not full. Otherwise let
 	// it be garbage collected.
 	select {
 	case c <- buf:
@@ -163,30 +162,30 @@ func (c scriptFreeList) Return(buf []byte) {
 	}
 }

-// Create the concurrent safe free list to use for script deserialization.  As
+// Create the concurrent safe free list to use for script deserialization. As
 // previously described, this free list is maintained to significantly reduce
 // the number of allocations.
 var scriptPool scriptFreeList = make(chan []byte, freeListMaxItems)

-// OutPoint defines a bitcoin data type that is used to track previous
+// Outpoint defines a kaspa data type that is used to track previous
 // transaction outputs.
-type OutPoint struct {
+type Outpoint struct {
 	TxID  daghash.TxID
 	Index uint32
 }

-// NewOutPoint returns a new bitcoin transaction outpoint point with the
+// NewOutpoint returns a new kaspa transaction outpoint point with the
 // provided hash and index.
-func NewOutPoint(txID *daghash.TxID, index uint32) *OutPoint {
-	return &OutPoint{
+func NewOutpoint(txID *daghash.TxID, index uint32) *Outpoint {
+	return &Outpoint{
 		TxID:  *txID,
 		Index: index,
 	}
 }

-// String returns the OutPoint in the human-readable form "txID:index".
-func (o OutPoint) String() string {
-	// Allocate enough for ID string, colon, and 10 digits.  Although
+// String returns the Outpoint in the human-readable form "txID:index".
+func (o Outpoint) String() string {
+	// Allocate enough for ID string, colon, and 10 digits. Although
 	// at the time of writing, the number of digits can be no greater than
 	// the length of the decimal representation of maxTxOutPerMessage, the
 	// maximum message payload may increase in the future and this
@@ -199,9 +198,9 @@ func (o OutPoint) String() string {
 	return string(buf)
 }

-// TxIn defines a bitcoin transaction input.
+// TxIn defines a kaspa transaction input.
 type TxIn struct {
-	PreviousOutPoint OutPoint
+	PreviousOutpoint Outpoint
 	SignatureScript  []byte
 	Sequence         uint64
 }
@@ -227,47 +226,48 @@ func serializeSignatureScriptSize(signatureScript []byte, encodingFlags txEncodi
 	return VarIntSerializeSize(0)
 }

-// NewTxIn returns a new bitcoin transaction input with the provided
+// NewTxIn returns a new kaspa transaction input with the provided
 // previous outpoint point and signature script with a default sequence of
 // MaxTxInSequenceNum.
-func NewTxIn(prevOut *OutPoint, signatureScript []byte) *TxIn {
+func NewTxIn(prevOut *Outpoint, signatureScript []byte) *TxIn {
 	return &TxIn{
-		PreviousOutPoint: *prevOut,
+		PreviousOutpoint: *prevOut,
 		SignatureScript:  signatureScript,
 		Sequence:         MaxTxInSequenceNum,
 	}
 }

-// TxOut defines a bitcoin transaction output.
+// TxOut defines a kaspa transaction output.
 type TxOut struct {
-	Value    uint64
-	PkScript []byte
+	Value        uint64
+	ScriptPubKey []byte
 }

 // SerializeSize returns the number of bytes it would take to serialize the
 // the transaction output.
 func (t *TxOut) SerializeSize() int {
-	// Value 8 bytes + serialized varint size for the length of PkScript +
-	// PkScript bytes.
-	return 8 + VarIntSerializeSize(uint64(len(t.PkScript))) + len(t.PkScript)
+	// Value 8 bytes + serialized varint size for the length of ScriptPubKey +
+	// ScriptPubKey bytes.
+	return 8 + VarIntSerializeSize(uint64(len(t.ScriptPubKey))) + len(t.ScriptPubKey)
 }

-// NewTxOut returns a new bitcoin transaction output with the provided
+// NewTxOut returns a new kaspa transaction output with the provided
 // transaction value and public key script.
-func NewTxOut(value uint64, pkScript []byte) *TxOut {
+func NewTxOut(value uint64, scriptPubKey []byte) *TxOut {
 	return &TxOut{
-		Value:    value,
-		PkScript: pkScript,
+		Value:        value,
+		ScriptPubKey: scriptPubKey,
 	}
 }

-// MsgTx implements the Message interface and represents a bitcoin tx message.
+// MsgTx implements the Message interface and represents a kaspa tx message.
 // It is used to deliver transaction information in response to a getdata
 // message (MsgGetData) for a given transaction.
 //
 // Use the AddTxIn and AddTxOut functions to build up the list of transaction
 // inputs and outputs.
 type MsgTx struct {
+	baseMessage
 	Version      int32
 	TxIn         []*TxIn
 	TxOut        []*TxOut
@@ -288,70 +288,48 @@ func (msg *MsgTx) AddTxOut(to *TxOut) {
 	msg.TxOut = append(msg.TxOut, to)
 }

-// IsCoinBase determines whether or not a transaction is a coinbase.  A coinbase
-// is a special transaction created by miners that has no inputs.  This is
-// represented in the block dag by a transaction with a single input that has
-// a previous output transaction index set to the maximum value along with a
-// zero TxID.
-func (msg *MsgTx) IsCoinBase() bool {
-	// A coin base must only have one transaction input.
-	if len(msg.TxIn) != 1 {
-		return false
-	}
-
-	// The previous output of a coinbase must have a max value index and
-	// a zero TxID.
-	prevOut := &msg.TxIn[0].PreviousOutPoint
-	return prevOut.Index == math.MaxUint32 && prevOut.TxID == daghash.ZeroTxID
-}
-
-// IsFeeTransaction determines whether or not a transaction is a fee transaction.  A fee
-// transaction is a special transaction created by miners that distributes fees to the
-// previous blocks' miners.  Each input of the fee transaction should set index to maximum
+// IsCoinBase determines whether or not a transaction is a coinbase transaction. A coinbase
+// transaction is a special transaction created by miners that distributes fees and block subsidy
+// to the previous blocks' miners, and to specify the scriptPubKey that will be used to pay the current
+// miner in future blocks. Each input of the coinbase transaction should set index to maximum
 // value and reference the relevant block id, instead of previous transaction id.
-func (msg *MsgTx) IsFeeTransaction() bool {
-	for _, txIn := range msg.TxIn {
-		// The previous output of a fee transaction have a max value index and
-		// a non-zero TxID (to differentiate from coinbase).
-		prevOut := txIn.PreviousOutPoint
-		if prevOut.Index != math.MaxUint32 || prevOut.TxID == daghash.ZeroTxID {
-			return false
-		}
-	}
-	return true
-}
-
-// IsBlockReward determines whether or not a transaction is a block reward (a fee transaction or a coinbase)
-func (msg *MsgTx) IsBlockReward() bool {
-	return msg.IsFeeTransaction() || msg.IsCoinBase()
+func (msg *MsgTx) IsCoinBase() bool {
+	// A coinbase transaction must have subnetwork id SubnetworkIDCoinbase
+	return msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDCoinbase)
 }

 // TxHash generates the Hash for the transaction.
 func (msg *MsgTx) TxHash() *daghash.Hash {
 	// Encode the transaction and calculate double sha256 on the result.
-	// Ignore the error returns since the only way the encode could fail
-	// is being out of memory or due to nil pointers, both of which would
-	// cause a run-time panic.
-	buf := bytes.NewBuffer(make([]byte, 0, msg.serializeSize(txEncodingExcludePayload)))
-	_ = msg.serialize(buf, txEncodingExcludePayload)
+	writer := daghash.NewDoubleHashWriter()
+	err := msg.serialize(writer, txEncodingExcludePayload)
+	if err != nil {
+		// this writer never return errors (no allocations or possible failures) so errors can only come from validity checks,
+		// and we assume we never construct malformed transactions.
+		panic(fmt.Sprintf("TxHash() failed. this should never fail for structurally-valid transactions. err: %+v", err))
+	}

-	hash := daghash.Hash(daghash.DoubleHashH(buf.Bytes()))
+	hash := writer.Finalize()
 	return &hash
 }

 // TxID generates the Hash for the transaction without the signature script, gas and payload fields.
-func (msg *MsgTx) TxID() daghash.TxID {
+func (msg *MsgTx) TxID() *daghash.TxID {
 	// Encode the transaction, replace signature script with zeroes, cut off
-	// payload and calculate double sha256 on the result.  Ignore the error
-	// returns since the only way the encode could fail is being out of memory or
-	// due to nil pointers, both of which would cause a run-time panic.
+	// payload and calculate double sha256 on the result.
 	var encodingFlags txEncoding
 	if !msg.IsCoinBase() {
 		encodingFlags = txEncodingExcludeSignatureScript | txEncodingExcludePayload
 	}
-	buf := bytes.NewBuffer(make([]byte, 0, msg.serializeSize(encodingFlags)))
-	_ = msg.serialize(buf, encodingFlags)
-	return daghash.TxID(daghash.DoubleHashH(buf.Bytes()))
+	writer := daghash.NewDoubleHashWriter()
+	err := msg.serialize(writer, encodingFlags)
+	if err != nil {
+		// this writer never return errors (no allocations or possible failures) so errors can only come from validity checks,
+		// and we assume we never construct malformed transactions.
+		panic(fmt.Sprintf("TxID() failed. this should never fail for structurally-valid transactions. err: %+v", err))
+	}
+	txID := daghash.TxID(writer.Finalize())
+	return &txID
 }

 // Copy creates a deep copy of a transaction so that the original does not get
@@ -377,10 +355,10 @@ func (msg *MsgTx) Copy() *MsgTx {
 	// Deep copy the old TxIn data.
 	for _, oldTxIn := range msg.TxIn {
 		// Deep copy the old previous outpoint.
-		oldOutPoint := oldTxIn.PreviousOutPoint
-		newOutPoint := OutPoint{}
-		newOutPoint.TxID.SetBytes(oldOutPoint.TxID[:])
-		newOutPoint.Index = oldOutPoint.Index
+		oldOutpoint := oldTxIn.PreviousOutpoint
+		newOutpoint := Outpoint{}
+		newOutpoint.TxID.SetBytes(oldOutpoint.TxID[:])
+		newOutpoint.Index = oldOutpoint.Index

 		// Deep copy the old signature script.
 		var newScript []byte
@@ -393,7 +371,7 @@ func (msg *MsgTx) Copy() *MsgTx {

 		// Create new txIn with the deep copied data.
 		newTxIn := TxIn{
-			PreviousOutPoint: newOutPoint,
+			PreviousOutpoint: newOutpoint,
 			SignatureScript:  newScript,
 			Sequence:         oldTxIn.Sequence,
 		}
@@ -404,9 +382,9 @@ func (msg *MsgTx) Copy() *MsgTx {

 	// Deep copy the old TxOut data.
 	for _, oldTxOut := range msg.TxOut {
-		// Deep copy the old PkScript
+		// Deep copy the old ScriptPubKey
 		var newScript []byte
-		oldScript := oldTxOut.PkScript
+		oldScript := oldTxOut.ScriptPubKey
 		oldScriptLen := len(oldScript)
 		if oldScriptLen > 0 {
 			newScript = make([]byte, oldScriptLen)
@@ -416,8 +394,8 @@ func (msg *MsgTx) Copy() *MsgTx {
 		// Create new txOut with the deep copied data and append it to
 		// new Tx.
 		newTxOut := TxOut{
-			Value:    oldTxOut.Value,
-			PkScript: newScript,
+			Value:        oldTxOut.Value,
+			ScriptPubKey: newScript,
 		}
 		newTx.TxOut = append(newTx.TxOut, &newTxOut)
 	}
@@ -425,11 +403,11 @@ func (msg *MsgTx) Copy() *MsgTx {
 	return &newTx
 }

-// BtcDecode decodes r using the bitcoin protocol encoding into the receiver.
+// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
 // This is part of the Message interface implementation.
 // See Deserialize for decoding transactions stored to disk, such as in a
-// database, as opposed to decoding transactions from the wire.
-func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {
+// database, as opposed to decoding transactions from the appmessage.
+func (msg *MsgTx) KaspaDecode(r io.Reader, pver uint32) error {
 	version, err := binaryserializer.Uint32(r, littleEndian)
 	if err != nil {
 		return err
@@ -442,18 +420,18 @@ func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {
 	}

 	// Prevent more input transactions than could possibly fit into a
-	// message.  It would be possible to cause memory exhaustion and panics
+	// message. It would be possible to cause memory exhaustion and panics
 	// without a sane upper bound on this count.
 	if count > uint64(maxTxInPerMessage) {
 		str := fmt.Sprintf("too many input transactions to fit into "+
 			"max message size [count %d, max %d]", count,
 			maxTxInPerMessage)
-		return messageError("MsgTx.BtcDecode", str)
+		return messageError("MsgTx.KaspaDecode", str)
 	}

 	// returnScriptBuffers is a closure that returns any script buffers that
 	// were borrowed from the pool when there are any deserialization
-	// errors.  This is only valid to call before the final step which
+	// errors. This is only valid to call before the final step which
 	// replaces the scripts with the location in a contiguous buffer and
 	// returns them.
 	returnScriptBuffers := func() {
@@ -464,10 +442,10 @@ func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {
 			scriptPool.Return(txIn.SignatureScript)
 		}
 		for _, txOut := range msg.TxOut {
-			if txOut == nil || txOut.PkScript == nil {
+			if txOut == nil || txOut.ScriptPubKey == nil {
 				continue
 			}
-			scriptPool.Return(txOut.PkScript)
+			scriptPool.Return(txOut.ScriptPubKey)
 		}
 	}

@@ -495,14 +473,14 @@ func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {
 	}

 	// Prevent more output transactions than could possibly fit into a
-	// message.  It would be possible to cause memory exhaustion and panics
+	// message. It would be possible to cause memory exhaustion and panics
 	// without a sane upper bound on this count.
 	if count > uint64(maxTxOutPerMessage) {
 		returnScriptBuffers()
 		str := fmt.Sprintf("too many output transactions to fit into "+
 			"max message size [count %d, max %d]", count,
 			maxTxOutPerMessage)
-		return messageError("MsgTx.BtcDecode", str)
+		return messageError("MsgTx.KaspaDecode", str)
 	}

 	// Deserialize the outputs.
@@ -518,7 +496,7 @@ func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {
 			returnScriptBuffers()
 			return err
 		}
-		totalScriptSize += uint64(len(to.PkScript))
+		totalScriptSize += uint64(len(to.ScriptPubKey))
 	}

 	lockTime, err := binaryserializer.Uint64(r, littleEndian)
@@ -557,13 +535,17 @@ func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {

 		msg.Payload = make([]byte, payloadLength)
 		_, err = io.ReadFull(r, msg.Payload)
+		if err != nil {
+			returnScriptBuffers()
+			return err
+		}
 	}

 	// Create a single allocation to house all of the scripts and set each
 	// input signature script and output public key script to the
-	// appropriate subslice of the overall contiguous buffer.  Then, return
+	// appropriate subslice of the overall contiguous buffer. Then, return
 	// each individual script buffer back to the pool so they can be reused
-	// for future deserializations.  This is done because it significantly
+	// for future deserializations. This is done because it significantly
 	// reduces the number of allocations the garbage collector needs to
 	// track, which in turn improves performance and drastically reduces the
 	// amount of runtime overhead that would otherwise be needed to keep
@@ -594,18 +576,18 @@ func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {
 	for i := 0; i < len(msg.TxOut); i++ {
 		// Copy the public key script into the contiguous buffer at the
 		// appropriate offset.
-		pkScript := msg.TxOut[i].PkScript
-		copy(scripts[offset:], pkScript)
+		scriptPubKey := msg.TxOut[i].ScriptPubKey
+		copy(scripts[offset:], scriptPubKey)

 		// Reset the public key script of the transaction output to the
 		// slice of the contiguous buffer where the script lives.
-		scriptSize := uint64(len(pkScript))
+		scriptSize := uint64(len(scriptPubKey))
 		end := offset + scriptSize
-		msg.TxOut[i].PkScript = scripts[offset:end:end]
+		msg.TxOut[i].ScriptPubKey = scripts[offset:end:end]
 		offset += scriptSize

 		// Return the temporary script buffer to the pool.
-		scriptPool.Return(pkScript)
+		scriptPool.Return(scriptPubKey)
 	}

 	return nil
@@ -613,26 +595,26 @@ func (msg *MsgTx) BtcDecode(r io.Reader, pver uint32) error {

 // Deserialize decodes a transaction from r into the receiver using a format
 // that is suitable for long-term storage such as a database while respecting
-// the Version field in the transaction.  This function differs from BtcDecode
-// in that BtcDecode decodes from the bitcoin wire protocol as it was sent
-// across the network.  The wire encoding can technically differ depending on
+// the Version field in the transaction. This function differs from KaspaDecode
+// in that KaspaDecode decodes from the kaspa appmessage protocol as it was sent
+// across the network. The appmessage encoding can technically differ depending on
 // the protocol version and doesn't even really need to match the format of a
-// stored transaction at all.  As of the time this comment was written, the
+// stored transaction at all. As of the time this comment was written, the
 // encoded transaction is the same in both instances, but there is a distinct
 // difference and separating the two allows the API to be flexible enough to
 // deal with changes.
 func (msg *MsgTx) Deserialize(r io.Reader) error {
-	// At the current time, there is no difference between the wire encoding
-	// at protocol version 0 and the stable long-term storage format.  As
-	// a result, make use of BtcDecode.
-	return msg.BtcDecode(r, 0)
+	// At the current time, there is no difference between the appmessage encoding
+	// at protocol version 0 and the stable long-term storage format. As
+	// a result, make use of KaspaDecode.
+	return msg.KaspaDecode(r, 0)
 }

-// BtcEncode encodes the receiver to w using the bitcoin protocol encoding.
+// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
 // This is part of the Message interface implementation.
 // See Serialize for encoding transactions to be stored to disk, such as in a
-// database, as opposed to encoding transactions for the wire.
-func (msg *MsgTx) BtcEncode(w io.Writer, pver uint32) error {
+// database, as opposed to encoding transactions for the appmessage.
+func (msg *MsgTx) KaspaEncode(w io.Writer, pver uint32) error {
 	return msg.encode(w, pver, txEncodingFull)
 }

@@ -679,9 +661,9 @@ func (msg *MsgTx) encode(w io.Writer, pver uint32, encodingFlags txEncoding) err
 	}

 	if !msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDNative) {
-		if msg.SubnetworkID.IsEqual(subnetworkid.SubnetworkIDRegistry) && msg.Gas != 0 {
-			str := "Transactions from registry subnetwork should have 0 gas"
-			return messageError("MsgTx.BtcEncode", str)
+		if msg.SubnetworkID.IsBuiltIn() && msg.Gas != 0 {
+			str := "Transactions from built-in should have 0 gas"
+			return messageError("MsgTx.KaspaEncode", str)
 		}

 		err = binaryserializer.PutUint64(w, littleEndian, msg.Gas)
@@ -705,13 +687,13 @@ func (msg *MsgTx) encode(w io.Writer, pver uint32, encodingFlags txEncoding) err
 		}
 	} else if msg.Payload != nil {
 		str := "Transactions from native subnetwork should have <nil> payload"
-		return messageError("MsgTx.BtcEncode", str)
+		return messageError("MsgTx.KaspaEncode", str)
 	} else if msg.PayloadHash != nil {
 		str := "Transactions from native subnetwork should have <nil> payload hash"
-		return messageError("MsgTx.BtcEncode", str)
+		return messageError("MsgTx.KaspaEncode", str)
 	} else if msg.Gas != 0 {
 		str := "Transactions from native subnetwork should have 0 gas"
-		return messageError("MsgTx.BtcEncode", str)
+		return messageError("MsgTx.KaspaEncode", str)
 	}

 	return nil
@@ -719,24 +701,24 @@ func (msg *MsgTx) encode(w io.Writer, pver uint32, encodingFlags txEncoding) err

 // Serialize encodes the transaction to w using a format that suitable for
 // long-term storage such as a database while respecting the Version field in
-// the transaction.  This function differs from BtcEncode in that BtcEncode
-// encodes the transaction to the bitcoin wire protocol in order to be sent
-// across the network.  The wire encoding can technically differ depending on
+// the transaction. This function differs from KaspaEncode in that KaspaEncode
+// encodes the transaction to the kaspa appmessage protocol in order to be sent
+// across the network. The appmessage encoding can technically differ depending on
 // the protocol version and doesn't even really need to match the format of a
-// stored transaction at all.  As of the time this comment was written, the
+// stored transaction at all. As of the time this comment was written, the
 // encoded transaction is the same in both instances, but there is a distinct
 // difference and separating the two allows the API to be flexible enough to
 // deal with changes.
 func (msg *MsgTx) Serialize(w io.Writer) error {
-	// At the current time, there is no difference between the wire encoding
-	// at protocol version 0 and the stable long-term storage format.  As
-	// a result, make use of BtcEncode.
-	return msg.BtcEncode(w, 0)
+	// At the current time, there is no difference between the appmessage encoding
+	// at protocol version 0 and the stable long-term storage format. As
+	// a result, make use of KaspaEncode.
+	return msg.KaspaEncode(w, 0)
 }

 func (msg *MsgTx) serialize(w io.Writer, encodingFlags txEncoding) error {
-	// At the current time, there is no difference between the wire encoding
-	// at protocol version 0 and the stable long-term storage format.  As
+	// At the current time, there is no difference between the appmessage encoding
+	// at protocol version 0 and the stable long-term storage format. As
 	// a result, make use of `encode`.
 	return msg.encode(w, 0, encodingFlags)
 }
@@ -783,23 +765,23 @@ func (msg *MsgTx) serializeSize(encodingFlags txEncoding) int {
 	return n
 }

-// Command returns the protocol command string for the message.  This is part
+// Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.
-func (msg *MsgTx) Command() string {
+func (msg *MsgTx) Command() MessageCommand {
 	return CmdTx
 }

 // MaxPayloadLength returns the maximum length the payload can be for the
-// receiver.  This is part of the Message interface implementation.
+// receiver. This is part of the Message interface implementation.
 func (msg *MsgTx) MaxPayloadLength(pver uint32) uint32 {
-	return MaxBlockPayload
+	return MaxMessagePayload
 }

-// PkScriptLocs returns a slice containing the start of each public key script
-// within the raw serialized transaction.  The caller can easily obtain the
+// ScriptPubKeyLocs returns a slice containing the start of each public key script
+// within the raw serialized transaction. The caller can easily obtain the
 // length of each script by using len on the script available via the
 // appropriate transaction output entry.
-func (msg *MsgTx) PkScriptLocs() []int {
+func (msg *MsgTx) ScriptPubKeyLocs() []int {
 	numTxOut := len(msg.TxOut)
 	if numTxOut == 0 {
 		return nil
@@ -819,18 +801,18 @@ func (msg *MsgTx) PkScriptLocs() []int {
 	}

 	// Calculate and set the appropriate offset for each public key script.
-	pkScriptLocs := make([]int, numTxOut)
+	scriptPubKeyLocs := make([]int, numTxOut)
 	for i, txOut := range msg.TxOut {
 		// The offset of the script in the transaction output is:
 		//
 		// Value 8 bytes + serialized varint size for the length of
-		// PkScript.
-		n += 8 + VarIntSerializeSize(uint64(len(txOut.PkScript)))
-		pkScriptLocs[i] = n
-		n += len(txOut.PkScript)
+		// ScriptPubKey.
+		n += 8 + VarIntSerializeSize(uint64(len(txOut.ScriptPubKey)))
+		scriptPubKeyLocs[i] = n
+		n += len(txOut.ScriptPubKey)
 	}

-	return pkScriptLocs
+	return scriptPubKeyLocs
 }

 // IsSubnetworkCompatible return true iff subnetworkID is one or more of the following:
@@ -907,8 +889,8 @@ func NewRegistryMsgTx(version int32, txIn []*TxIn, txOut []*TxOut, gasLimit uint
 	return NewSubnetworkMsgTx(version, txIn, txOut, subnetworkid.SubnetworkIDRegistry, 0, payload)
 }

-// readOutPoint reads the next sequence of bytes from r as an OutPoint.
-func readOutPoint(r io.Reader, pver uint32, version int32, op *OutPoint) error {
+// readOutpoint reads the next sequence of bytes from r as an Outpoint.
+func readOutpoint(r io.Reader, pver uint32, version int32, op *Outpoint) error {
 	_, err := io.ReadFull(r, op.TxID[:])
 	if err != nil {
 		return err
@@ -918,9 +900,9 @@ func readOutPoint(r io.Reader, pver uint32, version int32, op *OutPoint) error {
 	return err
 }

-// writeOutPoint encodes op to the bitcoin protocol encoding for an OutPoint
+// writeOutpoint encodes op to the kaspa protocol encoding for an Outpoint
 // to w.
-func writeOutPoint(w io.Writer, pver uint32, version int32, op *OutPoint) error {
+func writeOutpoint(w io.Writer, pver uint32, version int32, op *Outpoint) error {
 	_, err := w.Write(op.TxID[:])
 	if err != nil {
 		return err
@@ -930,10 +912,10 @@ func writeOutPoint(w io.Writer, pver uint32, version int32, op *OutPoint) error
 }

 // readScript reads a variable length byte array that represents a transaction
-// script.  It is encoded as a varInt containing the length of the array
-// followed by the bytes themselves.  An error is returned if the length is
+// script. It is encoded as a varInt containing the length of the array
+// followed by the bytes themselves. An error is returned if the length is
 // greater than the passed maxAllowed parameter which helps protect against
-// memory exhaustion attacks and forced panics through malformed messages.  The
+// memory exhaustion attacks and forced panics through malformed messages. The
 // fieldName parameter is only used for the error message so it provides more
 // context in the error.
 func readScript(r io.Reader, pver uint32, maxAllowed uint32, fieldName string) ([]byte, error) {
@@ -942,7 +924,7 @@ func readScript(r io.Reader, pver uint32, maxAllowed uint32, fieldName string) (
 		return nil, err
 	}

-	// Prevent byte array larger than the max message size.  It would
+	// Prevent byte array larger than the max message size. It would
 	// be possible to cause memory exhaustion and panics without a sane
 	// upper bound on this count.
 	if count > uint64(maxAllowed) {
@@ -963,7 +945,7 @@ func readScript(r io.Reader, pver uint32, maxAllowed uint32, fieldName string) (
 // readTxIn reads the next sequence of bytes from r as a transaction input
 // (TxIn).
 func readTxIn(r io.Reader, pver uint32, version int32, ti *TxIn) error {
-	err := readOutPoint(r, pver, version, &ti.PreviousOutPoint)
+	err := readOutpoint(r, pver, version, &ti.PreviousOutpoint)
 	if err != nil {
 		return err
 	}
@@ -977,10 +959,10 @@ func readTxIn(r io.Reader, pver uint32, version int32, ti *TxIn) error {
 	return ReadElement(r, &ti.Sequence)
 }

-// writeTxIn encodes ti to the bitcoin protocol encoding for a transaction
+// writeTxIn encodes ti to the kaspa protocol encoding for a transaction
 // input (TxIn) to w.
 func writeTxIn(w io.Writer, pver uint32, version int32, ti *TxIn, encodingFlags txEncoding) error {
-	err := writeOutPoint(w, pver, version, &ti.PreviousOutPoint)
+	err := writeOutpoint(w, pver, version, &ti.PreviousOutpoint)
 	if err != nil {
 		return err
 	}
@@ -1005,12 +987,12 @@ func readTxOut(r io.Reader, pver uint32, version int32, to *TxOut) error {
 		return err
 	}

-	to.PkScript, err = readScript(r, pver, MaxMessagePayload,
+	to.ScriptPubKey, err = readScript(r, pver, MaxMessagePayload,
 		"transaction output public key script")
 	return err
 }

-// WriteTxOut encodes to into the bitcoin protocol encoding for a transaction
+// WriteTxOut encodes to into the kaspa protocol encoding for a transaction
 // output (TxOut) to w.
 func WriteTxOut(w io.Writer, pver uint32, version int32, to *TxOut) error {
 	err := binaryserializer.PutUint64(w, littleEndian, uint64(to.Value))
@@ -1018,5 +1000,5 @@ func WriteTxOut(w io.Writer, pver uint32, version int32, to *TxOut) error {
 		return err
 	}

-	return WriteVarBytes(w, pver, to.PkScript)
+	return WriteVarBytes(w, pver, to.ScriptPubKey)
 }
--- a/app/appmessage/p2p_msgtx_test.go
+++ b/app/appmessage/p2p_msgtx_test.go
@@ -2,20 +2,21 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
 	"bytes"
 	"fmt"
+	"github.com/pkg/errors"
 	"io"
 	"math"
 	"reflect"
 	"testing"
 	"unsafe"

-	"github.com/daglabs/btcd/dagconfig/daghash"
-	"github.com/daglabs/btcd/util/subnetworkid"
 	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
 )

 // TestTx tests the MsgTx API.
@@ -29,15 +30,15 @@ func TestTx(t *testing.T) {
 	}

 	// Ensure the command is expected value.
-	wantCmd := "tx"
+	wantCmd := MessageCommand(6)
 	msg := NewNativeMsgTx(1, nil, nil)
 	if cmd := msg.Command(); cmd != wantCmd {
-		t.Errorf("NewMsgAddr: wrong command - got %v want %v",
+		t.Errorf("NewMsgAddresses: wrong command - got %v want %v",
 			cmd, wantCmd)
 	}

 	// Ensure max payload is expected value for latest protocol version.
-	wantPayload := uint32(1000 * 1000)
+	wantPayload := uint32(1024 * 1024 * 32)
 	maxPayload := msg.MaxPayloadLength(pver)
 	if maxPayload != wantPayload {
 		t.Errorf("MaxPayloadLength: wrong max payload length for "+
@@ -45,31 +46,31 @@ func TestTx(t *testing.T) {
 			maxPayload, wantPayload)
 	}

-	// Ensure we get the same transaction output point data back out.
+	// Ensure we get the same transaction outpoint data back out.
 	// NOTE: This is a block hash and made up index, but we're only
 	// testing package functionality.
 	prevOutIndex := uint32(1)
-	prevOut := NewOutPoint(txID, prevOutIndex)
+	prevOut := NewOutpoint(txID, prevOutIndex)
 	if !prevOut.TxID.IsEqual(txID) {
-		t.Errorf("NewOutPoint: wrong ID - got %v, want %v",
+		t.Errorf("NewOutpoint: wrong ID - got %v, want %v",
 			spew.Sprint(&prevOut.TxID), spew.Sprint(txID))
 	}
 	if prevOut.Index != prevOutIndex {
-		t.Errorf("NewOutPoint: wrong index - got %v, want %v",
+		t.Errorf("NewOutpoint: wrong index - got %v, want %v",
 			prevOut.Index, prevOutIndex)
 	}
 	prevOutStr := fmt.Sprintf("%s:%d", txID.String(), prevOutIndex)
 	if s := prevOut.String(); s != prevOutStr {
-		t.Errorf("OutPoint.String: unexpected result - got %v, "+
+		t.Errorf("Outpoint.String: unexpected result - got %v, "+
 			"want %v", s, prevOutStr)
 	}

 	// Ensure we get the same transaction input back out.
 	sigScript := []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62}
 	txIn := NewTxIn(prevOut, sigScript)
-	if !reflect.DeepEqual(&txIn.PreviousOutPoint, prevOut) {
+	if !reflect.DeepEqual(&txIn.PreviousOutpoint, prevOut) {
 		t.Errorf("NewTxIn: wrong prev outpoint - got %v, want %v",
-			spew.Sprint(&txIn.PreviousOutPoint),
+			spew.Sprint(&txIn.PreviousOutpoint),
 			spew.Sprint(prevOut))
 	}
 	if !bytes.Equal(txIn.SignatureScript, sigScript) {
@@ -80,7 +81,7 @@ func TestTx(t *testing.T) {

 	// Ensure we get the same transaction output back out.
 	txValue := uint64(5000000000)
-	pkScript := []byte{
+	scriptPubKey := []byte{
 		0x41, // OP_DATA_65
 		0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
 		0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
@@ -93,16 +94,16 @@ func TestTx(t *testing.T) {
 		0xa6, // 65-byte signature
 		0xac, // OP_CHECKSIG
 	}
-	txOut := NewTxOut(txValue, pkScript)
+	txOut := NewTxOut(txValue, scriptPubKey)
 	if txOut.Value != txValue {
-		t.Errorf("NewTxOut: wrong pk script - got %v, want %v",
+		t.Errorf("NewTxOut: wrong scriptPubKey - got %v, want %v",
 			txOut.Value, txValue)

 	}
-	if !bytes.Equal(txOut.PkScript, pkScript) {
-		t.Errorf("NewTxOut: wrong pk script - got %v, want %v",
-			spew.Sdump(txOut.PkScript),
-			spew.Sdump(pkScript))
+	if !bytes.Equal(txOut.ScriptPubKey, scriptPubKey) {
+		t.Errorf("NewTxOut: wrong scriptPubKey - got %v, want %v",
+			spew.Sdump(txOut.ScriptPubKey),
+			spew.Sdump(scriptPubKey))
 	}

 	// Ensure transaction inputs are added properly.
@@ -129,25 +130,25 @@ func TestTx(t *testing.T) {

 // TestTxHash tests the ability to generate the hash of a transaction accurately.
 func TestTxHashAndID(t *testing.T) {
-	txID1Str := "5b92e6ed52bc78745905e0d104069e46407f62ea8d7d2bce78cd13f80ce220dc"
+	txID1Str := "edca872f27279674c7a52192b32fd68b8b8be714bfea52d98b2c3c86c30e85c6"
 	wantTxID1, err := daghash.NewTxIDFromStr(txID1Str)
 	if err != nil {
-		t.Errorf("NewHashFromStr: %v", err)
+		t.Errorf("NewTxIDFromStr: %v", err)
 		return
 	}

-	// First transaction from block 113875.
+	// A coinbase transaction
 	txIn := &TxIn{
-		PreviousOutPoint: OutPoint{
+		PreviousOutpoint: Outpoint{
 			TxID:  daghash.TxID{},
-			Index: 0xffffffff,
+			Index: math.MaxUint32,
 		},
 		SignatureScript: []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62},
 		Sequence:        math.MaxUint64,
 	}
 	txOut := &TxOut{
 		Value: 5000000000,
-		PkScript: []byte{
+		ScriptPubKey: []byte{
 			0x41, // OP_DATA_65
 			0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
 			0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
@@ -161,7 +162,7 @@ func TestTxHashAndID(t *testing.T) {
 			0xac, // OP_CHECKSIG
 		},
 	}
-	tx1 := NewNativeMsgTx(1, []*TxIn{txIn}, []*TxOut{txOut})
+	tx1 := NewSubnetworkMsgTx(1, []*TxIn{txIn}, []*TxOut{txOut}, subnetworkid.SubnetworkIDCoinbase, 0, nil)

 	// Ensure the hash produced is expected.
 	tx1Hash := tx1.TxHash()
@@ -180,19 +181,19 @@ func TestTxHashAndID(t *testing.T) {
 	hash2Str := "b11924b7eeffea821522222576c53dc5b8ddd97602f81e5e124d2626646d74ca"
 	wantHash2, err := daghash.NewHashFromStr(hash2Str)
 	if err != nil {
-		t.Errorf("NewHashFromStr: %v", err)
+		t.Errorf("NewTxIDFromStr: %v", err)
 		return
 	}

 	id2Str := "750499ae9e6d44961ef8bad8af27a44dd4bcbea166b71baf181e8d3997e1ff72"
 	wantID2, err := daghash.NewTxIDFromStr(id2Str)
 	if err != nil {
-		t.Errorf("NewHashFromStr: %v", err)
+		t.Errorf("NewTxIDFromStr: %v", err)
 		return
 	}
 	payload := []byte{1, 2, 3}
-	txIns := []*TxIn{&TxIn{
-		PreviousOutPoint: OutPoint{
+	txIns := []*TxIn{{
+		PreviousOutpoint: Outpoint{
 			Index: 0,
 			TxID:  daghash.TxID{1, 2, 3},
 		},
@@ -212,14 +213,14 @@ func TestTxHashAndID(t *testing.T) {
 	txOuts := []*TxOut{
 		{
 			Value: 244623243,
-			PkScript: []byte{
+			ScriptPubKey: []byte{
 				0x76, 0xA9, 0x14, 0xBA, 0xDE, 0xEC, 0xFD, 0xEF, 0x05, 0x07, 0x24, 0x7F, 0xC8, 0xF7, 0x42, 0x41,
 				0xD7, 0x3B, 0xC0, 0x39, 0x97, 0x2D, 0x7B, 0x88, 0xAC,
 			},
 		},
 		{
 			Value: 44602432,
-			PkScript: []byte{
+			ScriptPubKey: []byte{
 				0x76, 0xA9, 0x14, 0xC1, 0x09, 0x32, 0x48, 0x3F, 0xEC, 0x93, 0xED, 0x51, 0xF5, 0xFE, 0x95, 0xE7,
 				0x25, 0x59, 0xF2, 0xCC, 0x70, 0x43, 0xF9, 0x88, 0xAC,
 			},
@@ -245,17 +246,16 @@ func TestTxHashAndID(t *testing.T) {
 		t.Errorf("tx2ID and tx2Hash shouldn't be the same for non-coinbase transaction with signature and/or payload")
 	}

-	tx2.Payload = []byte{}
 	tx2.TxIn[0].SignatureScript = []byte{}
 	newTx2Hash := tx2.TxHash()
 	if !tx2ID.IsEqual((*daghash.TxID)(newTx2Hash)) {
-		t.Errorf("tx2ID and newTx2Hash should be the same for transaction without empty signature and payload")
+		t.Errorf("tx2ID and newTx2Hash should be the same for transaction with an empty signature")
 	}
 }

-// TestTxWire tests the MsgTx wire encode and decode for various numbers
+// TestTxEncoding tests the MsgTx appmessage encode and decode for various numbers
 // of transaction inputs and outputs and protocol versions.
-func TestTxWire(t *testing.T) {
+func TestTxEncoding(t *testing.T) {
 	// Empty tx message.
 	noTx := NewNativeMsgTx(1, nil, nil)
 	noTxEncoded := []byte{
@@ -271,8 +271,8 @@ func TestTxWire(t *testing.T) {
 	tests := []struct {
 		in   *MsgTx // Message to encode
 		out  *MsgTx // Expected decoded message
-		buf  []byte // Wire encoding
-		pver uint32 // Protocol version for wire encoding
+		buf  []byte // Encoded value
+		pver uint32 // Protocol version for appmessage encoding
 	}{
 		// Latest protocol version with no transactions.
 		{
@@ -293,44 +293,44 @@ func TestTxWire(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode the message to wire format.
+		// Encode the message to appmessage format.
 		var buf bytes.Buffer
-		err := test.in.BtcEncode(&buf, test.pver)
+		err := test.in.KaspaEncode(&buf, test.pver)
 		if err != nil {
-			t.Errorf("BtcEncode #%d error %v", i, err)
+			t.Errorf("KaspaEncode #%d error %v", i, err)
 			continue
 		}
 		if !bytes.Equal(buf.Bytes(), test.buf) {
-			t.Errorf("BtcEncode #%d\n got: %s want: %s", i,
+			t.Errorf("KaspaEncode #%d\n got: %s want: %s", i,
 				spew.Sdump(buf.Bytes()), spew.Sdump(test.buf))
 			continue
 		}

-		// Decode the message from wire format.
+		// Decode the message from appmessage format.
 		var msg MsgTx
 		rbuf := bytes.NewReader(test.buf)
-		err = msg.BtcDecode(rbuf, test.pver)
+		err = msg.KaspaDecode(rbuf, test.pver)
 		if err != nil {
-			t.Errorf("BtcDecode #%d error %v", i, err)
+			t.Errorf("KaspaDecode #%d error %v", i, err)
 			continue
 		}
 		if !reflect.DeepEqual(&msg, test.out) {
-			t.Errorf("BtcDecode #%d\n got: %s want: %s", i,
+			t.Errorf("KaspaDecode #%d\n got: %s want: %s", i,
 				spew.Sdump(&msg), spew.Sdump(test.out))
 			continue
 		}
 	}
 }

-// TestTxWireErrors performs negative tests against wire encode and decode
+// TestTxEncodingErrors performs negative tests against appmessage encode and decode
 // of MsgTx to confirm error paths work correctly.
-func TestTxWireErrors(t *testing.T) {
+func TestTxEncodingErrors(t *testing.T) {
 	pver := ProtocolVersion

 	tests := []struct {
 		in       *MsgTx // Value to encode
-		buf      []byte // Wire encoding
-		pver     uint32 // Protocol version for wire encoding
+		buf      []byte // Encoded value
+		pver     uint32 // Protocol version for appmessage encoding
 		max      int    // Max size of fixed buffer to induce errors
 		writeErr error  // Expected write error
 		readErr  error  // Expected read error
@@ -353,9 +353,9 @@ func TestTxWireErrors(t *testing.T) {
 		{multiTx, multiTxEncoded, pver, 57, io.ErrShortWrite, io.EOF},
 		// Force error in transaction output value.
 		{multiTx, multiTxEncoded, pver, 58, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output pk script length.
+		// Force error in transaction output scriptPubKey length.
 		{multiTx, multiTxEncoded, pver, 66, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output pk script.
+		// Force error in transaction output scriptPubKey.
 		{multiTx, multiTxEncoded, pver, 67, io.ErrShortWrite, io.EOF},
 		// Force error in transaction output lock time.
 		{multiTx, multiTxEncoded, pver, 210, io.ErrShortWrite, io.EOF},
@@ -363,21 +363,21 @@ func TestTxWireErrors(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Encode to wire format.
+		// Encode to appmessage format.
 		w := newFixedWriter(test.max)
-		err := test.in.BtcEncode(w, test.pver)
-		if err != test.writeErr {
-			t.Errorf("BtcEncode #%d wrong error got: %v, want: %v",
+		err := test.in.KaspaEncode(w, test.pver)
+		if !errors.Is(err, test.writeErr) {
+			t.Errorf("KaspaEncode #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
 		}

-		// Decode from wire format.
+		// Decode from appmessage format.
 		var msg MsgTx
 		r := newFixedReader(test.max, test.buf)
-		err = msg.BtcDecode(r, test.pver)
-		if err != test.readErr {
-			t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
+		err = msg.KaspaDecode(r, test.pver)
+		if !errors.Is(err, test.readErr) {
+			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
 		}
@@ -403,7 +403,7 @@ func TestTxSerialize(t *testing.T) {
 		0x00,                                           // Varint for number of input transactions
 		0x00,                                           // Varint for number of output transactions
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Lock time
-		0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 		0x00, 0x00, 0x00, 0x00, // Sub Network ID
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Gas
@@ -435,11 +435,11 @@ func TestTxSerialize(t *testing.T) {
 	}

 	tests := []struct {
-		name         string
-		in           *MsgTx // Message to encode
-		out          *MsgTx // Expected decoded message
-		buf          []byte // Serialized data
-		pkScriptLocs []int  // Expected output script locations
+		name             string
+		in               *MsgTx // Message to encode
+		out              *MsgTx // Expected decoded message
+		buf              []byte // Serialized data
+		scriptPubKeyLocs []int  // Expected output script locations
 	}{
 		// No transactions.
 		{
@@ -474,7 +474,7 @@ func TestTxSerialize(t *testing.T) {
 			multiTx,
 			multiTx,
 			multiTxEncoded,
-			multiTxPkScriptLocs,
+			multiTxScriptPubKeyLocs,
 		},
 	}

@@ -508,27 +508,27 @@ func TestTxSerialize(t *testing.T) {
 		}

 		// Ensure the public key script locations are accurate.
-		pkScriptLocs := test.in.PkScriptLocs()
-		if !reflect.DeepEqual(pkScriptLocs, test.pkScriptLocs) {
-			t.Errorf("PkScriptLocs #%d\n got: %s want: %s", i,
-				spew.Sdump(pkScriptLocs),
-				spew.Sdump(test.pkScriptLocs))
+		scriptPubKeyLocs := test.in.ScriptPubKeyLocs()
+		if !reflect.DeepEqual(scriptPubKeyLocs, test.scriptPubKeyLocs) {
+			t.Errorf("ScriptPubKeyLocs #%d\n got: %s want: %s", i,
+				spew.Sdump(scriptPubKeyLocs),
+				spew.Sdump(test.scriptPubKeyLocs))
 			continue
 		}
-		for j, loc := range pkScriptLocs {
-			wantPkScript := test.in.TxOut[j].PkScript
-			gotPkScript := test.buf[loc : loc+len(wantPkScript)]
-			if !bytes.Equal(gotPkScript, wantPkScript) {
-				t.Errorf("PkScriptLocs #%d:%d\n unexpected "+
+		for j, loc := range scriptPubKeyLocs {
+			wantScriptPubKey := test.in.TxOut[j].ScriptPubKey
+			gotScriptPubKey := test.buf[loc : loc+len(wantScriptPubKey)]
+			if !bytes.Equal(gotScriptPubKey, wantScriptPubKey) {
+				t.Errorf("ScriptPubKeyLocs #%d:%d\n unexpected "+
 					"script got: %s want: %s", i, j,
-					spew.Sdump(gotPkScript),
-					spew.Sdump(wantPkScript))
+					spew.Sdump(gotScriptPubKey),
+					spew.Sdump(wantScriptPubKey))
 			}
 		}
 	}
 }

-// TestTxSerializeErrors performs negative tests against wire encode and decode
+// TestTxSerializeErrors performs negative tests against appmessage encode and decode
 // of MsgTx to confirm error paths work correctly.
 func TestTxSerializeErrors(t *testing.T) {
 	tests := []struct {
@@ -556,9 +556,9 @@ func TestTxSerializeErrors(t *testing.T) {
 		{multiTx, multiTxEncoded, 57, io.ErrShortWrite, io.EOF},
 		// Force error in transaction output value.
 		{multiTx, multiTxEncoded, 58, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output pk script length.
+		// Force error in transaction output scriptPubKey length.
 		{multiTx, multiTxEncoded, 66, io.ErrShortWrite, io.EOF},
-		// Force error in transaction output pk script.
+		// Force error in transaction output scriptPubKey.
 		{multiTx, multiTxEncoded, 67, io.ErrShortWrite, io.EOF},
 		// Force error in transaction output lock time.
 		{multiTx, multiTxEncoded, 210, io.ErrShortWrite, io.EOF},
@@ -569,7 +569,7 @@ func TestTxSerializeErrors(t *testing.T) {
 		// Serialize the transaction.
 		w := newFixedWriter(test.max)
 		err := test.in.Serialize(w)
-		if err != test.writeErr {
+		if !errors.Is(err, test.writeErr) {
 			t.Errorf("Serialize #%d wrong error got: %v, want: %v",
 				i, err, test.writeErr)
 			continue
@@ -579,7 +579,7 @@ func TestTxSerializeErrors(t *testing.T) {
 		var tx MsgTx
 		r := newFixedReader(test.max, test.buf)
 		err = tx.Deserialize(r)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("Deserialize #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -590,8 +590,8 @@ func TestTxSerializeErrors(t *testing.T) {

 	w := bytes.NewBuffer(make([]byte, 0, registryTx.SerializeSize()))
 	err := registryTx.Serialize(w)
-	str := "Transactions from registry subnetwork should have 0 gas"
-	expectedErr := messageError("MsgTx.BtcEncode", str)
+	str := "Transactions from built-in should have 0 gas"
+	expectedErr := messageError("MsgTx.KaspaEncode", str)
 	if err == nil || err.Error() != expectedErr.Error() {
 		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
 	}
@@ -601,7 +601,7 @@ func TestTxSerializeErrors(t *testing.T) {
 	err = nativeTx.Serialize(w)

 	str = "Transactions from native subnetwork should have 0 gas"
-	expectedErr = messageError("MsgTx.BtcEncode", str)
+	expectedErr = messageError("MsgTx.KaspaEncode", str)
 	if err == nil || err.Error() != expectedErr.Error() {
 		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
 	}
@@ -613,7 +613,7 @@ func TestTxSerializeErrors(t *testing.T) {
 	err = nativeTx.Serialize(w)

 	str = "Transactions from native subnetwork should have <nil> payload"
-	expectedErr = messageError("MsgTx.BtcEncode", str)
+	expectedErr = messageError("MsgTx.KaspaEncode", str)
 	if err == nil || err.Error() != expectedErr.Error() {
 		t.Errorf("TestTxSerializeErrors: expected error %v but got %v", expectedErr, err)
 	}
@@ -621,15 +621,15 @@ func TestTxSerializeErrors(t *testing.T) {

 // TestTxOverflowErrors performs tests to ensure deserializing transactions
 // which are intentionally crafted to use large values for the variable number
-// of inputs and outputs are handled properly.  This could otherwise potentially
+// of inputs and outputs are handled properly. This could otherwise potentially
 // be used as an attack vector.
 func TestTxOverflowErrors(t *testing.T) {
 	pver := ProtocolVersion
 	txVer := uint32(1)

 	tests := []struct {
-		buf     []byte // Wire encoding
-		pver    uint32 // Protocol version for wire encoding
+		buf     []byte // Encoded value
+		pver    uint32 // Protocol version for appmessage encoding
 		version uint32 // Transaction version
 		err     error  // Expected error
 	}{
@@ -691,17 +691,17 @@ func TestTxOverflowErrors(t *testing.T) {

 	t.Logf("Running %d tests", len(tests))
 	for i, test := range tests {
-		// Decode from wire format.
+		// Decode from appmessage format.
 		var msg MsgTx
 		r := bytes.NewReader(test.buf)
-		err := msg.BtcDecode(r, test.pver)
+		err := msg.KaspaDecode(r, test.pver)
 		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("BtcDecode #%d wrong error got: %v, want: %v",
+			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
 				i, err, reflect.TypeOf(test.err))
 			continue
 		}

-		// Decode from wire format.
+		// Decode from appmessage format.
 		r = bytes.NewReader(test.buf)
 		err = msg.Deserialize(r)
 		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
@@ -845,7 +845,7 @@ func underlyingArrayAddress(buf []byte) uint64 {
 // multiTx is a MsgTx with an input and output and used in various tests.
 var multiTxIns = []*TxIn{
 	{
-		PreviousOutPoint: OutPoint{
+		PreviousOutpoint: Outpoint{
 			TxID:  daghash.TxID{},
 			Index: 0xffffffff,
 		},
@@ -858,7 +858,7 @@ var multiTxIns = []*TxIn{
 var multiTxOuts = []*TxOut{
 	{
 		Value: 0x12a05f200,
-		PkScript: []byte{
+		ScriptPubKey: []byte{
 			0x41, // OP_DATA_65
 			0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
 			0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
@@ -874,7 +874,7 @@ var multiTxOuts = []*TxOut{
 	},
 	{
 		Value: 0x5f5e100,
-		PkScript: []byte{
+		ScriptPubKey: []byte{
 			0x41, // OP_DATA_65
 			0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
 			0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
@@ -891,7 +891,7 @@ var multiTxOuts = []*TxOut{
 }
 var multiTx = NewNativeMsgTx(1, multiTxIns, multiTxOuts)

-// multiTxEncoded is the wire encoded bytes for multiTx using protocol version
+// multiTxEncoded is the appmessage encoded bytes for multiTx using protocol version
 // 60002 and is used in the various tests.
 var multiTxEncoded = []byte{
 	0x01, 0x00, 0x00, 0x00, // Version
@@ -906,7 +906,7 @@ var multiTxEncoded = []byte{
 	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // Sequence
 	0x02,                                           // Varint for number of output transactions
 	0x00, 0xf2, 0x05, 0x2a, 0x01, 0x00, 0x00, 0x00, // Transaction amount
-	0x43, // Varint for length of pk script
+	0x43, // Varint for length of scriptPubKey
 	0x41, // OP_DATA_65
 	0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
 	0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
@@ -919,7 +919,7 @@ var multiTxEncoded = []byte{
 	0xa6,                                           // 65-byte signature
 	0xac,                                           // OP_CHECKSIG
 	0x00, 0xe1, 0xf5, 0x05, 0x00, 0x00, 0x00, 0x00, // Transaction amount
-	0x43, // Varint for length of pk script
+	0x43, // Varint for length of scriptPubKey
 	0x41, // OP_DATA_65
 	0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
 	0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
@@ -937,6 +937,6 @@ var multiTxEncoded = []byte{
 	0x00, 0x00, 0x00, 0x00, // Sub Network ID
 }

-// multiTxPkScriptLocs is the location information for the public key scripts
+// multiTxScriptPubKeyLocs is the location information for the public key scripts
 // located in multiTx.
-var multiTxPkScriptLocs = []int{67, 143}
+var multiTxScriptPubKeyLocs = []int{67, 143}
--- a/app/appmessage/p2p_msgverack.go
+++ b/app/appmessage/p2p_msgverack.go
@@ -0,0 +1,26 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+// MsgVerAck defines a kaspa verack message which is used for a peer to
+// acknowledge a version message (MsgVersion) after it has used the information
+// to negotiate parameters. It implements the Message interface.
+//
+// This message has no payload.
+type MsgVerAck struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgVerAck) Command() MessageCommand {
+	return CmdVerAck
+}
+
+// NewMsgVerAck returns a new kaspa verack message that conforms to the
+// Message interface.
+func NewMsgVerAck() *MsgVerAck {
+	return &MsgVerAck{}
+}
--- a/app/appmessage/p2p_msgverack_test.go
+++ b/app/appmessage/p2p_msgverack_test.go
@@ -0,0 +1,20 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"testing"
+)
+
+// TestVerAck tests the MsgVerAck API.
+func TestVerAck(t *testing.T) {
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(1)
+	msg := NewMsgVerAck()
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgVerAck: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+}
--- a/app/appmessage/p2p_msgversion.go
+++ b/app/appmessage/p2p_msgversion.go
@@ -0,0 +1,130 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"fmt"
+	"github.com/kaspanet/kaspad/version"
+	"strings"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util/mstime"
+
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/subnetworkid"
+)
+
+// MaxUserAgentLen is the maximum allowed length for the user agent field in a
+// version message (MsgVersion).
+const MaxUserAgentLen = 256
+
+// DefaultUserAgent for appmessage in the stack
+var DefaultUserAgent = fmt.Sprintf("/kaspad:%s/", version.Version())
+
+// MsgVersion implements the Message interface and represents a kaspa version
+// message. It is used for a peer to advertise itself as soon as an outbound
+// connection is made. The remote peer then uses this information along with
+// its own to negotiate. The remote peer must then respond with a version
+// message of its own containing the negotiated values followed by a verack
+// message (MsgVerAck). This exchange must take place before any further
+// communication is allowed to proceed.
+type MsgVersion struct {
+	baseMessage
+	// Version of the protocol the node is using.
+	ProtocolVersion uint32
+
+	// The peer's network (mainnet, testnet, etc.)
+	Network string
+
+	// Bitfield which identifies the enabled services.
+	Services ServiceFlag
+
+	// Time the message was generated. This is encoded as an int64 on the appmessage.
+	Timestamp mstime.Time
+
+	// Address of the local peer.
+	Address *NetAddress
+
+	// The peer unique ID
+	ID *id.ID
+
+	// The user agent that generated messsage. This is a encoded as a varString
+	// on the appmessage. This has a max length of MaxUserAgentLen.
+	UserAgent string
+
+	// The selected tip hash of the generator of the version message.
+	SelectedTipHash *daghash.Hash
+
+	// Don't announce transactions to peer.
+	DisableRelayTx bool
+
+	// The subnetwork of the generator of the version message. Should be nil in full nodes
+	SubnetworkID *subnetworkid.SubnetworkID
+}
+
+// HasService returns whether the specified service is supported by the peer
+// that generated the message.
+func (msg *MsgVersion) HasService(service ServiceFlag) bool {
+	return msg.Services&service == service
+}
+
+// AddService adds service as a supported service by the peer generating the
+// message.
+func (msg *MsgVersion) AddService(service ServiceFlag) {
+	msg.Services |= service
+}
+
+// Command returns the protocol command string for the message. This is part
+// of the Message interface implementation.
+func (msg *MsgVersion) Command() MessageCommand {
+	return CmdVersion
+}
+
+// NewMsgVersion returns a new kaspa version message that conforms to the
+// Message interface using the passed parameters and defaults for the remaining
+// fields.
+func NewMsgVersion(addr *NetAddress, id *id.ID, network string,
+	selectedTipHash *daghash.Hash, subnetworkID *subnetworkid.SubnetworkID) *MsgVersion {
+
+	// Limit the timestamp to one millisecond precision since the protocol
+	// doesn't support better.
+	return &MsgVersion{
+		ProtocolVersion: ProtocolVersion,
+		Network:         network,
+		Services:        0,
+		Timestamp:       mstime.Now(),
+		Address:         addr,
+		ID:              id,
+		UserAgent:       DefaultUserAgent,
+		SelectedTipHash: selectedTipHash,
+		DisableRelayTx:  false,
+		SubnetworkID:    subnetworkID,
+	}
+}
+
+// ValidateUserAgent checks userAgent length against MaxUserAgentLen
+func ValidateUserAgent(userAgent string) error {
+	if len(userAgent) > MaxUserAgentLen {
+		str := fmt.Sprintf("user agent too long [len %d, max %d]",
+			len(userAgent), MaxUserAgentLen)
+		return messageError("MsgVersion", str)
+	}
+	return nil
+}
+
+// AddUserAgent adds a user agent to the user agent string for the version
+// message. The version string is not defined to any strict format, although
+// it is recommended to use the form "major.minor.revision" e.g. "2.6.41".
+func (msg *MsgVersion) AddUserAgent(name string, version string,
+	comments ...string) {
+
+	newUserAgent := fmt.Sprintf("%s:%s", name, version)
+	if len(comments) != 0 {
+		newUserAgent = fmt.Sprintf("%s(%s)", newUserAgent,
+			strings.Join(comments, "; "))
+	}
+	newUserAgent = fmt.Sprintf("%s%s/", msg.UserAgent, newUserAgent)
+	msg.UserAgent = newUserAgent
+}
--- a/app/appmessage/p2p_msgversion_test.go
+++ b/app/appmessage/p2p_msgversion_test.go
@@ -0,0 +1,96 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/davecgh/go-spew/spew"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"net"
+	"reflect"
+	"testing"
+)
+
+// TestVersion tests the MsgVersion API.
+func TestVersion(t *testing.T) {
+	pver := ProtocolVersion
+
+	// Create version message data.
+	selectedTipHash := &daghash.Hash{12, 34}
+	tcpAddrMe := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 16111}
+	me := NewNetAddress(tcpAddrMe, SFNodeNetwork)
+	generatedID, err := id.GenerateID()
+	if err != nil {
+		t.Fatalf("id.GenerateID: %s", err)
+	}
+
+	// Ensure we get the correct data back out.
+	msg := NewMsgVersion(me, generatedID, "mainnet", selectedTipHash, nil)
+	if msg.ProtocolVersion != pver {
+		t.Errorf("NewMsgVersion: wrong protocol version - got %v, want %v",
+			msg.ProtocolVersion, pver)
+	}
+	if !reflect.DeepEqual(msg.Address, me) {
+		t.Errorf("NewMsgVersion: wrong me address - got %v, want %v",
+			spew.Sdump(&msg.Address), spew.Sdump(me))
+	}
+	if msg.ID.String() != generatedID.String() {
+		t.Errorf("NewMsgVersion: wrong nonce - got %s, want %s",
+			msg.ID, generatedID)
+	}
+	if msg.UserAgent != DefaultUserAgent {
+		t.Errorf("NewMsgVersion: wrong user agent - got %v, want %v",
+			msg.UserAgent, DefaultUserAgent)
+	}
+	if !msg.SelectedTipHash.IsEqual(selectedTipHash) {
+		t.Errorf("NewMsgVersion: wrong selected tip hash - got %s, want %s",
+			msg.SelectedTipHash, selectedTipHash)
+	}
+	if msg.DisableRelayTx {
+		t.Errorf("NewMsgVersion: disable relay tx is not false by "+
+			"default - got %v, want %v", msg.DisableRelayTx, false)
+	}
+
+	msg.AddUserAgent("myclient", "1.2.3", "optional", "comments")
+	customUserAgent := DefaultUserAgent + "myclient:1.2.3(optional; comments)/"
+	if msg.UserAgent != customUserAgent {
+		t.Errorf("AddUserAgent: wrong user agent - got %s, want %s",
+			msg.UserAgent, customUserAgent)
+	}
+
+	msg.AddUserAgent("mygui", "3.4.5")
+	customUserAgent += "mygui:3.4.5/"
+	if msg.UserAgent != customUserAgent {
+		t.Errorf("AddUserAgent: wrong user agent - got %s, want %s",
+			msg.UserAgent, customUserAgent)
+	}
+
+	// Version message should not have any services set by default.
+	if msg.Services != 0 {
+		t.Errorf("NewMsgVersion: wrong default services - got %v, want %v",
+			msg.Services, 0)
+
+	}
+	if msg.HasService(SFNodeNetwork) {
+		t.Errorf("HasService: SFNodeNetwork service is set")
+	}
+
+	// Ensure the command is expected value.
+	wantCmd := MessageCommand(0)
+	if cmd := msg.Command(); cmd != wantCmd {
+		t.Errorf("NewMsgVersion: wrong command - got %v want %v",
+			cmd, wantCmd)
+	}
+
+	// Ensure adding the full service node flag works.
+	msg.AddService(SFNodeNetwork)
+	if msg.Services != SFNodeNetwork {
+		t.Errorf("AddService: wrong services - got %v, want %v",
+			msg.Services, SFNodeNetwork)
+	}
+	if !msg.HasService(SFNodeNetwork) {
+		t.Errorf("HasService: SFNodeNetwork service not set")
+	}
+}
--- a/app/appmessage/p2p_netaddress.go
+++ b/app/appmessage/p2p_netaddress.go
@@ -0,0 +1,74 @@
+// Copyright (c) 2013-2015 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"github.com/kaspanet/kaspad/util/mstime"
+	"net"
+)
+
+// NetAddress defines information about a peer on the network including the time
+// it was last seen, the services it supports, its IP address, and port.
+type NetAddress struct {
+	// Last time the address was seen.
+	Timestamp mstime.Time
+
+	// Bitfield which identifies the services supported by the address.
+	Services ServiceFlag
+
+	// IP address of the peer.
+	IP net.IP
+
+	// Port the peer is using. This is encoded in big endian on the appmessage
+	// which differs from most everything else.
+	Port uint16
+}
+
+// HasService returns whether the specified service is supported by the address.
+func (na *NetAddress) HasService(service ServiceFlag) bool {
+	return na.Services&service == service
+}
+
+// AddService adds service as a supported service by the peer generating the
+// message.
+func (na *NetAddress) AddService(service ServiceFlag) {
+	na.Services |= service
+}
+
+// TCPAddress converts the NetAddress to *net.TCPAddr
+func (na *NetAddress) TCPAddress() *net.TCPAddr {
+	return &net.TCPAddr{
+		IP:   na.IP,
+		Port: int(na.Port),
+	}
+}
+
+// NewNetAddressIPPort returns a new NetAddress using the provided IP, port, and
+// supported services with defaults for the remaining fields.
+func NewNetAddressIPPort(ip net.IP, port uint16, services ServiceFlag) *NetAddress {
+	return NewNetAddressTimestamp(mstime.Now(), services, ip, port)
+}
+
+// NewNetAddressTimestamp returns a new NetAddress using the provided
+// timestamp, IP, port, and supported services. The timestamp is rounded to
+// single millisecond precision.
+func NewNetAddressTimestamp(
+	timestamp mstime.Time, services ServiceFlag, ip net.IP, port uint16) *NetAddress {
+	// Limit the timestamp to one millisecond precision since the protocol
+	// doesn't support better.
+	na := NetAddress{
+		Timestamp: timestamp,
+		Services:  services,
+		IP:        ip,
+		Port:      port,
+	}
+	return &na
+}
+
+// NewNetAddress returns a new NetAddress using the provided TCP address and
+// supported services with defaults for the remaining fields.
+func NewNetAddress(addr *net.TCPAddr, services ServiceFlag) *NetAddress {
+	return NewNetAddressIPPort(addr.IP, uint16(addr.Port), services)
+}
--- a/app/appmessage/p2p_netaddress_test.go
+++ b/app/appmessage/p2p_netaddress_test.go
@@ -0,0 +1,45 @@
+// Copyright (c) 2013-2016 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package appmessage
+
+import (
+	"net"
+	"testing"
+)
+
+// TestNetAddress tests the NetAddress API.
+func TestNetAddress(t *testing.T) {
+	ip := net.ParseIP("127.0.0.1")
+	port := 16111
+
+	// Test NewNetAddress.
+	na := NewNetAddress(&net.TCPAddr{IP: ip, Port: port}, 0)
+
+	// Ensure we get the same ip, port, and services back out.
+	if !na.IP.Equal(ip) {
+		t.Errorf("NetNetAddress: wrong ip - got %v, want %v", na.IP, ip)
+	}
+	if na.Port != uint16(port) {
+		t.Errorf("NetNetAddress: wrong port - got %v, want %v", na.Port,
+			port)
+	}
+	if na.Services != 0 {
+		t.Errorf("NetNetAddress: wrong services - got %v, want %v",
+			na.Services, 0)
+	}
+	if na.HasService(SFNodeNetwork) {
+		t.Errorf("HasService: SFNodeNetwork service is set")
+	}
+
+	// Ensure adding the full service node flag works.
+	na.AddService(SFNodeNetwork)
+	if na.Services != SFNodeNetwork {
+		t.Errorf("AddService: wrong services - got %v, want %v",
+			na.Services, SFNodeNetwork)
+	}
+	if !na.HasService(SFNodeNetwork) {
+		t.Errorf("HasService: SFNodeNetwork service not set")
+	}
+}
--- a/app/appmessage/protocol.go
+++ b/app/appmessage/protocol.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import (
 	"fmt"
@@ -10,13 +10,16 @@ import (
 	"strings"
 )

-// XXX pedro: we will probably need to bump this.
 const (
 	// ProtocolVersion is the latest protocol version this package supports.
 	ProtocolVersion uint32 = 1
+
+	// DefaultServices describes the default services that are supported by
+	// the server.
+	DefaultServices = SFNodeNetwork | SFNodeBloom | SFNodeCF
 )

-// ServiceFlag identifies services supported by a bitcoin peer.
+// ServiceFlag identifies services supported by a kaspa peer.
 type ServiceFlag uint64

 const (
@@ -89,45 +92,41 @@ func (f ServiceFlag) String() string {
 	return s
 }

-// BitcoinNet represents which bitcoin network a message belongs to.
-type BitcoinNet uint32
+// KaspaNet represents which kaspa network a message belongs to.
+type KaspaNet uint32

-// Constants used to indicate the message bitcoin network.  They can also be
+// Constants used to indicate the message kaspa network. They can also be
 // used to seek to the next message when a stream's state is unknown, but
 // this package does not provide that functionality since it's generally a
 // better idea to simply disconnect clients that are misbehaving over TCP.
 const (
-	// MainNet represents the main bitcoin network.
-	MainNet BitcoinNet = 0xd9b4bef9
+	// Mainnet represents the main kaspa network.
+	Mainnet KaspaNet = 0x3ddcf71d

-	// TestNet represents the regression test network.
-	TestNet BitcoinNet = 0xdab5bffa
+	// Testnet represents the test network.
+	Testnet KaspaNet = 0xddb8af8f

-	// TestNet3 represents the test network (version 3).
-	TestNet3 BitcoinNet = 0x0709110b
+	// Simnet represents the simulation test network.
+	Simnet KaspaNet = 0x374dcf1c

-	// SimNet represents the simulation test network.
-	SimNet BitcoinNet = 0x12141c16
-
-	// DevNet represents the development test network.
-	DevNet BitcoinNet = 0x01020304
+	// Devnet represents the development test network.
+	Devnet KaspaNet = 0x732d87e1
 )

-// bnStrings is a map of bitcoin networks back to their constant names for
+// bnStrings is a map of kaspa networks back to their constant names for
 // pretty printing.
-var bnStrings = map[BitcoinNet]string{
-	MainNet:  "MainNet",
-	TestNet:  "TestNet",
-	TestNet3: "TestNet3",
-	SimNet:   "SimNet",
-	DevNet:   "DevNet",
+var bnStrings = map[KaspaNet]string{
+	Mainnet: "Mainnet",
+	Testnet: "Testnet",
+	Simnet:  "Simnet",
+	Devnet:  "Devnet",
 }

-// String returns the BitcoinNet in human-readable form.
-func (n BitcoinNet) String() string {
+// String returns the KaspaNet in human-readable form.
+func (n KaspaNet) String() string {
 	if s, ok := bnStrings[n]; ok {
 		return s
 	}

-	return fmt.Sprintf("Unknown BitcoinNet (%d)", uint32(n))
+	return fmt.Sprintf("Unknown KaspaNet (%d)", uint32(n))
 }
--- a/app/appmessage/protocol_test.go
+++ b/app/appmessage/protocol_test.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.

-package wire
+package appmessage

 import "testing"

@@ -33,17 +33,16 @@ func TestServiceFlagStringer(t *testing.T) {
 	}
 }

-// TestBitcoinNetStringer tests the stringized output for bitcoin net types.
-func TestBitcoinNetStringer(t *testing.T) {
+// TestKaspaNetStringer tests the stringized output for kaspa net types.
+func TestKaspaNetStringer(t *testing.T) {
 	tests := []struct {
-		in   BitcoinNet
+		in   KaspaNet
 		want string
 	}{
-		{MainNet, "MainNet"},
-		{TestNet, "TestNet"},
-		{TestNet3, "TestNet3"},
-		{SimNet, "SimNet"},
-		{0xffffffff, "Unknown BitcoinNet (4294967295)"},
+		{Mainnet, "Mainnet"},
+		{Testnet, "Testnet"},
+		{Simnet, "Simnet"},
+		{0xffffffff, "Unknown KaspaNet (4294967295)"},
 	}

 	t.Logf("Running %d tests", len(tests))
--- a/app/appmessage/rpc_add_peer.go
+++ b/app/appmessage/rpc_add_peer.go
@@ -0,0 +1,39 @@
+package appmessage
+
+// AddPeerRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type AddPeerRequestMessage struct {
+	baseMessage
+	Address     string
+	IsPermanent bool
+}
+
+// Command returns the protocol command string for the message
+func (msg *AddPeerRequestMessage) Command() MessageCommand {
+	return CmdAddPeerRequestMessage
+}
+
+// NewAddPeerRequestMessage returns a instance of the message
+func NewAddPeerRequestMessage(address string, isPermanent bool) *AddPeerRequestMessage {
+	return &AddPeerRequestMessage{
+		Address:     address,
+		IsPermanent: isPermanent,
+	}
+}
+
+// AddPeerResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type AddPeerResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *AddPeerResponseMessage) Command() MessageCommand {
+	return CmdAddPeerResponseMessage
+}
+
+// NewAddPeerResponseMessage returns a instance of the message
+func NewAddPeerResponseMessage() *AddPeerResponseMessage {
+	return &AddPeerResponseMessage{}
+}
--- a/app/appmessage/rpc_get_block.go
+++ b/app/appmessage/rpc_get_block.go
@@ -0,0 +1,123 @@
+package appmessage
+
+// GetBlockRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockRequestMessage struct {
+	baseMessage
+	Hash                          string
+	SubnetworkID                  string
+	IncludeBlockHex               bool
+	IncludeBlockVerboseData       bool
+	IncludeTransactionVerboseData bool
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlockRequestMessage) Command() MessageCommand {
+	return CmdGetBlockRequestMessage
+}
+
+// NewGetBlockRequestMessage returns a instance of the message
+func NewGetBlockRequestMessage(hash string, subnetworkID string, includeBlockHex bool,
+	includeBlockVerboseData bool, includeTransactionVerboseData bool) *GetBlockRequestMessage {
+	return &GetBlockRequestMessage{
+		Hash:                          hash,
+		SubnetworkID:                  subnetworkID,
+		IncludeBlockHex:               includeBlockHex,
+		IncludeBlockVerboseData:       includeBlockVerboseData,
+		IncludeTransactionVerboseData: includeTransactionVerboseData,
+	}
+}
+
+// GetBlockResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockResponseMessage struct {
+	baseMessage
+	BlockHex         string
+	BlockVerboseData *BlockVerboseData
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlockResponseMessage) Command() MessageCommand {
+	return CmdGetBlockResponseMessage
+}
+
+// NewGetBlockResponseMessage returns a instance of the message
+func NewGetBlockResponseMessage() *GetBlockResponseMessage {
+	return &GetBlockResponseMessage{}
+}
+
+// BlockVerboseData holds verbose data about a block
+type BlockVerboseData struct {
+	Hash                   string
+	Confirmations          uint64
+	Size                   int32
+	BlueScore              uint64
+	IsChainBlock           bool
+	Version                int32
+	VersionHex             string
+	HashMerkleRoot         string
+	AcceptedIDMerkleRoot   string
+	UTXOCommitment         string
+	TxIDs                  []string
+	TransactionVerboseData []*TransactionVerboseData
+	Time                   int64
+	Nonce                  uint64
+	Bits                   string
+	Difficulty             float64
+	ParentHashes           []string
+	SelectedParentHash     string
+	ChildHashes            []string
+	AcceptedBlockHashes    []string
+}
+
+// TransactionVerboseData holds verbose data about a transaction
+type TransactionVerboseData struct {
+	Hex                       string
+	TxID                      string
+	Hash                      string
+	Size                      int32
+	Version                   int32
+	LockTime                  uint64
+	SubnetworkID              string
+	Gas                       uint64
+	PayloadHash               string
+	Payload                   string
+	TransactionVerboseInputs  []*TransactionVerboseInput
+	TransactionVerboseOutputs []*TransactionVerboseOutput
+	BlockHash                 string
+	AcceptedBy                string
+	IsInMempool               bool
+	Time                      uint64
+	BlockTime                 uint64
+}
+
+// TransactionVerboseInput holds data about a transaction input
+type TransactionVerboseInput struct {
+	TxID        string
+	OutputIndex uint32
+	ScriptSig   *ScriptSig
+	Sequence    uint64
+}
+
+// ScriptSig holds data about a script signature
+type ScriptSig struct {
+	Asm string
+	Hex string
+}
+
+// TransactionVerboseOutput holds data about a transaction output
+type TransactionVerboseOutput struct {
+	Value        uint64
+	Index        uint32
+	ScriptPubKey *ScriptPubKeyResult
+}
+
+// ScriptPubKeyResult holds data about a script public key
+type ScriptPubKeyResult struct {
+	Asm     string
+	Hex     string
+	Type    string
+	Address string
+}
--- a/app/appmessage/rpc_get_block_count.go
+++ b/app/appmessage/rpc_get_block_count.go
@@ -0,0 +1,38 @@
+package appmessage
+
+// GetBlockCountRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockCountRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlockCountRequestMessage) Command() MessageCommand {
+	return CmdGetBlockCountRequestMessage
+}
+
+// NewGetBlockCountRequestMessage returns a instance of the message
+func NewGetBlockCountRequestMessage() *GetBlockCountRequestMessage {
+	return &GetBlockCountRequestMessage{}
+}
+
+// GetBlockCountResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockCountResponseMessage struct {
+	baseMessage
+	BlockCount uint64
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlockCountResponseMessage) Command() MessageCommand {
+	return CmdGetBlockCountResponseMessage
+}
+
+// NewGetBlockCountResponseMessage returns a instance of the message
+func NewGetBlockCountResponseMessage(blockCount uint64) *GetBlockCountResponseMessage {
+	return &GetBlockCountResponseMessage{
+		BlockCount: blockCount,
+	}
+}
--- a/app/appmessage/rpc_get_block_dag_info.go
+++ b/app/appmessage/rpc_get_block_dag_info.go
@@ -0,0 +1,41 @@
+package appmessage
+
+// GetBlockDAGInfoRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockDAGInfoRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlockDAGInfoRequestMessage) Command() MessageCommand {
+	return CmdGetBlockDAGInfoRequestMessage
+}
+
+// NewGetBlockDAGInfoRequestMessage returns a instance of the message
+func NewGetBlockDAGInfoRequestMessage() *GetBlockDAGInfoRequestMessage {
+	return &GetBlockDAGInfoRequestMessage{}
+}
+
+// GetBlockDAGInfoResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockDAGInfoResponseMessage struct {
+	baseMessage
+	NetworkName         string
+	BlockCount          uint64
+	TipHashes           []string
+	VirtualParentHashes []string
+	Difficulty          float64
+	PastMedianTime      int64
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlockDAGInfoResponseMessage) Command() MessageCommand {
+	return CmdGetBlockDAGInfoResponseMessage
+}
+
+// NewGetBlockDAGInfoResponseMessage returns a instance of the message
+func NewGetBlockDAGInfoResponseMessage() *GetBlockDAGInfoResponseMessage {
+	return &GetBlockDAGInfoResponseMessage{}
+}
--- a/app/appmessage/rpc_get_block_template.go
+++ b/app/appmessage/rpc_get_block_template.go
@@ -0,0 +1,78 @@
+package appmessage
+
+// GetBlockTemplateRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockTemplateRequestMessage struct {
+	baseMessage
+	PayAddress string
+	LongPollID string
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlockTemplateRequestMessage) Command() MessageCommand {
+	return CmdGetBlockTemplateRequestMessage
+}
+
+// NewGetBlockTemplateRequestMessage returns a instance of the message
+func NewGetBlockTemplateRequestMessage(payAddress string, longPollID string) *GetBlockTemplateRequestMessage {
+	return &GetBlockTemplateRequestMessage{
+		PayAddress: payAddress,
+		LongPollID: longPollID,
+	}
+}
+
+// GetBlockTemplateResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockTemplateResponseMessage struct {
+	baseMessage
+	Bits                 string
+	CurrentTime          int64
+	ParentHashes         []string
+	MassLimit            int
+	Transactions         []GetBlockTemplateTransactionMessage
+	HashMerkleRoot       string
+	AcceptedIDMerkleRoot string
+	UTXOCommitment       string
+	Version              int32
+	LongPollID           string
+	TargetDifficulty     string
+	MinTime              int64
+	MaxTime              int64
+	MutableFields        []string
+	NonceRange           string
+	IsSynced             bool
+	IsConnected          bool
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlockTemplateResponseMessage) Command() MessageCommand {
+	return CmdGetBlockTemplateResponseMessage
+}
+
+// NewGetBlockTemplateResponseMessage returns a instance of the message
+func NewGetBlockTemplateResponseMessage() *GetBlockTemplateResponseMessage {
+	return &GetBlockTemplateResponseMessage{}
+}
+
+// GetBlockTemplateTransactionMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlockTemplateTransactionMessage struct {
+	baseMessage
+	Data    string
+	ID      string
+	Depends []int64
+	Mass    uint64
+	Fee     uint64
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlockTemplateTransactionMessage) Command() MessageCommand {
+	return CmdGetBlockTemplateTransactionMessage
+}
+
+// NewGetBlockTemplateTransactionMessage returns a instance of the message
+func NewGetBlockTemplateTransactionMessage() *GetBlockTemplateTransactionMessage {
+	return &GetBlockTemplateTransactionMessage{}
+}
--- a/app/appmessage/rpc_get_blocks.go
+++ b/app/appmessage/rpc_get_blocks.go
@@ -0,0 +1,51 @@
+package appmessage
+
+// GetBlocksRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlocksRequestMessage struct {
+	baseMessage
+	LowHash                 string
+	IncludeBlockHexes       bool
+	IncludeBlockVerboseData bool
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlocksRequestMessage) Command() MessageCommand {
+	return CmdGetBlocksRequestMessage
+}
+
+// NewGetBlocksRequestMessage returns a instance of the message
+func NewGetBlocksRequestMessage(lowHash string, includeBlockHexes bool, includeBlockVerboseData bool) *GetBlocksRequestMessage {
+	return &GetBlocksRequestMessage{
+		LowHash:                 lowHash,
+		IncludeBlockHexes:       includeBlockHexes,
+		IncludeBlockVerboseData: includeBlockVerboseData,
+	}
+}
+
+// GetBlocksResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetBlocksResponseMessage struct {
+	baseMessage
+	BlockHashes      []string
+	BlockHexes       []string
+	BlockVerboseData []*BlockVerboseData
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetBlocksResponseMessage) Command() MessageCommand {
+	return CmdGetBlocksResponseMessage
+}
+
+// NewGetBlocksResponseMessage returns a instance of the message
+func NewGetBlocksResponseMessage(blockHashes []string, blockHexes []string,
+	blockVerboseData []*BlockVerboseData) *GetBlocksResponseMessage {
+
+	return &GetBlocksResponseMessage{
+		BlockHashes:      blockHashes,
+		BlockHexes:       blockHexes,
+		BlockVerboseData: blockVerboseData,
+	}
+}
--- a/app/appmessage/rpc_get_chain_from_block.go
+++ b/app/appmessage/rpc_get_chain_from_block.go
@@ -0,0 +1,49 @@
+package appmessage
+
+// GetChainFromBlockRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetChainFromBlockRequestMessage struct {
+	baseMessage
+	StartHash               string
+	IncludeBlockVerboseData bool
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetChainFromBlockRequestMessage) Command() MessageCommand {
+	return CmdGetChainFromBlockRequestMessage
+}
+
+// NewGetChainFromBlockRequestMessage returns a instance of the message
+func NewGetChainFromBlockRequestMessage(startHash string, includeBlockVerboseData bool) *GetChainFromBlockRequestMessage {
+	return &GetChainFromBlockRequestMessage{
+		StartHash:               startHash,
+		IncludeBlockVerboseData: includeBlockVerboseData,
+	}
+}
+
+// GetChainFromBlockResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetChainFromBlockResponseMessage struct {
+	baseMessage
+	RemovedChainBlockHashes []string
+	AddedChainBlocks        []*ChainBlock
+	BlockVerboseData        []*BlockVerboseData
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetChainFromBlockResponseMessage) Command() MessageCommand {
+	return CmdGetChainFromBlockResponseMessage
+}
+
+// NewGetChainFromBlockResponseMessage returns a instance of the message
+func NewGetChainFromBlockResponseMessage(removedChainBlockHashes []string,
+	addedChainBlocks []*ChainBlock, blockVerboseData []*BlockVerboseData) *GetChainFromBlockResponseMessage {
+
+	return &GetChainFromBlockResponseMessage{
+		RemovedChainBlockHashes: removedChainBlockHashes,
+		AddedChainBlocks:        addedChainBlocks,
+		BlockVerboseData:        blockVerboseData,
+	}
+}
--- a/app/appmessage/rpc_get_connected_peer_info.go
+++ b/app/appmessage/rpc_get_connected_peer_info.go
@@ -0,0 +1,51 @@
+package appmessage
+
+// GetConnectedPeerInfoRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetConnectedPeerInfoRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetConnectedPeerInfoRequestMessage) Command() MessageCommand {
+	return CmdGetConnectedPeerInfoRequestMessage
+}
+
+// NewGetConnectedPeerInfoRequestMessage returns a instance of the message
+func NewGetConnectedPeerInfoRequestMessage() *GetConnectedPeerInfoRequestMessage {
+	return &GetConnectedPeerInfoRequestMessage{}
+}
+
+// GetConnectedPeerInfoResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetConnectedPeerInfoResponseMessage struct {
+	baseMessage
+	Infos []*GetConnectedPeerInfoMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetConnectedPeerInfoResponseMessage) Command() MessageCommand {
+	return CmdGetConnectedPeerInfoResponseMessage
+}
+
+// NewGetConnectedPeerInfoResponseMessage returns a instance of the message
+func NewGetConnectedPeerInfoResponseMessage(infos []*GetConnectedPeerInfoMessage) *GetConnectedPeerInfoResponseMessage {
+	return &GetConnectedPeerInfoResponseMessage{
+		Infos: infos,
+	}
+}
+
+// GetConnectedPeerInfoMessage holds information about a connected peer
+type GetConnectedPeerInfoMessage struct {
+	ID                        string
+	Address                   string
+	LastPingDuration          int64
+	SelectedTipHash           string
+	IsSyncNode                bool
+	IsOutbound                bool
+	TimeOffset                int64
+	UserAgent                 string
+	AdvertisedProtocolVersion uint32
+	TimeConnected             int64
+}
--- a/app/appmessage/rpc_get_current_network.go
+++ b/app/appmessage/rpc_get_current_network.go
@@ -0,0 +1,38 @@
+package appmessage
+
+// GetCurrentNetworkRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetCurrentNetworkRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetCurrentNetworkRequestMessage) Command() MessageCommand {
+	return CmdGetCurrentNetworkRequestMessage
+}
+
+// NewGetCurrentNetworkRequestMessage returns a instance of the message
+func NewGetCurrentNetworkRequestMessage() *GetCurrentNetworkRequestMessage {
+	return &GetCurrentNetworkRequestMessage{}
+}
+
+// GetCurrentNetworkResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetCurrentNetworkResponseMessage struct {
+	baseMessage
+	CurrentNetwork string
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetCurrentNetworkResponseMessage) Command() MessageCommand {
+	return CmdGetCurrentNetworkResponseMessage
+}
+
+// NewGetCurrentNetworkResponseMessage returns a instance of the message
+func NewGetCurrentNetworkResponseMessage(currentNetwork string) *GetCurrentNetworkResponseMessage {
+	return &GetCurrentNetworkResponseMessage{
+		CurrentNetwork: currentNetwork,
+	}
+}
--- a/app/appmessage/rpc_get_mempool_entry.go
+++ b/app/appmessage/rpc_get_mempool_entry.go
@@ -0,0 +1,35 @@
+package appmessage
+
+// GetMempoolEntryRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetMempoolEntryRequestMessage struct {
+	baseMessage
+	TxID string
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetMempoolEntryRequestMessage) Command() MessageCommand {
+	return CmdGetMempoolEntryRequestMessage
+}
+
+// NewGetMempoolEntryRequestMessage returns a instance of the message
+func NewGetMempoolEntryRequestMessage(txID string) *GetMempoolEntryRequestMessage {
+	return &GetMempoolEntryRequestMessage{TxID: txID}
+}
+
+// GetMempoolEntryResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetMempoolEntryResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetMempoolEntryResponseMessage) Command() MessageCommand {
+	return CmdGetMempoolEntryResponseMessage
+}
+
+// NewGetMempoolEntryResponseMessage returns a instance of the message
+func NewGetMempoolEntryResponseMessage() *GetMempoolEntryResponseMessage {
+	return &GetMempoolEntryResponseMessage{}
+}
--- a/app/appmessage/rpc_get_peer_addresses.go
+++ b/app/appmessage/rpc_get_peer_addresses.go
@@ -0,0 +1,44 @@
+package appmessage
+
+// GetPeerAddressesRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetPeerAddressesRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetPeerAddressesRequestMessage) Command() MessageCommand {
+	return CmdGetPeerAddressesRequestMessage
+}
+
+// NewGetPeerAddressesRequestMessage returns a instance of the message
+func NewGetPeerAddressesRequestMessage() *GetPeerAddressesRequestMessage {
+	return &GetPeerAddressesRequestMessage{}
+}
+
+// GetPeerAddressesResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetPeerAddressesResponseMessage struct {
+	baseMessage
+	Addresses []*GetPeerAddressesKnownAddressMessage
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetPeerAddressesResponseMessage) Command() MessageCommand {
+	return CmdGetPeerAddressesResponseMessage
+}
+
+// NewGetPeerAddressesResponseMessage returns a instance of the message
+func NewGetPeerAddressesResponseMessage(addresses []*GetPeerAddressesKnownAddressMessage) *GetPeerAddressesResponseMessage {
+	return &GetPeerAddressesResponseMessage{
+		Addresses: addresses,
+	}
+}
+
+// GetPeerAddressesKnownAddressMessage is an appmessage corresponding to
+// its respective RPC message
+type GetPeerAddressesKnownAddressMessage struct {
+	Addr string
+}
--- a/app/appmessage/rpc_get_selected_tip_hash.go
+++ b/app/appmessage/rpc_get_selected_tip_hash.go
@@ -0,0 +1,38 @@
+package appmessage
+
+// GetSelectedTipHashRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetSelectedTipHashRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetSelectedTipHashRequestMessage) Command() MessageCommand {
+	return CmdGetSelectedTipHashRequestMessage
+}
+
+// NewGetSelectedTipHashRequestMessage returns a instance of the message
+func NewGetSelectedTipHashRequestMessage() *GetSelectedTipHashRequestMessage {
+	return &GetSelectedTipHashRequestMessage{}
+}
+
+// GetSelectedTipHashResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetSelectedTipHashResponseMessage struct {
+	baseMessage
+	SelectedTipHash string
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetSelectedTipHashResponseMessage) Command() MessageCommand {
+	return CmdGetSelectedTipHashResponseMessage
+}
+
+// NewGetSelectedTipHashResponseMessage returns a instance of the message
+func NewGetSelectedTipHashResponseMessage(selectedTipHash string) *GetSelectedTipHashResponseMessage {
+	return &GetSelectedTipHashResponseMessage{
+		SelectedTipHash: selectedTipHash,
+	}
+}
--- a/app/appmessage/rpc_get_subnetwork.go
+++ b/app/appmessage/rpc_get_subnetwork.go
@@ -0,0 +1,41 @@
+package appmessage
+
+// GetSubnetworkRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetSubnetworkRequestMessage struct {
+	baseMessage
+	SubnetworkID string
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetSubnetworkRequestMessage) Command() MessageCommand {
+	return CmdGetSubnetworkRequestMessage
+}
+
+// NewGetSubnetworkRequestMessage returns a instance of the message
+func NewGetSubnetworkRequestMessage(subnetworkID string) *GetSubnetworkRequestMessage {
+	return &GetSubnetworkRequestMessage{
+		SubnetworkID: subnetworkID,
+	}
+}
+
+// GetSubnetworkResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetSubnetworkResponseMessage struct {
+	baseMessage
+	GasLimit uint64
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetSubnetworkResponseMessage) Command() MessageCommand {
+	return CmdGetSubnetworkResponseMessage
+}
+
+// NewGetSubnetworkResponseMessage returns a instance of the message
+func NewGetSubnetworkResponseMessage(gasLimit uint64) *GetSubnetworkResponseMessage {
+	return &GetSubnetworkResponseMessage{
+		GasLimit: gasLimit,
+	}
+}
--- a/app/appmessage/rpc_notify_block_added.go
+++ b/app/appmessage/rpc_notify_block_added.go
@@ -0,0 +1,53 @@
+package appmessage
+
+// NotifyBlockAddedRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyBlockAddedRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyBlockAddedRequestMessage) Command() MessageCommand {
+	return CmdNotifyBlockAddedRequestMessage
+}
+
+// NewNotifyBlockAddedRequestMessage returns a instance of the message
+func NewNotifyBlockAddedRequestMessage() *NotifyBlockAddedRequestMessage {
+	return &NotifyBlockAddedRequestMessage{}
+}
+
+// NotifyBlockAddedResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyBlockAddedResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyBlockAddedResponseMessage) Command() MessageCommand {
+	return CmdNotifyBlockAddedResponseMessage
+}
+
+// NewNotifyBlockAddedResponseMessage returns a instance of the message
+func NewNotifyBlockAddedResponseMessage() *NotifyBlockAddedResponseMessage {
+	return &NotifyBlockAddedResponseMessage{}
+}
+
+// BlockAddedNotificationMessage is an appmessage corresponding to
+// its respective RPC message
+type BlockAddedNotificationMessage struct {
+	baseMessage
+	Block *MsgBlock
+}
+
+// Command returns the protocol command string for the message
+func (msg *BlockAddedNotificationMessage) Command() MessageCommand {
+	return CmdBlockAddedNotificationMessage
+}
+
+// NewBlockAddedNotificationMessage returns a instance of the message
+func NewBlockAddedNotificationMessage(block *MsgBlock) *BlockAddedNotificationMessage {
+	return &BlockAddedNotificationMessage{
+		Block: block,
+	}
+}
--- a/app/appmessage/rpc_notify_chain_changed.go
+++ b/app/appmessage/rpc_notify_chain_changed.go
@@ -0,0 +1,69 @@
+package appmessage
+
+// NotifyChainChangedRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyChainChangedRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyChainChangedRequestMessage) Command() MessageCommand {
+	return CmdNotifyChainChangedRequestMessage
+}
+
+// NewNotifyChainChangedRequestMessage returns a instance of the message
+func NewNotifyChainChangedRequestMessage() *NotifyChainChangedRequestMessage {
+	return &NotifyChainChangedRequestMessage{}
+}
+
+// NotifyChainChangedResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyChainChangedResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyChainChangedResponseMessage) Command() MessageCommand {
+	return CmdNotifyChainChangedResponseMessage
+}
+
+// NewNotifyChainChangedResponseMessage returns a instance of the message
+func NewNotifyChainChangedResponseMessage() *NotifyChainChangedResponseMessage {
+	return &NotifyChainChangedResponseMessage{}
+}
+
+// ChainChangedNotificationMessage is an appmessage corresponding to
+// its respective RPC message
+type ChainChangedNotificationMessage struct {
+	baseMessage
+	RemovedChainBlockHashes []string
+	AddedChainBlocks        []*ChainBlock
+}
+
+// ChainBlock represents a DAG chain-block
+type ChainBlock struct {
+	Hash           string
+	AcceptedBlocks []*AcceptedBlock
+}
+
+// AcceptedBlock represents a block accepted into the DAG
+type AcceptedBlock struct {
+	Hash          string
+	AcceptedTxIDs []string
+}
+
+// Command returns the protocol command string for the message
+func (msg *ChainChangedNotificationMessage) Command() MessageCommand {
+	return CmdChainChangedNotificationMessage
+}
+
+// NewChainChangedNotificationMessage returns a instance of the message
+func NewChainChangedNotificationMessage(removedChainBlockHashes []string,
+	addedChainBlocks []*ChainBlock) *ChainChangedNotificationMessage {
+
+	return &ChainChangedNotificationMessage{
+		RemovedChainBlockHashes: removedChainBlockHashes,
+		AddedChainBlocks:        addedChainBlocks,
+	}
+}
--- a/app/appmessage/rpc_notify_finality_conflicts.go
+++ b/app/appmessage/rpc_notify_finality_conflicts.go
@@ -0,0 +1,72 @@
+package appmessage
+
+// NotifyFinalityConflictsRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyFinalityConflictsRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyFinalityConflictsRequestMessage) Command() MessageCommand {
+	return CmdNotifyFinalityConflictsRequestMessage
+}
+
+// NewNotifyFinalityConflictsRequestMessage returns a instance of the message
+func NewNotifyFinalityConflictsRequestMessage() *NotifyFinalityConflictsRequestMessage {
+	return &NotifyFinalityConflictsRequestMessage{}
+}
+
+// NotifyFinalityConflictsResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type NotifyFinalityConflictsResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *NotifyFinalityConflictsResponseMessage) Command() MessageCommand {
+	return CmdNotifyFinalityConflictsResponseMessage
+}
+
+// NewNotifyFinalityConflictsResponseMessage returns a instance of the message
+func NewNotifyFinalityConflictsResponseMessage() *NotifyFinalityConflictsResponseMessage {
+	return &NotifyFinalityConflictsResponseMessage{}
+}
+
+// FinalityConflictNotificationMessage is an appmessage corresponding to
+// its respective RPC message
+type FinalityConflictNotificationMessage struct {
+	baseMessage
+	ViolatingBlockHash string
+}
+
+// Command returns the protocol command string for the message
+func (msg *FinalityConflictNotificationMessage) Command() MessageCommand {
+	return CmdFinalityConflictNotificationMessage
+}
+
+// NewFinalityConflictNotificationMessage returns a instance of the message
+func NewFinalityConflictNotificationMessage(violatingBlockHash string) *FinalityConflictNotificationMessage {
+	return &FinalityConflictNotificationMessage{
+		ViolatingBlockHash: violatingBlockHash,
+	}
+}
+
+// FinalityConflictResolvedNotificationMessage is an appmessage corresponding to
+// its respective RPC message
+type FinalityConflictResolvedNotificationMessage struct {
+	baseMessage
+	FinalityBlockHash string
+}
+
+// Command returns the protocol command string for the message
+func (msg *FinalityConflictResolvedNotificationMessage) Command() MessageCommand {
+	return CmdFinalityConflictResolvedNotificationMessage
+}
+
+// NewFinalityConflictResolvedNotificationMessage returns a instance of the message
+func NewFinalityConflictResolvedNotificationMessage(finalityBlockHash string) *FinalityConflictResolvedNotificationMessage {
+	return &FinalityConflictResolvedNotificationMessage{
+		FinalityBlockHash: finalityBlockHash,
+	}
+}
--- a/app/appmessage/rpc_resolve_finality_conflict.go
+++ b/app/appmessage/rpc_resolve_finality_conflict.go
@@ -0,0 +1,37 @@
+package appmessage
+
+// ResolveFinalityConflictRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type ResolveFinalityConflictRequestMessage struct {
+	baseMessage
+	FinalityBlockHash string
+}
+
+// Command returns the protocol command string for the message
+func (msg *ResolveFinalityConflictRequestMessage) Command() MessageCommand {
+	return CmdResolveFinalityConflictRequestMessage
+}
+
+// NewResolveFinalityConflictRequestMessage returns a instance of the message
+func NewResolveFinalityConflictRequestMessage(finalityBlockHash string) *ResolveFinalityConflictRequestMessage {
+	return &ResolveFinalityConflictRequestMessage{
+		FinalityBlockHash: finalityBlockHash,
+	}
+}
+
+// ResolveFinalityConflictResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type ResolveFinalityConflictResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *ResolveFinalityConflictResponseMessage) Command() MessageCommand {
+	return CmdResolveFinalityConflictResponseMessage
+}
+
+// NewResolveFinalityConflictResponseMessage returns a instance of the message
+func NewResolveFinalityConflictResponseMessage() *ResolveFinalityConflictResponseMessage {
+	return &ResolveFinalityConflictResponseMessage{}
+}
--- a/app/appmessage/rpc_submit_block.go
+++ b/app/appmessage/rpc_submit_block.go
@@ -0,0 +1,37 @@
+package appmessage
+
+// SubmitBlockRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type SubmitBlockRequestMessage struct {
+	baseMessage
+	BlockHex string
+}
+
+// Command returns the protocol command string for the message
+func (msg *SubmitBlockRequestMessage) Command() MessageCommand {
+	return CmdSubmitBlockRequestMessage
+}
+
+// NewSubmitBlockRequestMessage returns a instance of the message
+func NewSubmitBlockRequestMessage(blockHex string) *SubmitBlockRequestMessage {
+	return &SubmitBlockRequestMessage{
+		BlockHex: blockHex,
+	}
+}
+
+// SubmitBlockResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type SubmitBlockResponseMessage struct {
+	baseMessage
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *SubmitBlockResponseMessage) Command() MessageCommand {
+	return CmdSubmitBlockResponseMessage
+}
+
+// NewSubmitBlockResponseMessage returns a instance of the message
+func NewSubmitBlockResponseMessage() *SubmitBlockResponseMessage {
+	return &SubmitBlockResponseMessage{}
+}
--- a/app/appmessage/rpc_submit_transaction.go
+++ b/app/appmessage/rpc_submit_transaction.go
@@ -0,0 +1,41 @@
+package appmessage
+
+// SubmitTransactionRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type SubmitTransactionRequestMessage struct {
+	baseMessage
+	TransactionHex string
+}
+
+// Command returns the protocol command string for the message
+func (msg *SubmitTransactionRequestMessage) Command() MessageCommand {
+	return CmdSubmitTransactionRequestMessage
+}
+
+// NewSubmitTransactionRequestMessage returns a instance of the message
+func NewSubmitTransactionRequestMessage(transactionHex string) *SubmitTransactionRequestMessage {
+	return &SubmitTransactionRequestMessage{
+		TransactionHex: transactionHex,
+	}
+}
+
+// SubmitTransactionResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type SubmitTransactionResponseMessage struct {
+	baseMessage
+	TxID string
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *SubmitTransactionResponseMessage) Command() MessageCommand {
+	return CmdSubmitTransactionResponseMessage
+}
+
+// NewSubmitTransactionResponseMessage returns a instance of the message
+func NewSubmitTransactionResponseMessage(txID string) *SubmitTransactionResponseMessage {
+	return &SubmitTransactionResponseMessage{
+		TxID: txID,
+	}
+}
--- a/app/appmessage/testdata/megatx.bin.bz2
+++ b/app/appmessage/testdata/megatx.bin.bz2
--- a/app/log.go
+++ b/app/log.go
@@ -0,0 +1,14 @@
+// Copyright (c) 2013-2017 The btcsuite developers
+// Copyright (c) 2017 The Decred developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package app
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/panics"
+)
+
+var log, _ = logger.Get(logger.SubsystemTags.KASD)
+var spawn = panics.GoroutineWrapperFunc(log)
--- a/app/protocol/blocklogger/blocklogger.go
+++ b/app/protocol/blocklogger/blocklogger.go
@@ -0,0 +1,64 @@
+// Copyright (c) 2015-2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blocklogger
+
+import (
+	"github.com/kaspanet/kaspad/util/mstime"
+	"sync"
+	"time"
+
+	"github.com/kaspanet/kaspad/util"
+)
+
+var (
+	receivedLogBlocks int64
+	receivedLogTx     int64
+	lastBlockLogTime  = mstime.Now()
+	mtx               sync.Mutex
+)
+
+// LogBlock logs a new block blue score as an information message
+// to show progress to the user. In order to prevent spam, it limits logging to
+// one message every 10 seconds with duration and totals included.
+func LogBlock(block *util.Block) error {
+	mtx.Lock()
+	defer mtx.Unlock()
+
+	receivedLogBlocks++
+	receivedLogTx += int64(len(block.MsgBlock().Transactions))
+
+	now := mstime.Now()
+	duration := now.Sub(lastBlockLogTime)
+	if duration < time.Second*10 {
+		return nil
+	}
+
+	// Truncate the duration to 10s of milliseconds.
+	tDuration := duration.Round(10 * time.Millisecond)
+
+	// Log information about new block blue score.
+	blockStr := "blocks"
+	if receivedLogBlocks == 1 {
+		blockStr = "block"
+	}
+	txStr := "transactions"
+	if receivedLogTx == 1 {
+		txStr = "transaction"
+	}
+
+	blueScore, err := block.BlueScore()
+	if err != nil {
+		return err
+	}
+
+	log.Infof("Processed %d %s in the last %s (%d %s, blue score %d, %s)",
+		receivedLogBlocks, blockStr, tDuration, receivedLogTx,
+		txStr, blueScore, block.MsgBlock().Header.Timestamp)
+
+	receivedLogBlocks = 0
+	receivedLogTx = 0
+	lastBlockLogTime = now
+	return nil
+}
--- a/app/protocol/blocklogger/log.go
+++ b/app/protocol/blocklogger/log.go
@@ -0,0 +1,11 @@
+// Copyright (c) 2017 The btcsuite developers
+// Use of this source code is governed by an ISC
+// license that can be found in the LICENSE file.
+
+package blocklogger
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+)
+
+var log, _ = logger.Get(logger.SubsystemTags.PROT)
--- a/app/protocol/common/common.go
+++ b/app/protocol/common/common.go
@@ -0,0 +1,14 @@
+package common
+
+import (
+	"time"
+
+	"github.com/pkg/errors"
+)
+
+// DefaultTimeout is the default duration to wait for enqueuing/dequeuing
+// to/from routes.
+const DefaultTimeout = 30 * time.Second
+
+// ErrPeerWithSameIDExists signifies that a peer with the same ID already exist.
+var ErrPeerWithSameIDExists = errors.New("ready peer with the same ID already exists")
--- a/app/protocol/flowcontext/addresses.go
+++ b/app/protocol/flowcontext/addresses.go
@@ -0,0 +1,10 @@
+package flowcontext
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+)
+
+// AddressManager returns the address manager associated to the flow context.
+func (f *FlowContext) AddressManager() *addressmanager.AddressManager {
+	return f.addressManager
+}
--- a/app/protocol/flowcontext/blocks.go
+++ b/app/protocol/flowcontext/blocks.go
@@ -0,0 +1,77 @@
+package flowcontext
+
+import (
+	"sync/atomic"
+
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// OnNewBlock updates the mempool after a new block arrival, and
+// relays newly unorphaned transactions and possibly rebroadcast
+// manually added transactions when not in IBD.
+func (f *FlowContext) OnNewBlock(block *util.Block) error {
+	transactionsAcceptedToMempool, err := f.txPool.HandleNewBlock(block)
+	if err != nil {
+		return err
+	}
+	if f.onBlockAddedToDAGHandler != nil {
+		f.onBlockAddedToDAGHandler(block)
+	}
+
+	return f.broadcastTransactionsAfterBlockAdded(block, transactionsAcceptedToMempool)
+}
+
+func (f *FlowContext) broadcastTransactionsAfterBlockAdded(block *util.Block, transactionsAcceptedToMempool []*util.Tx) error {
+	f.updateTransactionsToRebroadcast(block)
+
+	// Don't relay transactions when in IBD.
+	if atomic.LoadUint32(&f.isInIBD) != 0 {
+		return nil
+	}
+
+	var txIDsToRebroadcast []*daghash.TxID
+	if f.shouldRebroadcastTransactions() {
+		txIDsToRebroadcast = f.txIDsToRebroadcast()
+	}
+
+	txIDsToBroadcast := make([]*daghash.TxID, len(transactionsAcceptedToMempool)+len(txIDsToRebroadcast))
+	for i, tx := range transactionsAcceptedToMempool {
+		txIDsToBroadcast[i] = tx.ID()
+	}
+	offset := len(transactionsAcceptedToMempool)
+	for i, txID := range txIDsToRebroadcast {
+		txIDsToBroadcast[offset+i] = txID
+	}
+
+	if len(txIDsToBroadcast) == 0 {
+		return nil
+	}
+	if len(txIDsToBroadcast) > appmessage.MaxInvPerTxInvMsg {
+		txIDsToBroadcast = txIDsToBroadcast[:appmessage.MaxInvPerTxInvMsg]
+	}
+	inv := appmessage.NewMsgInvTransaction(txIDsToBroadcast)
+	return f.Broadcast(inv)
+}
+
+// SharedRequestedBlocks returns a *blockrelay.SharedRequestedBlocks for sharing
+// data about requested blocks between different peers.
+func (f *FlowContext) SharedRequestedBlocks() *blockrelay.SharedRequestedBlocks {
+	return f.sharedRequestedBlocks
+}
+
+// AddBlock adds the given block to the DAG and propagates it.
+func (f *FlowContext) AddBlock(block *util.Block, flags blockdag.BehaviorFlags) error {
+	_, _, err := f.DAG().ProcessBlock(block, flags)
+	if err != nil {
+		return err
+	}
+	err = f.OnNewBlock(block)
+	if err != nil {
+		return err
+	}
+	return f.Broadcast(appmessage.NewMsgInvBlock(block.Hash()))
+}
--- a/app/protocol/flowcontext/config.go
+++ b/app/protocol/flowcontext/config.go
@@ -0,0 +1,8 @@
+package flowcontext
+
+import "github.com/kaspanet/kaspad/infrastructure/config"
+
+// Config returns an instance of *config.Config associated to the flow context.
+func (f *FlowContext) Config() *config.Config {
+	return f.cfg
+}
--- a/app/protocol/flowcontext/consensus.go
+++ b/app/protocol/flowcontext/consensus.go
@@ -0,0 +1,8 @@
+package flowcontext
+
+import "github.com/kaspanet/kaspad/domain/blockdag"
+
+// DAG returns the DAG associated to the flow context.
+func (f *FlowContext) DAG() *blockdag.BlockDAG {
+	return f.dag
+}
--- a/app/protocol/flowcontext/errors.go
+++ b/app/protocol/flowcontext/errors.go
@@ -0,0 +1,31 @@
+package flowcontext
+
+import (
+	"errors"
+	"sync/atomic"
+
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+)
+
+// HandleError handles an error from a flow,
+// It sends the error to errChan if isStopping == 0 and increments isStopping
+//
+// If this is ErrRouteClosed - forward it to errChan
+// If this is ProtocolError - logs the error, and forward it to errChan
+// Otherwise - panics
+func (*FlowContext) HandleError(err error, flowName string, isStopping *uint32, errChan chan<- error) {
+	isErrRouteClosed := errors.Is(err, router.ErrRouteClosed)
+	if !isErrRouteClosed {
+		if protocolErr := &(protocolerrors.ProtocolError{}); !errors.As(err, &protocolErr) {
+			panic(err)
+		}
+
+		log.Errorf("error from %s: %+v", flowName, err)
+	}
+
+	if atomic.AddUint32(isStopping, 1) == 1 {
+		errChan <- err
+	}
+}
--- a/app/protocol/flowcontext/flow_context.go
+++ b/app/protocol/flowcontext/flow_context.go
@@ -0,0 +1,84 @@
+package flowcontext
+
+import (
+	"sync"
+	"time"
+
+	"github.com/kaspanet/kaspad/app/protocol/flows/blockrelay"
+	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/domain/mempool"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+)
+
+// OnBlockAddedToDAGHandler is a handler function that's triggered
+// when a block is added to the DAG
+type OnBlockAddedToDAGHandler func(block *util.Block)
+
+// OnTransactionAddedToMempoolHandler is a handler function that's triggered
+// when a transaction is added to the mempool
+type OnTransactionAddedToMempoolHandler func()
+
+// FlowContext holds state that is relevant to more than one flow or one peer, and allows communication between
+// different flows that can be associated to different peers.
+type FlowContext struct {
+	cfg               *config.Config
+	netAdapter        *netadapter.NetAdapter
+	txPool            *mempool.TxPool
+	dag               *blockdag.BlockDAG
+	addressManager    *addressmanager.AddressManager
+	connectionManager *connmanager.ConnectionManager
+
+	onBlockAddedToDAGHandler           OnBlockAddedToDAGHandler
+	onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler
+
+	transactionsToRebroadcastLock sync.Mutex
+	transactionsToRebroadcast     map[daghash.TxID]*util.Tx
+	lastRebroadcastTime           time.Time
+	sharedRequestedTransactions   *relaytransactions.SharedRequestedTransactions
+
+	sharedRequestedBlocks *blockrelay.SharedRequestedBlocks
+
+	isInIBD       uint32
+	startIBDMutex sync.Mutex
+	ibdPeer       *peerpkg.Peer
+
+	peers      map[id.ID]*peerpkg.Peer
+	peersMutex sync.RWMutex
+}
+
+// New returns a new instance of FlowContext.
+func New(cfg *config.Config, dag *blockdag.BlockDAG, addressManager *addressmanager.AddressManager,
+	txPool *mempool.TxPool, netAdapter *netadapter.NetAdapter,
+	connectionManager *connmanager.ConnectionManager) *FlowContext {
+
+	return &FlowContext{
+		cfg:                         cfg,
+		netAdapter:                  netAdapter,
+		dag:                         dag,
+		addressManager:              addressManager,
+		connectionManager:           connectionManager,
+		txPool:                      txPool,
+		sharedRequestedTransactions: relaytransactions.NewSharedRequestedTransactions(),
+		sharedRequestedBlocks:       blockrelay.NewSharedRequestedBlocks(),
+		peers:                       make(map[id.ID]*peerpkg.Peer),
+		transactionsToRebroadcast:   make(map[daghash.TxID]*util.Tx),
+	}
+}
+
+// SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
+func (f *FlowContext) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler OnBlockAddedToDAGHandler) {
+	f.onBlockAddedToDAGHandler = onBlockAddedToDAGHandler
+}
+
+// SetOnTransactionAddedToMempoolHandler sets the onTransactionAddedToMempool handler
+func (f *FlowContext) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler OnTransactionAddedToMempoolHandler) {
+	f.onTransactionAddedToMempoolHandler = onTransactionAddedToMempoolHandler
+}
--- a/app/protocol/flowcontext/ibd.go
+++ b/app/protocol/flowcontext/ibd.go
@@ -0,0 +1,89 @@
+package flowcontext
+
+import (
+	"sync/atomic"
+	"time"
+
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+)
+
+// StartIBDIfRequired selects a peer and starts IBD against it
+// if required
+func (f *FlowContext) StartIBDIfRequired() {
+	f.startIBDMutex.Lock()
+	defer f.startIBDMutex.Unlock()
+
+	if f.IsInIBD() {
+		return
+	}
+
+	peer := f.selectPeerForIBD(f.dag)
+	if peer == nil {
+		spawn("StartIBDIfRequired-requestSelectedTipsIfRequired", f.requestSelectedTipsIfRequired)
+		return
+	}
+
+	atomic.StoreUint32(&f.isInIBD, 1)
+	f.ibdPeer = peer
+	spawn("StartIBDIfRequired-peer.StartIBD", peer.StartIBD)
+}
+
+// IsInIBD is true if IBD is currently running
+func (f *FlowContext) IsInIBD() bool {
+	return atomic.LoadUint32(&f.isInIBD) != 0
+}
+
+// selectPeerForIBD returns the first peer whose selected tip
+// hash is not in our DAG
+func (f *FlowContext) selectPeerForIBD(dag *blockdag.BlockDAG) *peerpkg.Peer {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	for _, peer := range f.peers {
+		peerSelectedTipHash := peer.SelectedTipHash()
+		if !dag.IsInDAG(peerSelectedTipHash) {
+			return peer
+		}
+	}
+	return nil
+}
+
+func (f *FlowContext) requestSelectedTipsIfRequired() {
+	if f.isDAGTimeCurrent() {
+		return
+	}
+	f.requestSelectedTips()
+}
+
+func (f *FlowContext) isDAGTimeCurrent() bool {
+	const minDurationToRequestSelectedTips = time.Minute
+	return f.dag.Now().Sub(f.dag.SelectedTipHeader().Timestamp) > minDurationToRequestSelectedTips
+}
+
+func (f *FlowContext) requestSelectedTips() {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	for _, peer := range f.peers {
+		peer.RequestSelectedTipIfRequired()
+	}
+}
+
+// FinishIBD finishes the current IBD flow and starts a new one if required.
+func (f *FlowContext) FinishIBD() {
+	f.ibdPeer = nil
+
+	atomic.StoreUint32(&f.isInIBD, 0)
+
+	f.StartIBDIfRequired()
+}
+
+// IBDPeer returns the currently active IBD peer.
+// Returns nil if we aren't currently in IBD
+func (f *FlowContext) IBDPeer() *peerpkg.Peer {
+	if !f.IsInIBD() {
+		return nil
+	}
+	return f.ibdPeer
+}
--- a/app/protocol/flowcontext/log.go
+++ b/app/protocol/flowcontext/log.go
@@ -0,0 +1,9 @@
+package flowcontext
+
+import (
+	"github.com/kaspanet/kaspad/infrastructure/logger"
+	"github.com/kaspanet/kaspad/util/panics"
+)
+
+var log, _ = logger.Get(logger.SubsystemTags.PROT)
+var spawn = panics.GoroutineWrapperFunc(log)
--- a/app/protocol/flowcontext/network.go
+++ b/app/protocol/flowcontext/network.go
@@ -0,0 +1,74 @@
+package flowcontext
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/pkg/errors"
+)
+
+// NetAdapter returns the net adapter that is associated to the flow context.
+func (f *FlowContext) NetAdapter() *netadapter.NetAdapter {
+	return f.netAdapter
+}
+
+// ConnectionManager returns the connection manager that is associated to the flow context.
+func (f *FlowContext) ConnectionManager() *connmanager.ConnectionManager {
+	return f.connectionManager
+}
+
+// AddToPeers marks this peer as ready and adds it to the ready peers list.
+func (f *FlowContext) AddToPeers(peer *peerpkg.Peer) error {
+	f.peersMutex.Lock()
+	defer f.peersMutex.Unlock()
+
+	if _, ok := f.peers[*peer.ID()]; ok {
+		return errors.Wrapf(common.ErrPeerWithSameIDExists, "peer with ID %s already exists", peer.ID())
+	}
+
+	f.peers[*peer.ID()] = peer
+
+	return nil
+}
+
+// RemoveFromPeers remove this peer from the peers list.
+func (f *FlowContext) RemoveFromPeers(peer *peerpkg.Peer) {
+	f.peersMutex.Lock()
+	defer f.peersMutex.Unlock()
+
+	delete(f.peers, *peer.ID())
+}
+
+// readyPeerConnections returns the NetConnections of all the ready peers.
+func (f *FlowContext) readyPeerConnections() []*netadapter.NetConnection {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+	peerConnections := make([]*netadapter.NetConnection, len(f.peers))
+	i := 0
+	for _, peer := range f.peers {
+		peerConnections[i] = peer.Connection()
+		i++
+	}
+	return peerConnections
+}
+
+// Broadcast broadcast the given message to all the ready peers.
+func (f *FlowContext) Broadcast(message appmessage.Message) error {
+	return f.netAdapter.P2PBroadcast(f.readyPeerConnections(), message)
+}
+
+// Peers returns the currently active peers
+func (f *FlowContext) Peers() []*peerpkg.Peer {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+
+	peers := make([]*peerpkg.Peer, len(f.peers))
+	i := 0
+	for _, peer := range f.peers {
+		peers[i] = peer
+		i++
+	}
+	return peers
+}
--- a/app/protocol/flowcontext/transactions.go
+++ b/app/protocol/flowcontext/transactions.go
@@ -0,0 +1,78 @@
+package flowcontext
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/flows/relaytransactions"
+	"github.com/kaspanet/kaspad/domain/mempool"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/pkg/errors"
+	"time"
+)
+
+// AddTransaction adds transaction to the mempool and propagates it.
+func (f *FlowContext) AddTransaction(tx *util.Tx) error {
+	f.transactionsToRebroadcastLock.Lock()
+	defer f.transactionsToRebroadcastLock.Unlock()
+
+	transactionsAcceptedToMempool, err := f.txPool.ProcessTransaction(tx, false)
+	if err != nil {
+		return err
+	}
+
+	if len(transactionsAcceptedToMempool) > 1 {
+		return errors.New("got more than one accepted transactions when no orphans were allowed")
+	}
+
+	f.transactionsToRebroadcast[*tx.ID()] = tx
+	inv := appmessage.NewMsgInvTransaction([]*daghash.TxID{tx.ID()})
+	return f.Broadcast(inv)
+}
+
+func (f *FlowContext) updateTransactionsToRebroadcast(block *util.Block) {
+	f.transactionsToRebroadcastLock.Lock()
+	defer f.transactionsToRebroadcastLock.Unlock()
+	// Note: if the block is red, its transactions won't be rebroadcasted
+	// anymore, although they are not included in the UTXO set.
+	// This is probably ok, since red blocks are quite rare.
+	for _, tx := range block.Transactions() {
+		delete(f.transactionsToRebroadcast, *tx.ID())
+	}
+}
+
+func (f *FlowContext) shouldRebroadcastTransactions() bool {
+	const rebroadcastInterval = 30 * time.Second
+	return time.Since(f.lastRebroadcastTime) > rebroadcastInterval
+}
+
+func (f *FlowContext) txIDsToRebroadcast() []*daghash.TxID {
+	f.transactionsToRebroadcastLock.Lock()
+	defer f.transactionsToRebroadcastLock.Unlock()
+
+	txIDs := make([]*daghash.TxID, len(f.transactionsToRebroadcast))
+	i := 0
+	for _, tx := range f.transactionsToRebroadcast {
+		txIDs[i] = tx.ID()
+		i++
+	}
+	return txIDs
+}
+
+// SharedRequestedTransactions returns a *relaytransactions.SharedRequestedTransactions for sharing
+// data about requested transactions between different peers.
+func (f *FlowContext) SharedRequestedTransactions() *relaytransactions.SharedRequestedTransactions {
+	return f.sharedRequestedTransactions
+}
+
+// TxPool returns the transaction pool associated to the manager.
+func (f *FlowContext) TxPool() *mempool.TxPool {
+	return f.txPool
+}
+
+// OnTransactionAddedToMempool notifies the handler function that a transaction
+// has been added to the mempool
+func (f *FlowContext) OnTransactionAddedToMempool() {
+	if f.onTransactionAddedToMempoolHandler != nil {
+		f.onTransactionAddedToMempoolHandler()
+	}
+}
--- a/Show More
+++ b/Show More