BlockChain

abstract def append(modifier: B): Try[(BT, Option[RollbackTo[B]])]

abstract def blockAt(height: Int): Option[B]

abstract def chainScore(): Score

Quality score of a best chain, e.g.

abstract def children(blockId: ModifierId): Seq[B]

abstract def compare(other: SI): History.HistoryComparisonResult.Value

Whether another's node syncinfo shows that another node is ahead or behind ours

abstract def height(): Int

Height of the a chain, or a longest chain in an explicit block-tree

abstract def heightOf(blockId: ModifierId): Option[Int]

abstract def modifierById(modifierId: ModifierId): Option[B]

abstract def score(block: B): Score

Score of concrete block

abstract def syncInfo(answer: Boolean): SI

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def applicable(modifier: B): Boolean

Whether a modifier could be applied to the history

final def asInstanceOf[T0]: T0

def averageDelay(blockId: ModifierId, blockNum: Int): Try[Long]

Average delay in milliseconds between last blockNum blocks starting from block

def clone(): AnyRef

def contains(id: ModifierId): Boolean

Whether the history contains a modifier with the given id

def contains(persistentModifier: B): Boolean

Whether the history contains the given modifier

def continuation(openSurface: Seq[(ModifierTypeId, ModifierId)], size: Int): Option[Seq[B]]

def continuationIds(openSurface: Seq[(ModifierTypeId, ModifierId)], size: Int): Option[Seq[(ModifierTypeId, ModifierId)]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

lazy val genesisBlock: B

final def getClass(): Class[_]

def hashCode(): Int

def heightOf(block: B): Option[Int]

Height of a block if it's in the blocktree

def isEmpty: Boolean

Is there's no history, even genesis block

final def isInstanceOf[T0]: Boolean

def lastBlock: B

Block with maximum blockchain score

def lastBlockIds(howMany: Int): Seq[ModifierId]

def lastBlocks(howMany: Int): Seq[B]

def log: Logger

def lookForward(parentSignature: ModifierId, howMany: Int): Seq[ModifierId]

Return howMany blocks starting from parentSignature

def modifierById(modifierId: String): Option[B]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def openSurfaceIds(): Seq[ModifierId]

def parent(block: B, back: Int = 1): Option[B]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit