return -code error "Invalid option: $arg"
			}
		}
	}

	if {[string length $publicKey] != $::nano::key::publicKeyLength} {
		set publicKey [binary decode hex $publicKey]

		if {[string length $publicKey] != $::nano::key::publicKeyLength} {
			return -code error "Invalid public key (length: [string length $publicKey], expected $::nano::key::publicKeyLength)"
		}
	}

	set checksum [string reverse [::nano::internal::hashData $publicKey 5]]
	append publicKey $checksum

	set publicKey [binary encode hex $publicKey]
	set publicKey [expr "0x$publicKey"]

	if {[info exists workDataBasedOn]} {
		if {$workDataBasedOn eq "previous"} {
			dict set blockDict "_workData" [dict get $blockDict "previous"]
		} else {
			dict set blockDict "_workData" [::nano::address::toPublicKey [dict get $blockDict "account"]]
		}
	}

	if {[dict exists $blockDict "work"]} {
		set valid [::nano::work::validate [dict get $blockDict "_workData"] [dict get $blockDict "work"]]
		if {!$valid} {
			return -code error "Invalid work when adding block"
		}
	}

	return $blockDict
}

proc ::nano::block::dict::fromJSON {blockJSON} {
	set retval [::json::json2dict $blockJSON]

			}
		}
	}

	set now [clock seconds]
	# Cleanup nonces while we are here
	foreach {peerKey peerInfo} [array get ::nano::node::_node_id_nonces] {
		if {![dict exists $peerInfo "lastSeen"]} {
			continue
		}

		set lastSeen [dict get $peerInfo "lastSeen"]
		if {($now - $lastSeen) > (5 * 60)} {
			unset ::nano::node::_node_id_nonces($peerKey)
		}
	}

	# Come up with a list of peers that we have seen recently
	foreach {peerKeyInfo peerInfo} [array get ::nano::node::peers] {
		if {![dict exists $peerInfo "lastSeen"]} {
			continue
		}

		set lastSeen [dict get $peerInfo "lastSeen"]
		set address [dict get $peerKeyInfo "address"]
		set peerPort [dict get $peerKeyInfo "port"]
		set peerKey [dict create address $address port $peerPort]

		if {($now - $lastSeen) > (5 * 60)} {
#puts "Have not seen $peerKey in a while, dropping (now=$now, lastSeen=$lastSeen)"

		# If this peer is not already known, contact them requesting a handshake
		if {![info exists ::nano::node::peers($peer)]} {
			if {![info exists ::nano::node::_node_id_nonces($peer)]} {
				set node_id_nonce [::nano::internal::randomBytes 32]
				set ::nano::node::_node_id_nonces($peer) [dict create query $node_id_nonce lastSeen $now]

				set peerSock [::nano::node::createSocket realtime $address $port]

				::nano::network::client $peerSock "node_id_handshake" query -query $node_id_nonce
			}
		}
	}

	# Stats
	::nano::node::stats::incr [list keepalive]

	if {"response" in $flags} {
		binary scan $messageData H64H128 result(key) result(signature)
	}

	return [array get result]
}

proc ::nano::network::_socketToPeer {realtimeSocket} {
	set peerInfo [dict get $realtimeSocket remote]
	set peerAddress [lindex $peerInfo 0]
	set peerPort [lindex $peerInfo 1]
	set peer [dict create address $peerAddress port $peerPort]
	return $peer
}

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

	if {"response" in [dict get $messageDict flags]} {
		set peer [::nano::network::_socketToPeer [dict get $messageDict socket]]




		# 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
		dict set ::nano::node::peers($peer) lastSeen [clock seconds]
		dict set ::nano::node::peers($peer) nodeIdKey [dict get $messageDict key]

		# Stats
		::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

	if {![info exists messageTypeID]} {
		::nano::node::log "*** Incoming: INVALID [binary encode hex $message] ($messageData)"

		return ""
	}

	::nano::node::log "*** Incoming: $messageType ($messageTypeID on $networkType; from $peerSock) [binary encode hex $message] ($messageData)"

	catch {
		set peer [::nano::network::_socketToPeer $peerSock]
		dict set ::nano::node::peers($peer) lastPacket [clock seconds]
		dict set ::nano::node::peers($peer) lastVersion $versionUsing
	}

	if {![info exists messageDict]} {
		return ""
	}

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

	foreach peer [::nano::node::getPeers] {
		if {[info exists glob]} {
			if {![string match $glob $peer] == !$globInvert} {
				continue
			}
		}

		unset -nocomplain peerInfo
		set fields [list]
		if {[info exists ::nano::node::peers($peer)]} {
			set peerInfo $::nano::node::peers($peer)
		}

		catch {
			set versionUsing [dict get $peerInfo lastVersion]

			lappend fields "protocol $versionUsing"
		}

		catch {
			set lastSeen [dict get $peerInfo lastSeen]
			set delta [expr {$now - $lastSeen}]

			set age "last seen $delta seconds ago"
			lappend fields $age
		}

		catch {
			set lastPacket [dict get $peerInfo lastPacket]
			set delta [expr {$now - $lastPacket}]

			lappend fields "last packet $delta seconds ago"
		}

		catch {
			set nodeID [dict get $peerInfo nodeIdKey]

			lappend fields "node identifier $nodeID"
		}

		if {[llength $fields] == 0} {
			lappend fields "statically configured peer"
		}

		lappend response "  $peer: [join $fields {, }]"
	}
	return [join $response "\n"]
}

proc ::nano::node::cli::_pull_chain {startBlockHash {endBlockHash "genesis"}} {
	if {$endBlockHash eq "genesis"} {
		set network [dict get $::nano::node::configuration network]