libnexakotlin/org.nexa.libnexakotlin/P2pClient

P2pClient

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

Constructors

P2pClient

constructor(chainSelector: ChainSelector, name: String, port: Int, logName: String, coCtxt: CoroutineContext, jobPool: ThreadJobPool = libNexaJobPool)

Types

Companion

object Companion

Properties

atomicWriter

val atomicWriter: iGate

aveLatency

@Volatile

var aveLatency: Double

beginTime

val beginTime: Long

When we first attempted to connect to this peer

bloomCount

var bloomCount: Int

bytesReceived

var bytesReceived: Long

bytesSent

var bytesSent: Long

capdHandlers

val capdHandlers: MutableMap<Long, Callbacker<List<CapdMsg>>>

capdHighestPriority

var capdHighestPriority: Double

capdLocalPriority

var capdLocalPriority: Double

capdQueryIdx

var capdQueryIdx: Long

capdRelayPriority

var capdRelayPriority: Double

capdSearches

val capdSearches: MutableMap<String, Long>

chainSelector

val chainSelector: ChainSelector

closed

@Volatile

var closed: Boolean

coCtxt

val coCtxt: CoroutineContext

curMsgCommand

val curMsgCommand: ByteArray

curMsgCookie

var curMsgCookie: Long

curMsgLen

var curMsgLen: Long

curNonce

var curNonce: Long

currentHeight

var currentHeight: Int

exclusiveHeaders

val exclusiveHeaders: iGate

headerCallback

@Volatile

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

incoming

@Volatile

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

jobPool

val jobPool: ThreadJobPool

lastPingCount

var lastPingCount: Long

lastReceiveTime

var lastReceiveTime: Long

When we last heard from this peer

lastSendTime

var lastSendTime: Long

When we last heard from this peer

localServices

var localServices: Long

logName

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

name

val name: String

onAddrCallback

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

onBlockCallback

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

onCapdInfo

val onCapdInfo: MutableSet<(P2pClient) -> Unit>

onHeadersCallback

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

onInvCallback

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

onMerkleBlockCallback

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

onRejectCallback

val onRejectCallback: Callbacker<RejectInfo>

installable callback for when some blockchain or connection state changes

onTxCallback

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

onVersionCallback

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

pingOutstanding

var pingOutstanding: Boolean

port

val port: Int

receivedData

var receivedData: BCHserialized

sendMsgCookie

var sendMsgCookie: AtomicInt

services

var services: Long

sock

var sock: iTcpSocket

subversion

var subversion: String

timeOffset

var timeOffset: Long

tokenInfoCallbacks

val tokenInfoCallbacks: MutableMap<Bytes, (reply: TokenInfoMsg?, error: String?) -> Unit>

txValidation

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

version

@Volatile

var version: Int

wantsTxRelayed

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

clear

fun clear()

clears all incoming messages

fun close()

connect

fun connect(timeout: Int = CONNECT_TIMEOUT): P2pClient

doIHandleThisMessage

fun doIHandleThisMessage(msgType: NetMsgType): Boolean

finalize

fun finalize()

get1TokenInfo

fun get1TokenInfo(gid: ByteArray, returned: (reply: TokenInfoMsg?, error: String?) -> Unit)

getHeaders

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

getTokenInfo