SimpleTransactionModule

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val InitialBalance: Long

val TransactionSizeLength: Int

lazy val accountWatchingSupport: Boolean

final def asInstanceOf[T0]: T0

lazy val balancesSupport: Boolean

val blockStorage: BlockStorageImpl

def broadcastTransaction(tx: SignedTransaction): ValidationResult

Validate transaction according to the State and send it to network

def clearFromUnconfirmed(data: StoredInBlock): Unit

def clearIncorrectTransactions(): Unit

Removes too old or invalid transactions from UnconfirmedTransactionsPool

def clone(): AnyRef

def createPayment(sender: PrivateKeyAccount, recipient: Account, amount: Long, fee: Long): PaymentTransaction

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formBlockData(transactions: StoredInBlock): TransactionsBlockField

def genesisData: BlockField[StoredInBlock]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isValid(block: Block): Boolean

def isValid(tx: Transaction, blockTime: Long): Boolean

Check whether tx is valid on current state and not expired yet

def issueAsset(request: IssueRequest, wallet: Wallet): Try[IssueTransaction]

def log: LoggerFacade

final def ne(arg0: AnyRef): Boolean

val networkController: ActorRef

final def notify(): Unit

final def notifyAll(): Unit

def onNewOffchainTransaction(transaction: Transaction): Unit

def packUnconfirmed(heightOpt: Option[Int]): StoredInBlock

def parseArraySize(bytes: Array[Byte], position: Int): (Array[Byte], Int)

def parseBlockFields(blockFields: BlockField[StoredInBlock]): StoredInBlock

def parseBytes(bytes: Array[Byte]): Try[TransactionsBlockField]

In Lagonaki, transaction-related data is just sequence of transactions.

def parseOption(bytes: Array[Byte], position: Int, length: Int): (Option[Array[Byte]], Int)

def putUnconfirmedIfNew(tx: Transaction): Boolean

def reissueAsset(request: ReissueRequest, wallet: Wallet): Try[ReissueTransaction]

implicit val settings: TransactionSettings with Settings

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

def toString(): String

def transactions(block: Block): StoredInBlock

def transferAsset(request: TransferRequest, wallet: Wallet): Try[TransferTransaction]

def unconfirmedTxs: Seq[Transaction]

val utxStorage: UnconfirmedTransactionsStorage

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def createPayment(payment: Payment, wallet: Wallet): Option[PaymentTransaction]