[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.

CHANGES

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

Jenkinsfile

@@ -1,10 +0,0 @@
-node {
-    stage 'Checkout'
-    checkout scm
-
-    stage 'Version'
-    sh './deploy.sh version'
-
-    stage 'Build'
-    sh "./deploy.sh build"
-}

LICENSE

@@ -3,6 +3,7 @@ ISC License
 Copyright (c) 2018-2019 The kaspanet developers
 Copyright (c) 2013-2018 The btcsuite developers
 Copyright (c) 2015-2016 The Decred developers
+Copyright (c) 2013-2014 Conformal Systems LLC.
 
 Permission to use, copy, modify, and distribute this software for any
 purpose with or without fee is hereby granted, provided that the above

README.md

@@ -4,7 +4,7 @@ Kaspad
 Warning: This is pre-alpha software. There's no guarantee anything works.
 ====
 
-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](https://choosealicense.com/licenses/isc/)
 [![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/kaspanet/kaspad)
 
 Kaspad is the reference full node Kaspa implementation written in Go (golang).
@@ -40,10 +40,8 @@ recommended that `GOPATH` is set to a directory in your home directory such as
 ```bash
 $ git clone https://github.com/kaspanet/kaspad $GOPATH/src/github.com/kaspanet/kaspad
 $ cd $GOPATH/src/github.com/kaspanet/kaspad
-$ ./test.sh
 $ go install . ./cmd/...
 ```
-`./test.sh` tests can be skipped, but some things might not run correctly on your system if tests fail.
 
 - 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,
@@ -75,5 +73,5 @@ The documentation is a work-in-progress. It is located in the [docs](https://git
 
 ## License
 
-Kaspad is licensed under the [copyfree](http://copyfree.org) ISC License.
+Kaspad is licensed under the copyfree [ISC License](https://choosealicense.com/licenses/isc/).
 

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

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/kaspanet/kaspad/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}
-}

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/kaspanet/kaspad/addrmgr"
-	"github.com/kaspanet/kaspad/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.")
-	}
-}

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)
-

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
+}

app/appmessage/README.md

@@ -1,7 +1,7 @@
 wire
 ====
 
