#puts "Querying $peerSock with node_id_handshake (1)"
				::nano::network::client $peerSock "node_id_handshake" query -query $node_id_nonce
			}
		}
	}

	# Stats
	::nano::node::stats::incr [list keepalive count]
	::nano::node::stats::incr [list keepalive]
	::nano::node::stats::incr [list keepalive peers] [llength $peers]
	foreach peer $peers {
		::nano::node::stats::lappend [list keepalive peersUnique] $peer
	}

	return ""
}

	return [array get result]
}

proc ::nano::network::server::node_id_handshake {messageDict} {
	set retval ""

	::nano::node::stats::incr [list node_id_handshake]

	if {"query" in [dict get $messageDict flags]} {
		set query [dict get $messageDict query]
		set clientID [dict get $::nano::node::configuration node client_id_private_key]
		set retval [dict create "invoke_client" [list node_id_handshake response -privateKey $clientID -query [binary decode hex $query]]]

		# Stats
		::nano::node::stats::incr [list node_id_handshake query count]
		::nano::node::stats::incr [list node_id_handshake query]
	}

	if {"response" in [dict get $messageDict flags]} {
		set peerInfo [dict get $messageDict socket remote]
		set peerAddress [lindex $peerInfo 0]
		set peerPort [lindex $peerInfo 1]
		set peer [dict create address $peerAddress port $peerPort]

		# XXX:TODO: Verify the nonce
		if {![info exists ::nano::node::_node_id_nonces($peer)]} {
			return ""
		}
		set sentNonce $::nano::node::_node_id_nonces($peer)
		unset ::nano::node::_node_id_nonces($peer)

		# Add the peer to our list of peers
#puts "Got node_id_handshake response from $peer"
		set ::nano::node::peers($peer) [dict create lastSeen [clock seconds]]

		# Stats
		::nano::node::stats::incr [list node_id_handshake response count]
		::nano::node::stats::incr [list node_id_handshake response]
		::nano::node::stats::lappend [list node_id_handshake response uniqueKeys] [dict get $messageDict key]
	}

	return $retval
}

proc ::nano::network::server::confirm_req {messageDict} {
	::nano::node::stats::incr [list confirm_req]
	return ""
}

proc ::nano::network::server::confirm_ack {messageDict} {
	# keep statistics
	dict with messageDict {}

	::nano::node::stats::incr [list confirm_ack]
	::nano::node::stats::incr [list confirm_ack valid $valid]
	if {!$valid} {
		return ""
	}

	::nano::node::stats::incr [list confirm_ack rep $voteAccount valid $valid]

	::nano::node::stats::incr [list confirm_ack voteType $voteType]
	::nano::node::stats::incr [list confirm_ack rep $voteAccount voteType $voteType]
	::nano::node::stats::newMinMax [list confirm_ack rep $voteAccount voteSequence] $voteSequence

	set votedOn [llength $hashes]

	::nano::node::stats::incr [list confirm_ack votedOnCount] $votedOn
	::nano::node::stats::incr [list confirm_ack rep $voteAccount votedOnCount] $votedOn
	::nano::node::stats::incr [list confirm_ack votedOn] $votedOn
	::nano::node::stats::incr [list confirm_ack rep $voteAccount votedOn] $votedOn

	foreach hash $hashes {
		::nano::node::stats::lappend [list confirm_ack votedOnUniqueCount] $hash
		::nano::node::stats::lappend [list confirm_ack rep $voteAccount votedOnUniqueCount] $hash
		::nano::node::stats::lappend [list confirm_ack votedOnUnique] $hash
		::nano::node::stats::lappend [list confirm_ack rep $voteAccount votedOnUnique] $hash
	}

	return ""
}

proc ::nano::protocol::parse::publish {extensions messageData} {
	set blockTypeID [expr {($extensions >> 8) & 0x0f}]

		}
		"open" - "state" {
			set valid false
		}
	}
	catch {
		set valid [::nano::internal::boolean [::nano::block::dict::verifySignature $block]]
	}
	if {$valid eq false && [dict get $block type] eq "state"} {
		# Check if possibly epoch
	}
	set validWork [::nano::internal::boolean [::nano::block::dict::validateWork $block]]


	::nano::node::stats::incr [list publish]
	::nano::node::stats::incr [list publish valid $valid]
	::nano::node::stats::incr [list publish validWork $validWork]
	::nano::node::stats::incr [list publish type [dict get $block type]]
	::nano::node::stats::lappend [list publish unique] $hash

}]} { puts $::errorInfo }
}]} { puts "ERROR: $::errorInfo" }

	return ""
}

# Namespace ::nano::protocol::parse deals with the network level protocol (outside the node)
# Namespace ::nano::network::server deals with the node's actual interaction with the network
proc ::nano::protocol::parse {message} {

	set configuredNetwork [dict get $::nano::node::configuration network]
	if {$network ne $configuredNetwork} {
		return ""
	}

	dict set messageDict socket $peerSock

	# Stats
	::nano::node::stats::incr [list datagram version $versionUsing]
	::nano::node::stats::incr [list datagram network $network]

	set retval [dict create]
	if {[catch {
		set retval [::nano::network::server::${messageType} $messageDict]
	} err]} {
		if {![string match "invalid command name *" $err]} {
			::nano::node::log "Error handling ${messageType}: $err"
		}

	set db ::nano::node::stats::_db
	if {[llength [info command $db]] != 0} {
		return
	}

	package require sqlite3

	::close [file tempfile dbFileName]
	file delete $dbFileName

	sqlite3 $db "" -create true
	sqlite3 $db $dbFileName -create true

	$db eval {PRAGMA journal_mode = OFF}

	file delete $dbFileName

	tailcall clear
}

proc ::nano::node::stats::close {} {
	set db ::nano::node::stats::_db

	$db close
}

proc ::nano::node::stats::clear {} {
	set db ::nano::node::stats::_db

	$db eval {DROP TABLE IF EXISTS counters}
	$db eval {DROP TABLE IF EXISTS minmax}
	$db eval {DROP TABLE IF EXISTS lists}