Get the current list of electrum protocol connections It is better to use the connection getter functions, rather than accessing this list. This is meant for display, health and statistics, rather than access

exclusiveNodeSet

var exclusiveNodeSet: MutableSet<String>?

getElectrumServerCandidate

var getElectrumServerCandidate: (ChainSelector) -> IpPort?

supply electrum server ip and ports if we need them

headersCallback

var headersCallback: (List<out iBlockHeader>) -> Unit?

a block header has arrived

initializingCnxns

@Volatile

var initializingCnxns: MutableList<P2pClient>

This connection is coming up

invCallback

var invCallback: (List<Inv>) -> Unit?

a notification of an object's existence has arrived

netType

val netType: ChainSelector

originalDnsSeeds

var originalDnsSeeds: Array<String>?

If a seeder was supplied, store its domain name here

OUT_OF_NODES_DELAY

val OUT_OF_NODES_DELAY: Long

p2pCnxns

open override val p2pCnxns: List<P2pClient>

Get the current list of peer-to-peer connections It is better to use the connection getter functions, rather than accessing this list. This is meant for display, health and statistics, rather than access

partialBlockCallback

var partialBlockCallback: (List<iMerkleBlock>) -> Unit?

A partially complete MerkleBlock arrived

preferredCnxn

@Volatile

var preferredCnxn: P2pClient?

if this is not null, try all communications to this connection first

preferredNodeSet

var preferredNodeSet: MutableSet<String>?

processingThread

var processingThread: iThread?

prospectLimit

var prospectLimit: Int

once we get into 0 priority prospects, if the length of prospects is this number then loop back to 0. This stops us from trying more than a few unlikely connections (provided by ADDR messages)

prospects

val prospects: MutableMap<String, PossibleConnection>

reconnectTimer

val reconnectTimer: LeakyBucket

schedule connection retries: we'll take 5 per retry, so this results in a try every 5 seconds on average, but you can build up a max of 5 quick tries.

SIMULTANEOUS_CNXN_INIT

val SIMULTANEOUS_CNXN_INIT: Int = 5

size

open override val size: Int

Returns the number of currently connected peers

txCallback

var txCallback: (List<out iTransaction>) -> Unit?

If a message of a certain type comes in, call this callback with the message for processing

wakingDelay

val wakingDelay: iGate

Functions

add

fun add(pc: PossibleConnection)

open override fun add(ip: String, port: Int, priority: Int, keepForever: Boolean)

Add a potential node into the list of possible connections

addBlockHandler

open override fun addBlockHandler(cb: (List<out iBlockHeader>) -> Unit)

Add a callback to handle incoming blocks -- downcast the parameter to either BCHBlock or MerkleBlock

addBlockHeadersHandler

open override fun addBlockHeadersHandler(cb: (List<out iBlockHeader>) -> Unit)

Add a callback to handle incoming block headers

addInvHandler

open override fun addInvHandler(cb: (List<Inv>) -> Unit)

Add a callback to handle incoming inventory (right now, only blocks, the CnxnMgr auto-handles tx INVs)

addPartialBlockHandler

open override fun addPartialBlockHandler(cb: (List<out iMerkleBlock>) -> Unit)

Add a callback to handle incoming incomplete MerkleBlocks

addTxHandler

open override fun addTxHandler(cb: (List<out iTransaction>) -> Unit)

Add a callback to handle incoming transactions

ban

fun ban(nodeIp: String, bd: BanData)

broadcastTransaction

open override fun broadcastTransaction(tx: ByteArray)

cleanupConnections

fun cleanupConnections()

clear

open override fun clear()

clear all incoming messages, drop all connections

clearBanned

open override fun clearBanned(ip: String?)

remove a node (or all nodes if ip==null) from the ban table

cnxnProcessor

fun cnxnProcessor()

connectedTo

open override fun connectedTo(ip: String, port: Int): Boolean

Returns true if we are connected to this node/port