-[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org)
+[![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](https://choosealicense.com/licenses/isc/)
 [![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/kaspanet/kaspad/wire)
 =======
 
@@ -32,11 +32,11 @@ to a remote node running a kaspa peer. Example syntax is:
 	// Use the most recent protocol version supported by the package and the
 	// main kaspa network.
 	pver := wire.ProtocolVersion
-	kaspanet := wire.MainNet
+	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 wire.Message, a []byte which contains the unmarshalled
+	// 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 {
@@ -57,7 +57,7 @@ from a remote peer is:
 	// Use the most recent protocol version supported by the package and the
 	// main bitcoin network.
 	pver := wire.ProtocolVersion
-	kaspanet := wire.MainNet
+	kaspanet := wire.Mainnet
 
 	// Create a new getaddr kaspa message.
 	msg := wire.NewMsgGetAddr()

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
+}

app/appmessage/bench_test.go

@@ -2,15 +2,13 @@
 // 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"
 
@@ -18,7 +16,7 @@ import (
 )
 
 // genesisCoinbaseTx is the coinbase transaction for the genesis blocks for
-// the main network, regression test network, and test network.
+// the main network and test network.
 var genesisCoinbaseTxIns = []*TxIn{
 	{
 		PreviousOutpoint: Outpoint{
@@ -354,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)
@@ -374,218 +372,6 @@ func BenchmarkWriteBlockHeader(b *testing.B) {
 	}
 }
 
-// BenchmarkDecodeGetHeaders performs a benchmark on how long it takes to
-// decode a getheaders message.
-func BenchmarkDecodeGetHeaders(b *testing.B) {
-	pver := ProtocolVersion
-	var m MsgGetHeaders
-	m.StartHash = &daghash.Hash{1}
-	m.StopHash = &daghash.Hash{1}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgGetHeaders.KaspaEncode: 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.KaspaDecode(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, hash, 0, uint64(i)))
-	}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgHeaders.KaspaEncode: 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.KaspaDecode(r, pver)
-	}
-}
-
-// BenchmarkDecodeGetBlockInvs performs a benchmark on how long it takes to
-// decode a getblockinvs message.
-func BenchmarkDecodeGetBlockInvs(b *testing.B) {
-	pver := ProtocolVersion
-	var m MsgGetBlockInvs
-	m.StartHash = &daghash.Hash{1}
-	m.StopHash = &daghash.Hash{1}
-
-	// Serialize it so the bytes are available to test the decode below.
-	var bb bytes.Buffer
-	if err := m.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgGetBlockInvs.KaspaEncode: unexpected error: %v", err)
-	}
-	buf := bb.Bytes()
-
-	r := bytes.NewReader(buf)
-	var msg MsgGetBlockInvs
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		r.Seek(0, 0)
-		msg.KaspaDecode(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.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgAddr.KaspaEncode: 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.KaspaDecode(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.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgInv.KaspaEncode: 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.KaspaDecode(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.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgNotFound.KaspaEncode: 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.KaspaDecode(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, 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.KaspaEncode(&bb, pver); err != nil {
-		b.Fatalf("MsgMerkleBlock.KaspaEncode: 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.KaspaDecode(r, pver)
-	}
-}
-
 // BenchmarkTxHash performs a benchmark on how long it takes to hash a
 // transaction.
 func BenchmarkTxHash(b *testing.B) {
@@ -625,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()
+	}
+}

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"
-	"io"
-	"math"
-	"time"
-
+	"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"
 )
 
 // 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,14 +163,6 @@ func ReadElement(r io.Reader, element interface{}) error {
 		*e = ServiceFlag(rv)
 		return nil
 
-	case *InvType:
-		rv, err := binaryserializer.Uint32(r, littleEndian)
-		if err != nil {
-			return err
-		}
-		*e = InvType(rv)
-		return nil
-
 	case *KaspaNet:
 		rv, err := binaryserializer.Uint32(r, littleEndian)
 		if err != nil {
@@ -159,27 +170,9 @@ func ReadElement(r io.Reader, element interface{}) error {
 		}
 		*e = KaspaNet(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)
-		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
@@ -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,38 +287,15 @@ func WriteElement(w io.Writer, element interface{}) error {
 		}
 		return nil
 
-	case InvType:
-		err := binaryserializer.PutUint32(w, littleEndian, uint32(e))
-		if err != nil {
-			return err
-		}
-		return nil
-
 	case KaspaNet:
 		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
@@ -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

app/appmessage/common_test.go

@@ -2,10 +2,11 @@
 // 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"
@@ -15,27 +16,27 @@ import (
 	"github.com/kaspanet/kaspad/util/daghash"
 )
 
-// mainNetGenesisHash is the hash of the first block in the block DAG for the
+// mainnetGenesisHash is the hash of the first block in the block DAG for the
 // main network (genesis block).
-var mainNetGenesisHash = &daghash.Hash{
+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 DAG for the
+// simnetGenesisHash is the hash of the first block in the block DAG for the
 // simulation test network.
-var simNetGenesisHash = &daghash.Hash{
+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{
+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,
@@ -56,15 +57,13 @@ var exampleUTXOCommitment = &daghash.Hash{
 	0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
 }
 
-// TestElementWire tests wire encode and decode for various element types. This
+// 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}},
@@ -89,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,
 			},
 		},
 		{
@@ -127,23 +122,14 @@ func TestElementWire(t *testing.T) {
 			[]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
 		},
 		{
-			InvType(InvTypeTx),
-			[]byte{0x01, 0x00, 0x00, 0x00},
-		},
-		{
-			KaspaNet(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 {
@@ -156,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 {
@@ -179,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
@@ -194,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,
 		},
 		{
@@ -217,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},
-		{KaspaNet(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
@@ -247,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
@@ -294,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
@@ -334,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
@@ -362,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},
@@ -394,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
@@ -410,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
@@ -445,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.
@@ -455,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
@@ -469,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 {
@@ -482,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 {
@@ -497,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.
@@ -507,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
@@ -524,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
@@ -552,8 +537,8 @@ 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},
@@ -564,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) {
@@ -576,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.
@@ -585,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
@@ -599,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 {
@@ -612,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")
@@ -628,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.
@@ -638,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
@@ -655,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
@@ -684,8 +669,8 @@ 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},
@@ -696,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")

app/appmessage/doc.go

@@ -1,12 +1,8 @@
-// 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 wire implements the kaspa wire protocol.
+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 wire. This package does not deal
+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.
 
@@ -23,7 +19,7 @@ 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
-wire using kaspa encoding are handled so the caller doesn't have to concern
+appmessage using kaspa encoding are handled so the caller doesn't have to concern
 themselves with the specifics.
 
 Message Interaction
@@ -41,20 +37,13 @@ interactions in no particular order.
 
 	Peer A Sends                            Peer B Responds
 	----------------------------------------------------------------------------
-	getaddr message (MsgGetAddr)            addr message (MsgAddr)
+	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)
-	getheaders message (MsgGetHeaders)      headers message (MsgHeaders)
-	ping message (MsgPing)                  pong message (MsgHeaders)* -or-
-	                                        (none -- Ability to send message is enough)
-
-	NOTES:
-	* The pong message was not added until later protocol versions as defined
-	  in BIP0031. The BIP0031Version constant can be used to detect a recent
-	  enough protocol version for this purpose (version > BIP0031Version).
+	ping message (MsgPing)                  pong message (MsgPong)
 
 Common Parameters
 
@@ -66,7 +55,7 @@ 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 wire.ProtocolVersion constant which indicates the
+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.
@@ -77,10 +66,10 @@ 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:
 
-	wire.MainNet
-	wire.RegTest  (Regression test network)
-	wire.TestNet (Test network)
-	wire.SimNet   (Simulation test network)
+    appmessage.Mainnet
+    appmessage.Testnet (Test network)
+    appmessage.Simnet  (Simulation test network)
+    appmessage.Devnet  (Development network)
 
 Determining Message Type
 
@@ -92,43 +81,43 @@ 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 *wire.MsgVersion:
+	case *appmessage.MsgVersion:
 		// The message is a pointer to a MsgVersion struct.
 		fmt.Printf("Protocol version: %d", msg.ProtocolVersion)
-	case *wire.MsgBlock:
+	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 wire, use the ReadMessage
+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 wire.Message, a []byte which contains the unmarshalled
+	// are a appmessage.Message, a []byte which contains the unmarshalled
 	// raw payload, and a possible error.
-	msg, rawPayload, err := wire.ReadMessage(conn, pver, kaspaNet)
+	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 wire, use the WriteMessage
+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 := wire.NewMsgGetAddr()
+	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 := wire.WriteMessage(conn, msg, pver, kaspaNet)
+	err := appmessage.WriteMessage(conn, msg, pver, kaspaNet)
 	if err != nil {
 		// Log and handle the error
 	}
@@ -137,8 +126,8 @@ 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 wire.MessageError. This allows the caller to
+io.ErrShortWrite, or of type appmessage.MessageError. This allows the caller to
 differentiate between general IO errors and malformed messages through type
 assertions.
 */
-package wire
+package appmessage

app/appmessage/error.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"
@@ -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...),
+	}
+}

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"

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)
+}

app/appmessage/p2p_blockheader.go

@@ -2,14 +2,15 @@
 // 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"
-	"io"
-	"time"
-
+	"fmt"
 	"github.com/kaspanet/kaspad/util/daghash"
+	"github.com/kaspanet/kaspad/util/mstime"
+	"github.com/pkg/errors"
+	"io"
+	"math"
 )
 
 // BaseBlockHeaderPayload is the base number of bytes a block header can be,
@@ -49,7 +50,7 @@ type BlockHeader struct {
 	UTXOCommitment *daghash.Hash
 
 	// Time the block was created.
-	Timestamp time.Time
+	Timestamp mstime.Time
 
 	// Difficulty target for the block.
 	Bits uint32
@@ -60,19 +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)
+	// 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 daghash.DoubleHashP(buf.Bytes())
+	res := writer.Finalize()
+	return &res
 }
 
 // IsGenesis returns true iff this block is a genesis block
@@ -83,7 +93,7 @@ func (h *BlockHeader) IsGenesis() bool {
 // 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.
+// 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)
 }
@@ -91,7 +101,7 @@ func (h *BlockHeader) KaspaDecode(r io.Reader, pver uint32) error {
 // 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.
+// 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)
 }
@@ -100,7 +110,7 @@ func (h *BlockHeader) KaspaEncode(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 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)
@@ -110,7 +120,7 @@ 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 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)
@@ -128,7 +138,7 @@ func (h *BlockHeader) SerializeSize() int {
 func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot *daghash.Hash,
 	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,
@@ -136,7 +146,7 @@ func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot
 		HashMerkleRoot:       hashMerkleRoot,
 		AcceptedIDMerkleRoot: acceptedIDMerkleRoot,
 		UTXOCommitment:       utxoCommitment,
-		Timestamp:            time.Unix(time.Now().Unix(), 0),
+		Timestamp:            mstime.Now(),
 		Bits:                 bits,
 		Nonce:                nonce,
 	}
@@ -144,7 +154,7 @@ func NewBlockHeader(version int32, parentHashes []*daghash.Hash, hashMerkleRoot
 
 // 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)
@@ -170,9 +180,9 @@ func readBlockHeader(r io.Reader, pver uint32, bh *BlockHeader) error {
 
 // 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
 	}
@@ -181,5 +191,5 @@ func writeBlockHeader(w io.Writer, pver uint32, bh *BlockHeader) error {
 			return err
 		}
 	}
-	return writeElements(w, bh.HashMerkleRoot, bh.AcceptedIDMerkleRoot, bh.UTXOCommitment, sec, bh.Bits, bh.Nonce)
+	return writeElements(w, bh.HashMerkleRoot, bh.AcceptedIDMerkleRoot, bh.UTXOCommitment, timestamp, bh.Bits, bh.Nonce)
 }

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"
-	"reflect"
-	"testing"
-	"time"
-
 	"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"
 )
 
 // TestBlockHeader tests the BlockHeader API.
@@ -22,9 +21,9 @@ 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
+	merkleHash := mainnetGenesisMerkleRoot
 	acceptedIDMerkleRoot := exampleAcceptedIDMerkleRoot
 	bits := uint32(0x1d00ffff)
 	bh := NewBlockHeader(1, hashes, merkleHash, acceptedIDMerkleRoot, exampleUTXOCommitment, bits, nonce)
@@ -48,9 +47,9 @@ 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
 
@@ -58,24 +57,24 @@ func TestBlockHeaderWire(t *testing.T) {
 	bits := uint32(0x1d00ffff)
 	baseBlockHdr := &BlockHeader{
 		Version:              1,
-		ParentHashes:         []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
-		HashMerkleRoot:       mainNetGenesisMerkleRoot,
+		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
-		Timestamp:            time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
+		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
-		0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainNetGenesisHash
+		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
+		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,
@@ -91,16 +90,16 @@ func TestBlockHeaderWire(t *testing.T) {
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
+		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.
 		{
@@ -113,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 {
@@ -138,7 +137,7 @@ func TestBlockHeaderWire(t *testing.T) {
 			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)
@@ -174,24 +173,24 @@ func TestBlockHeaderSerialize(t *testing.T) {
 	bits := uint32(0x1d00ffff)
 	baseBlockHdr := &BlockHeader{
 		Version:              1,
-		ParentHashes:         []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
-		HashMerkleRoot:       mainNetGenesisMerkleRoot,
+		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
-		Timestamp:            time.Unix(0x495fab29, 0), // 2009-01-03 12:15:05 -0600 CST
+		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
-		0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainNetGenesisHash
+		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
+		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,
@@ -207,9 +206,9 @@ func TestBlockHeaderSerialize(t *testing.T) {
 		0x30, 0xC1, 0xF8, 0xFD, 0xD0, 0xD9, 0x72, 0x87,
 		0x7F, 0x16, 0xC5, 0x96, 0x2E, 0x8B, 0xD9, 0x63,
 		0x65, 0x9C, 0x79, 0x3C, 0xE3, 0x70, 0xD9, 0x5F,
-		0x29, 0xab, 0x5f, 0x49, 0x00, 0x00, 0x00, 0x00, // Timestamp
+		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 {
@@ -260,11 +259,11 @@ 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,
+		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.ZeroHash,
 		UTXOCommitment:       &daghash.ZeroHash,
 		Timestamp:            timestamp,
@@ -275,7 +274,7 @@ func TestBlockHeaderSerializeSize(t *testing.T) {
 	genesisBlockHdr := &BlockHeader{
 		Version:              1,
 		ParentHashes:         []*daghash.Hash{},
-		HashMerkleRoot:       mainNetGenesisMerkleRoot,
+		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: &daghash.ZeroHash,
 		UTXOCommitment:       &daghash.ZeroHash,
 		Timestamp:            timestamp,
@@ -308,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,
@@ -321,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,

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),
+	}
+}

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")
+	}
+}

app/appmessage/p2p_msgblock.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"
@@ -21,15 +21,18 @@ import (
 // backing array multiple times.
 const defaultTransactionAlloc = 2048
 
-// MaxMassPerBlock is the maximum total transaction mass a block may have.
-const MaxMassPerBlock = 10000000
+// MaxMassAcceptedByBlock is the maximum total transaction mass a block may accept.
+const MaxMassAcceptedByBlock = 10000000
 
 // MaxMassPerTx is the maximum total mass a transaction may have.
-const MaxMassPerTx = MaxMassPerBlock / 2
+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 = (MaxMassPerBlock / 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.
@@ -42,6 +45,7 @@ type TxLoc struct {
 // 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
 }
@@ -59,7 +63,7 @@ func (msg *MsgBlock) ClearTransactions() {
 // 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.
+// 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 {
@@ -74,9 +78,9 @@ func (msg *MsgBlock) KaspaDecode(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)
+			"[count %d, max %d]", txCount, MaxTxPerBlock)
 		return messageError("MsgBlock.KaspaDecode", str)
 	}
 
@@ -96,14 +100,14 @@ func (msg *MsgBlock) KaspaDecode(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 KaspaDecode in that
-// KaspaDecode decodes from the kaspa wire protocol as it was sent across the
-// network. The wire encoding can technically differ depending on the protocol
+// 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
 // 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 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)
@@ -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 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 wire protocol functions.
+	// 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)
 	}
 
@@ -159,7 +163,7 @@ func (msg *MsgBlock) DeserializeTxLoc(r *bytes.Buffer) ([]TxLoc, error) {
 // 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.
+// 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 {
@@ -184,14 +188,14 @@ func (msg *MsgBlock) KaspaEncode(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 KaspaEncode in that KaspaEncode encodes the block to
-// the kaspa wire protocol in order to be sent across the network. The wire
+// 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
 // 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 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)
@@ -213,7 +217,7 @@ func (msg *MsgBlock) SerializeSize() int {
 
 // 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
 }
 

app/appmessage/p2p_msgblock_test.go

@@ -2,17 +2,17 @@
 // 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/kaspanet/kaspad/util/subnetworkid"
 
 	"github.com/davecgh/go-spew/spew"
 	"github.com/kaspanet/kaspad/util/daghash"
@@ -32,7 +32,7 @@ func TestBlock(t *testing.T) {
 	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",
@@ -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 := "22e72b61a572bfb32b8739f4e5db3eebe9870e394288467958e93e4a3d3b749f"
+	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,7 +166,7 @@ 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.KaspaEncode(&buf, test.pver)
 		if err != nil {
@@ -179,7 +179,7 @@ func TestBlockWire(t *testing.T) {
 			continue
 		}
 
-		// Decode the message from wire format.
+		// Decode the message from appmessage format.
 		var msg MsgBlock
 		rbuf := bytes.NewReader(test.buf)
 		err = msg.KaspaDecode(rbuf, test.pver)
@@ -195,15 +195,15 @@ func TestBlockWire(t *testing.T) {
 	}
 }
 
-// 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
@@ -236,20 +236,20 @@ func TestBlockWireErrors(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.KaspaEncode(w, test.pver)
-		if err != test.writeErr {
+		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.KaspaDecode(r, test.pver)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -324,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 {
@@ -365,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
@@ -375,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
@@ -384,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
@@ -400,8 +400,8 @@ 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.
@@ -409,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,
@@ -431,7 +431,7 @@ func TestBlockOverflowErrors(t *testing.T) {
 				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{},
@@ -440,7 +440,7 @@ 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.KaspaDecode(r, test.pver)
@@ -450,7 +450,7 @@ func TestBlockOverflowErrors(t *testing.T) {
 			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) {
@@ -459,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) {
@@ -503,13 +503,13 @@ func TestBlockSerializeSize(t *testing.T) {
 var blockOne = MsgBlock{
 	Header: BlockHeader{
 		Version:              1,
-		ParentHashes:         []*daghash.Hash{mainNetGenesisHash, simNetGenesisHash},
-		HashMerkleRoot:       mainNetGenesisMerkleRoot,
+		ParentHashes:         []*daghash.Hash{mainnetGenesisHash, simnetGenesisHash},
+		HashMerkleRoot:       mainnetGenesisMerkleRoot,
 		AcceptedIDMerkleRoot: exampleAcceptedIDMerkleRoot,
 		UTXOCommitment:       exampleUTXOCommitment,
-		Timestamp:            time.Unix(0x4966bc61, 0), // 2009-01-08 20:54:25 -0600 CST
-		Bits:                 0x1d00ffff,               // 486604799
-		Nonce:                0x9962e301,               // 2573394689
+		Timestamp:            mstime.UnixMilliseconds(0x17315ed0f99),
+		Bits:                 0x1d00ffff, // 486604799
+		Nonce:                0x9962e301, // 2573394689
 	},
 	Transactions: []*MsgTx{
 		NewNativeMsgTx(1,
@@ -550,11 +550,11 @@ var blockOne = MsgBlock{
 var blockOneBytes = []byte{
 	0x01, 0x00, 0x00, 0x00, // Version 1
 	0x02,                                           // NumParentBlocks
-	0xdc, 0x5f, 0x5b, 0x5b, 0x1d, 0xc2, 0xa7, 0x25, // mainNetGenesisHash
+	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
+	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,
@@ -570,9 +570,9 @@ var blockOneBytes = []byte{
 	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
+	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

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,
+	}
+}

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))
+	}
+}

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{}
+}

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}
+}

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
+		}
+	}
+}

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,
+	}
+}

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,
+	}
+}

app/appmessage/p2p_msgping.go

@@ -2,11 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
-
-import (
-	"io"
-)
+package appmessage
 
 // MsgPing implements the Message interface and represents a kaspa ping
 // message.
@@ -20,46 +16,18 @@ import (
 // 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
 }
 
-// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
-// This is part of the Message interface implementation.
-func (msg *MsgPing) KaspaDecode(r io.Reader, pver uint32) error {
-	err := ReadElement(r, &msg.Nonce)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
-// This is part of the Message interface implementation.
-func (msg *MsgPing) KaspaEncode(w io.Writer, pver uint32) error {
-	err := WriteElement(w, msg.Nonce)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
 // Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.
-func (msg *MsgPing) Command() string {
+func (msg *MsgPing) Command() MessageCommand {
 	return CmdPing
 }
 
-// MaxPayloadLength returns the maximum length the payload can be for the
-// receiver. This is part of the Message interface implementation.
-func (msg *MsgPing) MaxPayloadLength(pver uint32) uint32 {
-	// Nonce 8 bytes.
-	return uint32(8)
-}
-
 // NewMsgPing returns a new kaspa ping message that conforms to the Message
 // interface. See MsgPing for details.
 func NewMsgPing(nonce uint64) *MsgPing {

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)
+	}
+}

app/appmessage/p2p_msgpong.go

@@ -2,11 +2,7 @@
 // Use of this source code is governed by an ISC
 // license that can be found in the LICENSE file.
 
-package wire
-
-import (
-	"io"
-)
+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
@@ -14,36 +10,18 @@ import (
 //
 // 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
 }
 
-// KaspaDecode decodes r using the kaspa protocol encoding into the receiver.
-// This is part of the Message interface implementation.
-func (msg *MsgPong) KaspaDecode(r io.Reader, pver uint32) error {
-	return ReadElement(r, &msg.Nonce)
-}
-
-// KaspaEncode encodes the receiver to w using the kaspa protocol encoding.
-// This is part of the Message interface implementation.
-func (msg *MsgPong) KaspaEncode(w io.Writer, pver uint32) error {
-	return WriteElement(w, msg.Nonce)
-}
-
 // Command returns the protocol command string for the message. This is part
 // of the Message interface implementation.
-func (msg *MsgPong) Command() string {
+func (msg *MsgPong) Command() MessageCommand {
 	return CmdPong
 }
 
-// MaxPayloadLength returns the maximum length the payload can be for the
-// receiver. This is part of the Message interface implementation.
-func (msg *MsgPong) MaxPayloadLength(pver uint32) uint32 {
-	// Nonce 8 bytes.
-	return uint32(8)
-}
-
 // NewMsgPong returns a new kaspa pong message that conforms to the Message
 // interface. See MsgPong for details.
 func NewMsgPong(nonce uint64) *MsgPong {

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)
+	}
+}

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,
+	}
+}

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,
+	}
+}

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)
+	}
+}

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,
+	}
+}

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)
+	}
+}

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,
+	}
+}

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)
+	}
+}

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{}
+}

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,
+	}
+}

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{}
+}

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)
+	}
+}

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,
+	}
+}

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,
+	}
+}

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)
+	}
+}

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,
+	}
+}

