Node

implicit abstract def chainAppConfig: ChainAppConfig

abstract def getFilterCount: Future[Int]

abstract def getFiltersBetweenHeights(startHeight: Int, endHeight: Int): Future[Vector[FilterResponse]]

abstract def getHeightByBlockStamp(blockStamp: BlockStamp): Future[Int]

implicit abstract def nodeAppConfig: NodeAppConfig

abstract val peer: Peer

implicit abstract def system: ActorSystem

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addCallbacks(newCallbacks: NodeCallbacks): Node

final def asInstanceOf[T0]: T0

def broadcastTransaction(transaction: Transaction): Future[Unit]

Broadcasts the given transaction over the P2P network

def chainApiFromDb()(implicit executionContext: ExecutionContext): Future[ChainHandler]

This is constructing a chain api from disk every time we call this method This involves database calls which can be slow and expensive to construct our Blockchain

lazy val clientF: Future[P2PClient]

Unlike our chain api, this is cached inside our node object.

def clone(): AnyRef

def downloadBlocks(blockHashes: Vector[DoubleSha256Digest]): Future[Unit]

Fetches the given blocks from the peers and calls the appropriate callbacks when done.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit def executionContext: ExecutionContext

def finalize(): Unit

def getBestBlockHash(): Future[DoubleSha256DigestBE]

Gets the hash of the block that is what we consider "best"

def getBestHashBlockHeight()(implicit ec: ExecutionContext): Future[Int]

def getBlockHeight(blockHash: DoubleSha256DigestBE): Future[Option[Int]]

Gets the height of the given block

final def getClass(): Class[_]

def getNumberOfConfirmations(blockHashOpt: DoubleSha256DigestBE): Future[Option[Int]]

Gets number of confirmations for the given block hash

def hashCode(): Int

def isConnected: Future[Boolean]

Checks if we have a tcp connection with our peer

def isDisconnected: Future[Boolean]

def isInitialized: Future[Boolean]

Checks if we are fully initialized with our peer and have executed the handshake This means we can now send arbitrary messages to our peer

final def isInstanceOf[T0]: Boolean

def logger(implicit config: NodeAppConfig): MarkedLogger

final def ne(arg0: AnyRef): Boolean

def nodeCallbacks: NodeCallbacks

final def notify(): Unit

final def notifyAll(): Unit

lazy val peerMsgSenderF: Future[PeerMessageSender]

def send(msg: NetworkPayload): Future[Unit]

Sends the given P2P to our peer.

def start(): Future[Node]

Starts our node

def stop(): Future[Node]

Stops our node

def sync(): Future[Unit]

Starts to sync our node with our peer If our local best block hash is the same as our peers we will not sync, otherwise we will keep syncing until our best block hashes match up

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

lazy val txDAO: BroadcastAbleTransactionDAO

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit