set pubKey [string toupper [binary encode hex $pubKey]]
	}

	return $pubKey
}

# Low-level block management
proc ::nano::block::dict::toBlock {blockDict args} {
	array set block $blockDict

	set blockData ""

	# Include type if requested
	set field "-type"
	if {[lsearch -exact $args $field] != -1} {
		append blockData [binary format c [lsearch -exact $::nano::block::blockTypes $block(type)]]
	}

	switch -- $block(type) {
		"state" {
			append blockData [::nano::address::toPublicKey $block(account)]
			append blockData [binary decode hex $block(previous)]
			append blockData [::nano::address::toPublicKey $block(representative)]
			append blockData [binary decode hex [format %032llX $block(balance)]]

			append blockData [binary decode hex $block(previous)]
			append blockData [::nano::address::toPublicKey $block(representative)]
		}
		default {
			return -code error "Invalid block type $block(type)"
		}
	}

	foreach field {-work -signature} {
		if {[lsearch -exact $args $field] == -1} {
			# It makes no sense to miss an intermediate field, so if
			# one of them is excluded, stop processing further fields
			break
		}

		set field [string trim $field "-"]
		set value $block($field)

		switch -exact -- $field {
			"work" {
				if {[string length $value] != $::nano::work::workValueLength} {
					if {$block(type) eq "state"} {
						set value [binary format W $value]
					} else {
						set value [binary format w $value]
					}
				}
			}
			"signature" {
				if {[string length $value] != $::nano::block::signatureLength} {
					set value [binary decode hex $value]
				}
			}
		}

		append blockData $value
	}

	return $blockData
}

proc ::nano::block::json::toBlock {blockJSON} {
	set blockDict [::nano::block::dict::fromJSON $blockJSON]
	tailcall ::nano::block::dict::toBlock $blockDict
}

proc ::nano::block::dict::_addWorkData {blockDict} {
	# Do nothing if this is already set
	if {[dict exists $blockDict _workData]} {
		return $blockDict
	}

	# Parse out the work data
	if {[dict get $blockDict "type"] in {send receive change state}} {
		set workDataBasedOn "previous"
	}

	if {[dict get $blockDict "type"] eq "state" && [dict get $blockDict "previous"] eq $::nano::block::zero && [dict get $blockDict "link"] ne $::nano::block::zero} {
		set workDataBasedOn "account"
	}

	if {[dict get $blockDict "type"] eq "open"} {
		set workDataBasedOn "account"
	}

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

	return $blockDict
}

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

	if {[dict get $retval "type"] eq "send"} {
		set balance [dict get $retval "balance"]
		set balance [format %lli "0x$balance"]
		dict set retval "balance" $balance
	}





	set retval [::nano::block::dict::_addWorkData $retval]
















	return $retval
}

proc ::nano::block::json::fromDict {blockDict} {
	array set block $blockDict

	set addArgs_fromPublicKey [list]
	if {$addressPrefix eq "xrb_"} {
		lappend addArgs_fromPublicKey "-xrb"
	}

	switch -- $block(type) {
		"state" {
			binary scan $blockData a32H64a32H32H64H128Wu \
				block(account) \
				block(previous) \
				block(representative) \
				block(balance) \
				block(link) \
				block(signature) \
				block(work)
		}
		"open" {
			binary scan $blockData H64a32a32H128wu \
				block(source) \
				block(representative) \
				block(account) \
				block(signature) \
				block(work)

			set block(_workData) $block(account)
		}
		"send" {
			binary scan $blockData H64a32H32H128wu \
				block(previous) \
				block(destination) \
				block(balance) \
				block(signature) \
				block(work)

			set block(_workData) $block(previous)
		}
		"receive" {
			binary scan $blockData H64H64H128wu \
				block(previous) \
				block(source) \
				block(signature) \
				block(work)

			set block(_workData) $block(previous)
		}
		"change" {
			binary scan $blockData H64a32H128wu \
				block(previous) \
				block(representative) \
				block(signature) \
				block(work)

			set block(_workData) $block(previous)
		}

		switch -exact -- $field {
			"account" - "representative" - "link_as_account" - "destination" {
				set block($field) [::nano::address::fromPublicKey $block($field) {*}$addArgs_fromPublicKey]
			}
			"balance" {
				set block($field) [format %lli "0x$block($field)"]
			}
			"work" {
				set block($field) [format %016llx $block($field)]
			}
		}
	}


	return [array get block]
}

	}

	set retval [::nano::block::json::fromDict $retval]

	return $retval
}

proc ::nano::block::dict::verifySignature {blockDict {publicKey ""}} {
	if {$publicKey eq ""} {
		if {![dict exists $blockDict "account"]} {
			error "Account or public key must be specified"
		} else {
			set publicKey [::nano::address::toPublicKey [dict get $blockDict account]]
		}
	}

	set signature [dict get $blockDict signature]

	set blockDict [_addBlockHash $blockDict]

	set blockHash [dict get $blockDict _blockHash]

	tailcall ::nano::block::verifyBlockHash $blockHash $signature $publicKey

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

	set blockDict [_addBlockHash $blockDict]
	set blockDict [_addWorkData $blockDict]

	set blockHash [dict get $blockDict _workData]

	set work [::nano::work::fromWorkData $blockHash -binary]

	if {$outputMode eq "work"} {
		if {$outputFormat eq "hex"} {

	set retval [::nano::block::json::fromDict $retval]

	return $retval
}

proc ::nano::block::dict::validateWork {blockDict} {
	set blockDict [_addBlockHash $blockDict]
	set blockDict [_addWorkData $blockDict]

	set blockHash [dict get $blockDict _workData]
	set work      [dict get $blockDict work]

	tailcall ::nano::work::validate $blockHash $work
}

proc ::nano::block::dict::genesis {network} {
	if {![info exists ::nano::block::dict::genesis($network)]} {
		set ::nano::block::dict::genesis($network) [::nano::block::dict::fromJSON [::nano::block::json::genesis $network]]
	}

	return $::nano::block::dict::genesis($network)
}

proc ::nano::block::dict::printable {blockDict} {
	dict for {key value} $blockDict {
		switch -exact -- $key {
			"_workData" {
				if {[string length $value] == $::nano::block::hashLength} {
					set value [binary encode hex $value]
					dict set blockDict $key $value
				}
			}
		}
	}

	dict unset blockDict _blockData

	return $blockDict
}

#   send from <account> to <account> previousBalance <balance>
#        amount <amount> sourceBlock <sourceBlockHash>
#        previous <previousBlockHash> ?representative <representative>?
proc ::nano::block::create::send {args} {
	array set block $args
	if {![info exists block(representative)]} {
		set block(representative) $block(from)
	}

	set block(balance) [expr {$block(previousBalance) - $block(amount)}]

	if {[info exists block(-legacy)] && $block(-legacy)} {
		set blockDict [dict create \
			"type" send \
			"previous" $block(previous) \
			"balance" $block(balance) \
			"_workData" $block(previous) \
			"_comment" "Legacy send $block(amount) raw from $block(from) to $block(to)" \
		]
	} else {
		set blockDict [dict create \
			"type" state \
			"account" $block(from) \
			"previous" $block(previous) \
			"representative" $block(representative) \
			"balance" $block(balance) \
			"link_as_account" $block(to) \
			"_workData" $block(previous) \
			"_comment" "Send $block(amount) raw from $block(from) to $block(to)" \
		]
	}

	if {[info exists block(signKey)]} {
		set blockDict [::nano::block::dict::sign $blockDict $block(signKey) -update]
	}

	if {[info exists block(-json)] && $block(-json)} {
		return [::nano::block::json::fromDict $blockDict]

	array set block $args

	if {![info exists block(representative)]} {
		set block(representative) $block(to)
	}

	if {![info exists block(previous)]} {
		set isOpen true
		set block(previous) $::nano::block::zero
		set block(previousBalance) 0
		set block(_workData) [::nano::address::toPublicKey $block(to) -hex]
	} else {
		set isOpen false
		set block(_workData) $block(previous)
	}

	set block(balance) [expr {$block(previousBalance) + $block(amount)}]

	if {[info exists block(-legacy)] && $block(-legacy)} {
		if {$isOpen} {
			set blockDict [dict create \
				"type" open \
				"account" $block(to) \
				"representative" $block(representative) \
				"source" $block(sourceBlock) \
				"_workData" $block(_workData) \
				"_comment" "Legacy open + receive of $block(amount) raw on $block(to) from hash $block(sourceBlock)" \
			]
		} else {
			set blockDict [dict create \
				"type" receive \
				"source" $block(sourceBlock) \
				"previous" $block(previous) \
				"_workData" $block(_workData) \
				"_comment" "Legacy receive $block(amount) raw on $block(to) from hash $block(sourceBlock)" \
			]
		}
	} else {
		set blockDict [dict create \
			"type" state \
			"account" $block(to) \
			"previous" $block(previous) \
			"representative" $block(representative) \
			"balance" $block(balance) \
			"link" $block(sourceBlock) \
			"_workData" $block(_workData) \
			"_comment" "Receive $block(amount) raw on $block(to) from hash $block(sourceBlock)" \
		]
	}

	if {[info exists block(signKey)]} {
		set blockDict [::nano::block::dict::sign $blockDict $block(signKey) -update]
	}

	if {[info exists block(-json)] && $block(-json)} {
		return [::nano::block::json::fromDict $blockDict]

proc ::nano::protocol::parse::confirm_req {extensions blockData} {
	set blockTypeID [expr {($extensions >> 8) & 0x0f}]
	set blockType [::nano::block::typeFromTypeID $blockTypeID]
	set blockDict [::nano::block::dict::fromBlock $blockData -type=$blockType]
	set blockHash [::nano::block::dict::toHash $blockDict -hex]





	set retval(blockType) $blockType
	set retval(block) [::nano::block::dict::printable $blockDict]
	set retval(hash) $blockHash

	return [array get retval]
}

proc ::nano::protocol::parse::confirm_ack {extensions blockData} {
	set blockTypeID [expr {($extensions >> 8) & 0x0f}]
	set blockType [::nano::block::typeFromTypeID $blockTypeID]

	# Header
	binary scan $blockData H64H128wua* \
		retval(voteAccount) \
		retval(voteSignature) \
		retval(voteSequence) \
		newBlockData

	set blockData $newBlockData

			append signedData [binary decode hex $hash]
		}
	} else {
		set blockDict [::nano::block::dict::fromBlock $blockData -type=$blockType]
		set blockHash [::nano::block::dict::toHash $blockDict -hex]
		append signedData [binary decode hex $blockHash]





		set retval(blockType) $blockType
		set retval(hashes) [list $blockHash]
		set retval(block) [::nano::block::dict::printable $blockDict]
	}

	# Add the sequence number to the signed data
	append signedData [binary format w $retval(voteSequence)]

	# Verify signature of the hash
	set valid false

		set retval(valid) true
	}

	return [array get retval]
}

proc ::nano::protocol::create {network messageType args} {
	set versionUsing 15
	set versionMin 14
	set versionMax $versionUsing
	set messageInfo(extensions) 0
	set messageInfo(blockType) 0

	set messageType [string tolower $messageType]
	set messageTypeID [lsearch -exact $::nano::network::messageTypes $messageType]
	if {$messageTypeID == -1} {

				set peerSock [::nano::node::createSocket realtime $address $port]
#puts "Querying $peerSock with node_id_handshake (1)"
				::nano::network::client $peerSock "node_id_handshake" query -query $node_id_nonce
			}
		}
	}

	# Stats
	incr ::nano::node::stats([list keepalive count])
	incr ::nano::node::stats([list keepalive peers]) [llength $peers]
	foreach peer $peers {
		set ::nano::node::_stats_seen_hashes([list keepalive $peer]) 1
	}
	set ::nano::node::stats([list keepalive peersUnique]) [llength [array names ::nano::node::_stats_seen_hashes [list keepalive *]]]

	return ""
}

proc ::nano::protocol::parse::node_id_handshake {extensions messageData} {
	array set result [list]

	set flags [nano::protocol::extensions::get "node_id_handshake" $extensions]

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

	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
		incr ::nano::node::stats([list node_id_handshake query count])
	}

	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
		incr ::nano::node::stats([list node_id_handshake response count])
		set ::nano::node::_stats_seen_hashes([list node_id_handshake [dict get $messageDict key]]) 1
		set ::nano::node::stats([list node_id_handshake response uniqueKeys]) [llength [array names ::nano::node::_stats_seen_hashes [list node_id_handshake *]]]
	}

	return $retval
}

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

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

	incr ::nano::node::stats([list confirm_ack valid $valid])
	if {!$valid} {

proc ::nano::protocol::parse::publish {extensions messageData} {
	set blockTypeID [expr {($extensions >> 8) & 0x0f}]
	set blockType [::nano::block::typeFromTypeID $blockTypeID]
	set blockDict [::nano::block::dict::fromBlock $messageData -type=$blockType]
	set blockHash [::nano::block::dict::toHash $blockDict -hex]





	set retval(blockType) $blockType
	set retval(block) [::nano::block::dict::printable $blockDict]
	set retval(hash) $blockHash

	return [array get retval]
}

proc ::nano::internal::boolean {value} {
	if {$value} {
		return true
	} else {
		return false
	}
}

proc ::nano::network::server::publish {messageDict} {
	#puts "block: [binary encode hex $blockData]"
#9e1272edade3c247c738a4bd303eb0cfc3da298444bb9d13b8ffbced34ff036f4e1ff833324efc81c237776242928ef76a2cdfaa53f4c4530ee39bfff1977e26e382dd09ec8cafc2427cf817e9afe1f372ce81085ab4feb1f3de1f25ee818e5d000000008fc492fd20e57d048e000000204e7a62f25df739eaa224d403cb107b3f9caa0280113b0328fad3b402c465169006f988549a8b1e20e0a09b4b4dcae5397f6fcc4d507675f58c2b29ae02341b0a4fe562201a61bf27481aa4567c287136b4fd26b4840c93c42c7d1f5c518503d68ec561af4b8cf8
#9e1272edade3c247c738a4bd303eb0cfc3da298444bb9d13b8ffbced34ff036fa5e3647d3d296ec72baea013ba7fa1bf5c3357c33c90196f078ba091295e6e03e382dd09ec8cafc2427cf817e9afe1f372ce81085ab4feb1f3de1f25ee818e5d000000008fb2604ebd1fe098b8000000204e7a62f25df739eaa224d403cb107b3f9caa0280113b0328fad3b402c465165287cd9c61752dc9d011f666534dbdc10461e927503f9599791d73b1cca7fdc032d76db3f91e5b5c3d6206fa48b01bd08da4a89f2e880242e9917cfc3db80d0b9bfe8e6d1dd183d5
if {[catch {
	set hash [dict get $messageDict hash]
	set block [dict get $messageDict block]
	switch -exact -- [dict get $block type] {
		"send" - "receive" - "change" {
			set valid maybe
		}
		"open" - "state" {
			set valid false
		}
	}
	catch {
		set valid [::nano::internal::boolean [::nano::block::dict::verifySignature $block]]
	}
	set validWork [::nano::internal::boolean [::nano::block::dict::validateWork $block]]


	incr ::nano::node::stats([list publish valid $valid])
	incr ::nano::node::stats([list publish validWork $validWork])
	incr ::nano::node::stats([list publish type [dict get $block type]])


	set ::nano::node::_stats_seen_hashes([list publish $hash]) 1

	set ::nano::node::stats([list publish unique]) [llength [array names ::nano::node::_stats_seen_hashes [list publish *]]]
}]} { puts $::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} {

	return true
}

proc ::nano::rpc::client {action args} {
	::nano::rpc::client::init

	set rpcURL [dict get $::nano::rpc::client::config "-url"]

	switch -exact -- $action {
		"version" - "block" {
			set timeout 1000
		}
	}

	set timeoutArgs [list]
	if {[info exists timeout]} {
		lappend timeoutArgs -timeout $timeout
	}

	set jsonArgs [list]
	set outputFormat "dict"
	foreach {key value} $args {
		switch -exact -- $key {
			"-outputformat" {
				switch -exact -- $value {
					"dict" - "json" {
						set outputFormat $value
					}
					default {
						error "Invalid output format: $value"
					}
				}
				continue
			}
			"-count" {}
			"-accounts" {
				set valueAsStrings [lmap valueItem $value { json::write string $valueItem }]
				set value [json::write array {*}$valueAsStrings]
			}
			default {
				set value [json::write string $value]
			}
		}
		set key [string range $key 1 end]

		lappend jsonArgs $key $value
	}

	set query [json::write object action [json::write string $action] {*}$jsonArgs]

	catch {
		set token [http::geturl $rpcURL -query $query {*}$timeoutArgs]
		set ncode [http::ncode $token]
		set data [http::data $token]
	} error
	if {![info exists data]} {
		set ncode -1
		set data $error
	}

	if {[info exists token]} {
		http::cleanup $token
	}

	if {$ncode ne "200"} {
		return -code error "$ncode: $data"
	}

	if {$outputFormat eq "dict"} {
		set data [json::json2dict $data]
	}

	return $data
}

# Account balance manipulation
proc ::nano::balance::toUnit {raw toUnit {decimals 0}} {
	if {![string is entier -strict $raw]} {

	set nodeIDPublic [::nano::key::publicKeyFromPrivateKey $nodeIDPrivate -hex]
	return $nodeIDPublic
}

proc {::nano::node::cli::show logs} args {
	return [join [lrange $::nano::node::log end-19 end] "\n"]
}

proc {::nano::node::cli::clear stats} args {

	set ::nano::node::statsStartTime [clock seconds]

	unset -nocomplain ::nano::node::stats
	unset -nocomplain ::nano::node::_stats_seen_hashes
	unset -nocomplain ::nano::node::_stats_seen_hashes_by_rep

	return
}

proc {::nano::node::cli::clear peers} args {
	set ::nano::node::statsStartTime [clock seconds]

	unset -nocomplain ::nano::node::peers
	array set ::nano::node::peers [list]

	return
}

proc {::nano::node::cli::show stats} args {
	set now [clock seconds]
	set statsStart $::nano::node::statsStartTime
	set uptimeStats [expr {$now - $statsStart}]

	set quiet false
	if {!$quiet} {
		set format {%-19s: %s}
		puts [format $format "Stats last cleared" "[::nano::_cli::interval $uptimeStats] ago"]
		puts ""
	}

	set globalOnly false
	if {[lindex $args 0] eq "-global"} {
		set globalOnly true
	}

			set maxKeyLen $keyLen
		}

		set localStats($key) $val
	}

	foreach {key val} [lsort -stride 2 -dictionary [array get localStats]] {
		set extra ""
		if {![regexp { (min|max)[A-Z]} $key]} {
			if {[string is entier -strict $val]} {
				set valAvg [expr {($val * 1.0) / $uptimeStats}]
				set valAvg [format %.4f $valAvg]
				set extra " (avg: $valAvg per second)"
			}
		}

		puts [format "%-${maxKeyLen}s = %s%s" $key $val $extra]
	}

	return
}

proc {::nano::node::cli::show version} {} {
	return [package present nano]

	set endTime [clock seconds]

	set blocksPulled [::nano::node::bootstrap::TMP_LEDGER_BLOCKHASHCOUNT]
	set delta [expr {$endTime - $startTime}]

	puts "Pulled $blocksPulled blocks in [::nano::_cli::interval $delta]"
}

proc ::nano::node::cli::clear {args} {
	tailcall ::nano::_cli::multiword node clear {*}$args
}

proc ::nano::node::cli::show {args} {
	tailcall ::nano::_cli::multiword node show {*}$args
}

proc ::nano::node::cli::config {args} {
	tailcall ::nano::_cli::multiword node config {*}$args

	return [join $response "\n"]
}

# RPC CLI
proc ::nano::rpc::cli {args} {
	tailcall ::nano::_cli rpc -prompt {
		if {![info exists ::nano::rpc::cli::_cached_network]} {
			catch {
				set ::nano::rpc::cli::_cached_network [{::nano::rpc::cli::show network}]
			}
		}

		if {![info exists ::nano::rpc::cli::_cached_version]} {
			catch {
				set ::nano::rpc::cli::_cached_version [{::nano::rpc::cli::show version} -vendor]
			}
		}

		if {[info exists ::nano::rpc::cli::_cached_network]} {
			set network $::nano::rpc::cli::_cached_network
		} else {
			set network "<unknown>"
		}

		if {[info exists ::nano::rpc::cli::_cached_version]} {
			set version $::nano::rpc::cli::_cached_version
		} else {
			set version "<unknown>"
		}

		return "\[$network\] nano-rpc $version> "
	} {*}$args
}

proc ::nano::rpc::cli::help args {
	tailcall ::nano::_cli::help rpc "" {*}$args

			}
			lappend response [join $bootstrapResponse "\n"]
		}
	}

	if {[lsearch -exact $args "-blocks"] != -1} {
		set blockCount [::nano::rpc::client block_count]
		set blockCountInfoCount [dict get $blockCount count]
		set blockCountInfoUnchecked [dict get $blockCount unchecked]
		set blockCountInfoTotal [expr {$blockCountInfoCount + $blockCountInfoUnchecked}]
		lappend blocksResponse "Blocks:"
		lappend blocksResponse "  Count     = $blockCountInfoCount"
		lappend blocksResponse "  Unchecked = $blockCountInfoUnchecked"
		lappend blocksResponse "  Total     = $blockCountInfoTotal"
		lappend response [join $blocksResponse "\n"]
	}

	return [join $response "\n\n"]
}

proc {::nano::rpc::cli::show network} args {
	foreach network {main beta} {
		set genesisBlock [::nano::block::dict::genesis $network]
		set genesisBlockHash [::nano::block::dict::toHash $genesisBlock -hex]
		catch {
			set check [dict create]
			set check [::nano::rpc::client block -hash $genesisBlockHash]
		}
		if {[dict exists $check contents]} {
			return $network
		}
	}
	error "Unable to locate genesis block"
}

proc {::nano::rpc::cli::show version} args {
	set versions [::nano::rpc::client version]

	set vendor [dict get $versions node_vendor]
	set vendorVersion [lindex [split $vendor] end]

		set peer [list address $peer port $peerPort]
		lappend result "  $peer: version $peerVersion"
	}

	return [join $result "\n"]
}

proc {::nano::rpc::cli::show node-id} args {
	set id [dict get [::nano::rpc::client node_id] "public"]
	return $id
}

proc ::nano::rpc::cli::rpc {action args} {
	set format "json"
	set endmarker [lsearch -exact $args "--"]
	if {$endmarker != -1} {
		set field [lrange $args $endmarker+1 end]
		set args [lrange $args 0 $endmarker-1]
		set format "dict"
	}

	set result [::nano::rpc::client $action -outputformat $format {*}$args]

	if {$format eq "json"} {
		set result [string trim $result "\n\r"]
	}

	if {[info exists field]} {
		set result [dict get $result {*}$field]
	}

	return $result
}

# Export namespaces
namespace eval ::nano::node::cli {
	namespace export -clear *
}

namespace eval ::nano::rpc::cli {