app/appmessage/p2p_msgtx.go

@@ -2,10 +2,9 @@
 // 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"
@@ -44,11 +43,11 @@ 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,
@@ -84,7 +83,7 @@ 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
+	// 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
@@ -268,6 +267,7 @@ func NewTxOut(value uint64, scriptPubKey []byte) *TxOut {
 // 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
@@ -301,29 +301,34 @@ func (msg *MsgTx) IsCoinBase() bool {
 // 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 {
 	// 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)
-	txID := 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
 }
 
@@ -401,7 +406,7 @@ func (msg *MsgTx) Copy() *MsgTx {
 // 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.
+// 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 {
@@ -530,6 +535,10 @@ func (msg *MsgTx) KaspaDecode(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
@@ -587,15 +596,15 @@ func (msg *MsgTx) KaspaDecode(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 KaspaDecode
-// in that KaspaDecode decodes from the kaspa wire protocol as it was sent
-// across the network. The wire encoding can technically differ depending on
+// 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
 // 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 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)
@@ -604,7 +613,7 @@ func (msg *MsgTx) Deserialize(r io.Reader) error {
 // 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.
+// 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)
 }
@@ -693,22 +702,22 @@ 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 KaspaEncode in that KaspaEncode
-// encodes the transaction to the kaspa wire protocol in order to be sent
-// across the network. The wire encoding can technically differ depending on
+// 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
 // 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 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 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)
@@ -758,7 +767,7 @@ func (msg *MsgTx) serializeSize(encodingFlags txEncoding) int {
 
 // 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
 }
 

app/appmessage/p2p_msgtx_test.go

@@ -2,11 +2,12 @@
 // 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"
@@ -29,10 +30,10 @@ 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)
 	}
 
@@ -191,7 +192,7 @@ func TestTxHashAndID(t *testing.T) {
 		return
 	}
 	payload := []byte{1, 2, 3}
-	txIns := []*TxIn{&TxIn{
+	txIns := []*TxIn{{
 		PreviousOutpoint: Outpoint{
 			Index: 0,
 			TxID:  daghash.TxID{1, 2, 3},
@@ -252,9 +253,9 @@ func TestTxHashAndID(t *testing.T) {
 	}
 }
 
-// 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{
@@ -270,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.
 		{
@@ -292,7 +293,7 @@ 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.KaspaEncode(&buf, test.pver)
 		if err != nil {
@@ -305,7 +306,7 @@ func TestTxWire(t *testing.T) {
 			continue
 		}
 
-		// Decode the message from wire format.
+		// Decode the message from appmessage format.
 		var msg MsgTx
 		rbuf := bytes.NewReader(test.buf)
 		err = msg.KaspaDecode(rbuf, test.pver)
@@ -321,15 +322,15 @@ func TestTxWire(t *testing.T) {
 	}
 }
 
-// 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
@@ -362,20 +363,20 @@ 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.KaspaEncode(w, test.pver)
-		if err != test.writeErr {
+		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.KaspaDecode(r, test.pver)
-		if err != test.readErr {
+		if !errors.Is(err, test.readErr) {
 			t.Errorf("KaspaDecode #%d wrong error got: %v, want: %v",
 				i, err, test.readErr)
 			continue
@@ -527,7 +528,7 @@ func TestTxSerialize(t *testing.T) {
 	}
 }
 
-// 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 {
@@ -568,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
@@ -578,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
@@ -627,8 +628,8 @@ func TestTxOverflowErrors(t *testing.T) {
 	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
 	}{
@@ -690,7 +691,7 @@ 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.KaspaDecode(r, test.pver)
@@ -700,7 +701,7 @@ func TestTxOverflowErrors(t *testing.T) {
 			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) {
@@ -890,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

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{}
+}

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)
+	}
+}

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
+}

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")
+	}
+}

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)
+}

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")
+	}
+}

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,10 +10,13 @@ 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 kaspa peer.
@@ -97,30 +100,26 @@ type KaspaNet uint32
 // 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 kaspa network.
-	MainNet KaspaNet = 0xd9b4bef9
+	// Mainnet represents the main kaspa network.
+	Mainnet KaspaNet = 0x3ddcf71d
 
-	// TestNet represents the test network.
-	TestNet KaspaNet = 0x0709110b
+	// Testnet represents the test network.
+	Testnet KaspaNet = 0xddb8af8f
 
-	// RegTest represents the regression test network.
-	RegTest KaspaNet = 0xdab5bffa
+	// Simnet represents the simulation test network.
+	Simnet KaspaNet = 0x374dcf1c
 
-	// SimNet represents the simulation test network.
-	SimNet KaspaNet = 0x12141c16
-
-	// DevNet represents the development test network.
-	DevNet KaspaNet = 0x01020304
+	// Devnet represents the development test network.
+	Devnet KaspaNet = 0x732d87e1
 )
 
 // bnStrings is a map of kaspa networks back to their constant names for
 // pretty printing.
 var bnStrings = map[KaspaNet]string{
-	MainNet: "MainNet",
-	TestNet: "TestNet",
-	RegTest: "RegTest",
-	SimNet:  "SimNet",
-	DevNet:  "DevNet",
+	Mainnet: "Mainnet",
+	Testnet: "Testnet",
+	Simnet:  "Simnet",
+	Devnet:  "Devnet",
 }
 
 // String returns the KaspaNet in human-readable form.

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"
 
@@ -39,10 +39,9 @@ func TestKaspaNetStringer(t *testing.T) {
 		in   KaspaNet
 		want string
 	}{
-		{MainNet, "MainNet"},
-		{RegTest, "RegTest"},
-		{TestNet, "TestNet"},
-		{SimNet, "SimNet"},
+		{Mainnet, "Mainnet"},
+		{Testnet, "Testnet"},
+		{Simnet, "Simnet"},
 		{0xffffffff, "Unknown KaspaNet (4294967295)"},
 	}
 

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{}
+}

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
+}

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,
+	}
+}

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{}
+}

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{}
+}

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,
+	}
+}

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,
+	}
+}

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
+}

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,
+	}
+}

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{}
+}

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
+}

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,
+	}
+}

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,
+	}
+}

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,
+	}
+}

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,
+	}
+}

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,
+	}
+}

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{}
+}

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{}
+}

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,
+	}
+}

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)

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
+}

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)

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")

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
+}

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()))
+}

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
+}

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
+}

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
+	}
+}

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
+}

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
+}

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)

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
+}

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()
+	}
+}

app/protocol/flows/addressexchange/receiveaddresses.go

@@ -0,0 +1,57 @@
+package addressexchange
+
+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/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/infrastructure/config"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// ReceiveAddressesContext is the interface for the context needed for the ReceiveAddresses flow.
+type ReceiveAddressesContext interface {
+	Config() *config.Config
+	AddressManager() *addressmanager.AddressManager
+}
+
+// ReceiveAddresses asks a peer for more addresses if needed.
+func ReceiveAddresses(context ReceiveAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route,
+	peer *peerpkg.Peer) error {
+
+	if !context.AddressManager().NeedMoreAddresses() {
+		return nil
+	}
+
+	subnetworkID := peer.SubnetworkID()
+	msgGetAddresses := appmessage.NewMsgRequestAddresses(false, subnetworkID)
+	err := outgoingRoute.Enqueue(msgGetAddresses)
+	if err != nil {
+		return err
+	}
+
+	message, err := incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+	if err != nil {
+		return err
+	}
+
+	msgAddresses := message.(*appmessage.MsgAddresses)
+	if len(msgAddresses.AddrList) > addressmanager.GetAddressesMax {
+		return protocolerrors.Errorf(true, "address count exceeded %d", addressmanager.GetAddressesMax)
+	}
+
+	if msgAddresses.IncludeAllSubnetworks {
+		return protocolerrors.Errorf(true, "got unexpected "+
+			"IncludeAllSubnetworks=true in [%s] command", msgAddresses.Command())
+	}
+	if !msgAddresses.SubnetworkID.IsEqual(context.Config().SubnetworkID) && msgAddresses.SubnetworkID != nil {
+		return protocolerrors.Errorf(false, "only full nodes and %s subnetwork IDs "+
+			"are allowed in [%s] command, but got subnetwork ID %s",
+			context.Config().SubnetworkID, msgAddresses.Command(), msgAddresses.SubnetworkID)
+	}
+
+	sourceAddress := peer.Connection().NetAddress()
+	context.AddressManager().AddAddresses(msgAddresses.AddrList, sourceAddress, msgAddresses.SubnetworkID)
+	return nil
+}

app/protocol/flows/addressexchange/sendaddresses.go

@@ -0,0 +1,52 @@
+package addressexchange
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"math/rand"
+)
+
+// SendAddressesContext is the interface for the context needed for the SendAddresses flow.
+type SendAddressesContext interface {
+	AddressManager() *addressmanager.AddressManager
+}
+
+// SendAddresses sends addresses to a peer that requests it.
+func SendAddresses(context SendAddressesContext, incomingRoute *router.Route, outgoingRoute *router.Route) error {
+	message, err := incomingRoute.Dequeue()
+	if err != nil {
+		return err
+	}
+
+	msgGetAddresses := message.(*appmessage.MsgRequestAddresses)
+	addresses := context.AddressManager().AddressCache(msgGetAddresses.IncludeAllSubnetworks,
+		msgGetAddresses.SubnetworkID)
+	msgAddresses := appmessage.NewMsgAddresses(msgGetAddresses.IncludeAllSubnetworks, msgGetAddresses.SubnetworkID)
+	err = msgAddresses.AddAddresses(shuffleAddresses(addresses)...)
+	if err != nil {
+		return err
+	}
+
+	return outgoingRoute.Enqueue(msgAddresses)
+}
+
+// shuffleAddresses randomizes the given addresses sent if there are more than the maximum allowed in one message.
+func shuffleAddresses(addresses []*appmessage.NetAddress) []*appmessage.NetAddress {
+	addressCount := len(addresses)
+
+	if addressCount < appmessage.MaxAddressesPerMsg {
+		return addresses
+	}
+
+	shuffleAddresses := make([]*appmessage.NetAddress, addressCount)
+	copy(shuffleAddresses, addresses)
+
+	rand.Shuffle(addressCount, func(i, j int) {
+		shuffleAddresses[i], shuffleAddresses[j] = shuffleAddresses[j], shuffleAddresses[i]
+	})
+
+	// Truncate it to the maximum size.
+	shuffleAddresses = shuffleAddresses[:appmessage.MaxAddressesPerMsg]
+	return shuffleAddresses
+}

