libnexakotlin/org.nexa.libnexakotlin/P2pClient

P2pClient

class P2pClient(val chainSelector: ChainSelector, val name: String, val port: Int, val logName: String, val coCtxt: CoroutineContext)

Constructors

constructor(chainSelector: ChainSelector, name: String, port: Int, logName: String, coCtxt: CoroutineContext)

Types

object Companion

Properties

val atomicWriter: iGate

val beginTime: Long

When we first attempted to connect to this peer

var bloomCount: Int

var bytesReceived: Long

var bytesSent: Long

val chainSelector: ChainSelector

var closed: Boolean

val coCtxt: CoroutineContext

var curMsgChecksum: Long

val curMsgCommand: ByteArray

var curMsgLen: Long

var curNonce: Long

var currentHeight: Int

exclusiveHeaders

val exclusiveHeaders: iGate

var headerCallback: (MutableList<out iBlockHeader>, P2pClient) -> Boolean?

var incoming: MutableMap<NetMsgType, MutableList<BCHserialized>>

var inp: ByteReadChannel?

var lastPingCount: Long

lastReceiveTime

var lastReceiveTime: Long

When we last heard from this peer

var localServices: Long

val logName: String

MESSAGE_HEADER_SIZE

var MESSAGE_HEADER_SIZE: Int

MISBEHAVING_BAD_MESSAGE_LIMIT

val MISBEHAVING_BAD_MESSAGE_LIMIT: Int = 10

MISBEHAVING_QUIET_LIMIT

val MISBEHAVING_QUIET_LIMIT: Int = 25

misbehavingBadMessageCount

var misbehavingBadMessageCount: Int

misbehavingQuietCount

var misbehavingQuietCount: Int

keep track of how often we got a message drop. If its too many times, drop the node

misbehavingReason

var misbehavingReason: BanReason

val name: String

val onAddrCallback: MutableList<(MutableList<PossibleConnection>, P2pClient) -> Unit>

onBlockCallback

val onBlockCallback: MutableList<(iBlock, P2pClient) -> Unit>

onHeadersCallback

var onHeadersCallback: MutableList<(MutableList<out iBlockHeader>, P2pClient) -> Boolean>

val onInvCallback: MutableList<(MutableList<Inv>, P2pClient) -> Unit>

onMerkleBlockCallback

val onMerkleBlockCallback: MutableList<(iMerkleBlock, P2pClient) -> Unit>

val onTxCallback: MutableList<(MutableList<out iTransaction>, P2pClient) -> Unit>

onVersionCallback

var onVersionCallback: MutableList<(P2pClient) -> Unit>

var out: ByteWriteChannel?

pingOutstanding

var pingOutstanding: Boolean

var receivedData: BCHserialized

selectorManager

var selectorManager: SelectorManager

var services: Long

var sock: Socket?

var sockBuilder: TcpSocketBuilder

var subversion: String

var timeOffset: Long

val txValidation: MutableMap<Long, suspend (String) -> Unit>

var version: Int

var wantsTxRelayed: Boolean

Functions

cleanupExclusiveHeaders

fun cleanupExclusiveHeaders(cb: (MutableList<iBlockHeader>, P2pClient) -> Boolean)

If you issue a getHeaders() but then give up waiting, call this function

fun clear()

clears all incoming messages

fun close()

fun connect(timeout: Int = CONNECT_TIMEOUT): P2pClient

coProcessForever

suspend fun coProcessForever()

doIHandleThisMessage

fun doIHandleThisMessage(msgType: NetMsgType): Boolean

fun getHeaders(loc: BlockLocator, stopAt: Hash256, cb: (MutableList<out iBlockHeader>, P2pClient) -> Boolean)

Get block headers. This function only allows one outstanding getheaders per node due to protocol issues. Call @cleanupExclusiveHeaders() if you stop waiting (if cb is never called). Its Ok to unnecessarily call cleanupExclusiveHeaders

fun isAlive(): Boolean

misbehavingBadMessage

fun misbehavingBadMessage(howBad: Int = 1)

Provide feedback that this node is not responding to our requests

misbehavingQuiet

fun misbehavingQuiet(howBad: Int = 1)

Provide feedback that this node is not responding to our requests

fun process(): Boolean

processAddrMessage

fun processAddrMessage(msg: BCHserialized)

processBlockMessage

fun processBlockMessage(msg: BCHserialized)

fun processForever()

processGetDataMessage

fun processGetDataMessage(msg: BCHserialized)

processHeadersMessage

fun processHeadersMessage(msg: BCHserialized)

processInvMessage

fun processInvMessage(msg: BCHserialized)

processMerkleBlockMessage

fun processMerkleBlockMessage(msg: BCHserialized)

processTxMessage

fun processTxMessage(msg: BCHserialized)

processTxValResponse

fun processTxValResponse(msg: BCHserialized)

processVersionMessage

fun processVersionMessage(msg: BCHserialized)

provideHeadersInsteadOfInvs

fun provideHeadersInsteadOfInvs()

Tell the peer we want headers not INVs for new blocks

fun receive(): Boolean

fun send(command: ByteArray, msg: ByteArray)

fun send(command: ByteArray, msg: BCHserialized)

fun send(command: NetMsgType, msg: BCHserialized = BCHserialized(SerializationType.NETWORK))

sendBloomFilter

fun sendBloomFilter(filter: ByteArray, inBloomCount: Int = -1)

fun sendGetAddr()

Send a GETADDR request message

fun sendGetData(invs: Collection<Inv>)

fun sendGetHeaders(loc: BlockLocator, stopAt: Hash256)

fun sendInv(invs: MutableList<Inv>)

fun sendTx(tx: ByteArray)

fun sendTxVal(tx: iTransaction, nonce: Long? = null, handler: suspend (String) -> Unit)

fun sendVersion()

@ExperimentalTime

open override fun toString(): String

fun waitForReady()