coReport

open suspend override fun coReport(problemCnxn: P2pClient?)

wake up and analyze my connections, especially the optional passed connection

dropWorstConnections

fun dropWorstConnections(count: Int)

disconnect from the lowest N performing peers

exclusiveNodes

open override fun exclusiveNodes(nodes: Set<String>?)

Exclusively connect to a single node. All other existing connections will be dropped

find

fun find(name: String, portp: Int = -1): P2pClient?

Given a name and port, return the connection if we have one, or null if we don't. This includes pending connections

getAnotherElectrum

open override fun getAnotherElectrum(notThese: Set<ElectrumClient>): ElectrumClient?

Returns a random connection from the connection manager's node set, but not one of these. Returns null if no connections left

getAnotherNode

open override fun getAnotherNode(notThese: Set<P2pClient>): P2pClient?

Returns a random connection from the connection manager's node set, but not one of these. Returns null if no connections left

getElectrum

open override fun getElectrum(): ElectrumClient

Returns a random connection from the connection manager's node set. Tries 10 candidates then throws @ref ElectrumNoNodesException

getNode

open override fun getNode(block: Int): P2pClient

Returns a random connection from the connection manager's node set

getp2p

open suspend override fun getp2p(): P2pClient

Returns a random connection from the connection manager's node set

grabAndCheckConnection

fun grabAndCheckConnection(): P2pClient?

Loops looking for an alive connection, returns null if no connections are left

initialConnect

fun initialConnect(prospect: PossibleConnection, cnxn: P2pClient)

mapConnections

open override fun <T> mapConnections(mapfilter: (P2pClient) -> T?): List<T>

Returns a list of connected peers. This API works simultaneously as map (transformation) and filter functions and calls the passed function on every item in the connection list.

misbehaving

open override fun misbehaving(cnxn: P2pClient, reason: BanReason, count: Int)

report a node as having a problem

numPeers

open override fun ~~numPeers~~(): Int

Returns the number of currently connected peers

preferNodes

open override fun preferNodes(nodes: Set<String>?)

Prefer a particular node. An existing connections may be dropped to make room

processAddrMessage

fun processAddrMessage(newPeers: MutableList<PossibleConnection>, source: P2pClient)

processBlockMessage

fun processBlockMessage(blocks: MutableList<out iBlock>, node: P2pClient)

processHeaderMessage

fun processHeaderMessage(hdrs: List<out iBlockHeader>, node: P2pClient)

processInvMessage

fun processInvMessage(invs: MutableList<Inv>, node: P2pClient)

processMerkleBlockMessage

fun processMerkleBlockMessage(blocks: MutableList<out iMerkleBlock>, node: P2pClient)

processTxMessage

fun processTxMessage(txs: MutableList<out iTransaction>, node: P2pClient)

reassessBannedNodes

@ExperimentalTime

fun reassessBannedNodes()

report

open override fun report(problemCnxn: P2pClient?)

wake up and analyze my connections, especially the optional passed connection

restart

open override fun restart()

Restart connection manager operation after suspend may have killed threads

returnElectrum

open override fun returnElectrum(e: ElectrumClient)

Returns an electrum connection. DO NOT USE AFTER RETURNING

sendTransaction

open override fun sendTransaction(tx: ByteArray)

Send a transaction to one node

sendTransactions

open override fun sendTransactions(txes: List<ByteArray>): Boolean

Broadcast a set of transactions to the network, returns true if transactions were sent (otherwise no nodes are available).

setAddressFilter

open override fun setAddressFilter(bloom: ByteArray, onBloomInstalled: () -> Unit?)

tell all nodes, including future connections, that we are only interested in things that match this bloom filter. To enable multiple wallets to use the same Blockchain, do NOT use this API directly. Instead use the blockchain API

start

open override fun start()

Start the connection manager processing thread

stop

open override fun stop()

Stop the connection manager processing thread asynchronously