app/protocol/flows/blockrelay/handle_relay_block_requests.go

@@ -0,0 +1,55 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/pkg/errors"
+)
+
+// RelayBlockRequestsContext is the interface for the context needed for the HandleRelayBlockRequests flow.
+type RelayBlockRequestsContext interface {
+	DAG() *blockdag.BlockDAG
+}
+
+// HandleRelayBlockRequests listens to appmessage.MsgRequestRelayBlocks messages and sends
+// their corresponding blocks to the requesting peer.
+func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *router.Route,
+	outgoingRoute *router.Route, peer *peerpkg.Peer) error {
+
+	for {
+		message, err := incomingRoute.Dequeue()
+		if err != nil {
+			return err
+		}
+		getRelayBlocksMessage := message.(*appmessage.MsgRequestRelayBlocks)
+		for _, hash := range getRelayBlocksMessage.Hashes {
+			// Fetch the block from the database.
+			block, err := context.DAG().BlockByHash(hash)
+			if blockdag.IsNotInDAGErr(err) {
+				return protocolerrors.Errorf(true, "block %s not found", hash)
+			} else if err != nil {
+				return errors.Wrapf(err, "unable to fetch requested block hash %s", hash)
+			}
+			msgBlock := block.MsgBlock()
+
+			// If we are a full node and the peer is a partial node, we must convert
+			// the block to a partial block.
+			nodeSubnetworkID := context.DAG().SubnetworkID()
+			peerSubnetworkID := peer.SubnetworkID()
+
+			isNodeFull := nodeSubnetworkID == nil
+			isPeerFull := peerSubnetworkID == nil
+			if isNodeFull && !isPeerFull {
+				msgBlock.ConvertToPartial(peerSubnetworkID)
+			}
+
+			err = outgoingRoute.Enqueue(msgBlock)
+			if err != nil {
+				return err
+			}
+		}
+	}
+}

app/protocol/flows/blockrelay/handle_relay_invs.go

@@ -0,0 +1,245 @@
+package blockrelay
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/protocol/blocklogger"
+	"github.com/kaspanet/kaspad/app/protocol/common"
+	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
+	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
+	"github.com/kaspanet/kaspad/domain/blockdag"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util"
+	"github.com/kaspanet/kaspad/util/daghash"
+	mathUtil "github.com/kaspanet/kaspad/util/math"
+	"github.com/pkg/errors"
+)
+
+// RelayInvsContext is the interface for the context needed for the HandleRelayInvs flow.
+type RelayInvsContext interface {
+	NetAdapter() *netadapter.NetAdapter
+	DAG() *blockdag.BlockDAG
+	OnNewBlock(block *util.Block) error
+	SharedRequestedBlocks() *SharedRequestedBlocks
+	StartIBDIfRequired()
+	IsInIBD() bool
+	Broadcast(message appmessage.Message) error
+}
+
+type handleRelayInvsFlow struct {
+	RelayInvsContext
+	incomingRoute, outgoingRoute *router.Route
+	peer                         *peerpkg.Peer
+	invsQueue                    []*appmessage.MsgInvRelayBlock
+}
+
+// HandleRelayInvs listens to appmessage.MsgInvRelayBlock messages, requests their corresponding blocks if they
+// are missing, adds them to the DAG and propagates them to the rest of the network.
+func HandleRelayInvs(context RelayInvsContext, incomingRoute *router.Route, outgoingRoute *router.Route,
+	peer *peerpkg.Peer) error {
+
+	flow := &handleRelayInvsFlow{
+		RelayInvsContext: context,
+		incomingRoute:    incomingRoute,
+		outgoingRoute:    outgoingRoute,
+		peer:             peer,
+		invsQueue:        make([]*appmessage.MsgInvRelayBlock, 0),
+	}
+	return flow.start()
+}
+
+func (flow *handleRelayInvsFlow) start() error {
+	for {
+		inv, err := flow.readInv()
+		if err != nil {
+			return err
+		}
+
+		log.Debugf("Got relay inv for block %s", inv.Hash)
+
+		if flow.DAG().IsKnownBlock(inv.Hash) {
+			if flow.DAG().IsKnownInvalid(inv.Hash) {
+				return protocolerrors.Errorf(true, "sent inv of an invalid block %s",
+					inv.Hash)
+			}
+			continue
+		}
+
+		flow.StartIBDIfRequired()
+		if flow.IsInIBD() {
+			// Block relay is disabled during IBD
+			continue
+		}
+
+		requestQueue := newHashesQueueSet()
+		requestQueue.enqueueIfNotExists(inv.Hash)
+
+		for requestQueue.len() > 0 {
+			err := flow.requestBlocks(requestQueue)
+			if err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error) {
+
+	if len(flow.invsQueue) > 0 {
+		var inv *appmessage.MsgInvRelayBlock
+		inv, flow.invsQueue = flow.invsQueue[0], flow.invsQueue[1:]
+		return inv, nil
+	}
+
+	msg, err := flow.incomingRoute.Dequeue()
+	if err != nil {
+		return nil, err
+	}
+
+	inv, ok := msg.(*appmessage.MsgInvRelayBlock)
+	if !ok {
+		return nil, protocolerrors.Errorf(true, "unexpected %s message in the block relay handleRelayInvsFlow while "+
+			"expecting an inv message", msg.Command())
+	}
+	return inv, nil
+}
+
+func (flow *handleRelayInvsFlow) requestBlocks(requestQueue *hashesQueueSet) error {
+	numHashesToRequest := mathUtil.MinInt(appmessage.MsgRequestRelayBlocksHashes, requestQueue.len())
+	hashesToRequest := requestQueue.dequeue(numHashesToRequest)
+
+	pendingBlocks := map[daghash.Hash]struct{}{}
+	var filteredHashesToRequest []*daghash.Hash
+	for _, hash := range hashesToRequest {
+		exists := flow.SharedRequestedBlocks().addIfNotExists(hash)
+		if exists {
+			continue
+		}
+
+		// The block can become known from another peer in the process of orphan resolution
+		if flow.DAG().IsKnownBlock(hash) {
+			continue
+		}
+
+		pendingBlocks[*hash] = struct{}{}
+		filteredHashesToRequest = append(filteredHashesToRequest, hash)
+	}
+
+	// Exit early if we've filtered out all the hashes
+	if len(filteredHashesToRequest) == 0 {
+		return nil
+	}
+
+	// In case the function returns earlier than expected, we want to make sure requestedBlocks is
+	// clean from any pending blocks.
+	defer flow.SharedRequestedBlocks().removeSet(pendingBlocks)
+
+	getRelayBlocksMsg := appmessage.NewMsgRequestRelayBlocks(filteredHashesToRequest)
+	err := flow.outgoingRoute.Enqueue(getRelayBlocksMsg)
+	if err != nil {
+		return err
+	}
+
+	for len(pendingBlocks) > 0 {
+		msgBlock, err := flow.readMsgBlock()
+		if err != nil {
+			return err
+		}
+
+		block := util.NewBlock(msgBlock)
+		blockHash := block.Hash()
+
+		if _, ok := pendingBlocks[*blockHash]; !ok {
+			return protocolerrors.Errorf(true, "got unrequested block %s", block.Hash())
+		}
+
+		err = flow.processAndRelayBlock(requestQueue, block)
+		if err != nil {
+			return err
+		}
+
+		delete(pendingBlocks, *blockHash)
+		flow.SharedRequestedBlocks().remove(blockHash)
+	}
+	return nil
+}
+
+// readMsgBlock returns the next msgBlock in msgChan, and populates invsQueue with any inv messages that meanwhile arrive.
+//
+// Note: this function assumes msgChan can contain only appmessage.MsgInvRelayBlock and appmessage.MsgBlock messages.
+func (flow *handleRelayInvsFlow) readMsgBlock() (
+	msgBlock *appmessage.MsgBlock, err error) {
+
+	for {
+		message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
+		if err != nil {
+			return nil, err
+		}
+
+		switch message := message.(type) {
+		case *appmessage.MsgInvRelayBlock:
+			flow.invsQueue = append(flow.invsQueue, message)
+		case *appmessage.MsgBlock:
+			return message, nil
+		default:
+			return nil, errors.Errorf("unexpected message %s", message.Command())
+		}
+	}
+}
+
+func (flow *handleRelayInvsFlow) processAndRelayBlock(requestQueue *hashesQueueSet, block *util.Block) error {
+	blockHash := block.Hash()
+	isOrphan, isDelayed, err := flow.DAG().ProcessBlock(block, blockdag.BFNone)
+	if err != nil {
+		if !errors.As(err, &blockdag.RuleError{}) {
+			return errors.Wrapf(err, "failed to process block %s", blockHash)
+		}
+		log.Infof("Rejected block %s from %s: %s", blockHash, flow.peer, err)
+
+		return protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
+	}
+
+	if isDelayed {
+		return nil
+	}
+
+	if isOrphan {
+		blueScore, err := block.BlueScore()
+		if err != nil {
+			return protocolerrors.Errorf(true, "received an orphan "+
+				"block %s with malformed blue score", blockHash)
+		}
+
+		const maxOrphanBlueScoreDiff = 10000
+		selectedTipBlueScore := flow.DAG().SelectedTipBlueScore()
+		if blueScore > selectedTipBlueScore+maxOrphanBlueScoreDiff {
+			log.Infof("Orphan block %s has blue score %d and the selected tip blue score is "+
+				"%d. Ignoring orphans with a blue score difference from the selected tip greater than %d",
+				blockHash, blueScore, selectedTipBlueScore, maxOrphanBlueScoreDiff)
+			return nil
+		}
+
+		// Request the parents for the orphan block from the peer that sent it.
+		missingAncestors := flow.DAG().GetOrphanMissingAncestorHashes(blockHash)
+		for _, missingAncestor := range missingAncestors {
+			requestQueue.enqueueIfNotExists(missingAncestor)
+		}
+		return nil
+	}
+	err = blocklogger.LogBlock(block)
+	if err != nil {
+		return err
+	}
+	err = flow.Broadcast(appmessage.NewMsgInvBlock(blockHash))
+	if err != nil {
+		return err
+	}
+
+	flow.StartIBDIfRequired()
+	err = flow.OnNewBlock(block)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

app/protocol/flows/blockrelay/hashes_queue_set.go

@@ -0,0 +1,35 @@
+package blockrelay
+
+import "github.com/kaspanet/kaspad/util/daghash"
+
+type hashesQueueSet struct {
+	queue []*daghash.Hash
+	set   map[daghash.Hash]struct{}
+}
+
+func (r *hashesQueueSet) enqueueIfNotExists(hash *daghash.Hash) {
+	if _, ok := r.set[*hash]; ok {
+		return
+	}
+	r.queue = append(r.queue, hash)
+	r.set[*hash] = struct{}{}
+}
+
+func (r *hashesQueueSet) dequeue(numItems int) []*daghash.Hash {
+	var hashes []*daghash.Hash
+	hashes, r.queue = r.queue[:numItems], r.queue[numItems:]
+	for _, hash := range hashes {
+		delete(r.set, *hash)
+	}
+	return hashes
+}
+
+func (r *hashesQueueSet) len() int {
+	return len(r.queue)
+}
+
+func newHashesQueueSet() *hashesQueueSet {
+	return &hashesQueueSet{
+		set: make(map[daghash.Hash]struct{}),
+	}
+}