BitcoindV16RpcClient

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit object ECPrivateKeyWrites extends Writes[ECPrivateKey]

This is here (and not in JsonWrriters) so that the implicit network val is accessible

def abandonTransaction(txid: DoubleSha256Digest): Future[Unit]

def abandonTransaction(txid: DoubleSha256DigestBE): Future[Unit]

def abortRescan(): Future[Unit]

def addMultiSigAddress(minSignatures: Int, keys: Vector[Either[ECPublicKey, P2PKHAddress]], account: String, addressType: AddressType): Future[MultiSigResult]

def addMultiSigAddress(minSignatures: Int, keys: Vector[Either[ECPublicKey, P2PKHAddress]], addressType: AddressType): Future[MultiSigResult]

def addMultiSigAddress(minSignatures: Int, keys: Vector[Either[ECPublicKey, P2PKHAddress]], account: String): Future[MultiSigResult]

def addMultiSigAddress(minSignatures: Int, keys: Vector[Either[ECPublicKey, P2PKHAddress]]): Future[MultiSigResult]

def addNode(address: URI, command: AddNodeArgument): Future[Unit]

final def asInstanceOf[T0]: T0

def backupWallet(destination: String): Future[Unit]

def bitcoindCall[T](command: String, parameters: List[JsValue] = List.empty, printError: Boolean = true)(implicit reader: Reads[T]): Future[T]

def buildRequest(instance: BitcoindInstance, methodName: String, params: JsArray): HttpRequest

def bumpFee(txid: DoubleSha256Digest, confTarget: Int, totalFee: Option[Satoshis], replaceable: Boolean, estimateMode: String): Future[BumpFeeResult]

def bumpFee(txid: DoubleSha256DigestBE, confTarget: Int = 6, totalFee: Option[Satoshis] = None, replaceable: Boolean = true, estimateMode: String = "UNSET"): Future[BumpFeeResult]

def clearBanned(): Future[Unit]

def clone(): AnyRef

def combineRawTransaction(txs: Vector[Transaction]): Future[Transaction]

lazy val confFile: Path

The configuration file of the Bitcoin Core daemon

def createMultiSig(minSignatures: Int, keys: Vector[ECPublicKey]): Future[MultiSigResult]

def createRawTransaction(inputs: Vector[TransactionInput], outputs: Map[BitcoinAddress, Bitcoins], locktime: Int = 0): Future[Transaction]

def createWallet(walletName: String, disablePrivateKeys: Boolean = false): Future[CreateWalletResult]

def decodeRawTransaction(transaction: Transaction): Future[RpcTransaction]

def decodeScript(script: ScriptPubKey): Future[DecodeScriptResult]

def disconnectNode(address: URI): Future[Unit]

def dumpPrivKey(address: BitcoinAddress): Future[ECPrivateKey]

def dumpWallet(filePath: String): Future[DumpWalletResult]

implicit val eCPrivateKeyWrites: Writes[ECPrivateKey]

def encryptWallet(passphrase: String): Future[String]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def estimateSmartFee(blocks: Int, mode: FeeEstimationMode = FeeEstimationMode.Ecnomical): Future[EstimateSmartFeeResult]

implicit val executor: ExecutionContext

def finalize(): Unit

def fundRawTransaction(transaction: Transaction, options: FundRawTransactionOptions): Future[FundRawTransactionResult]

def fundRawTransaction(transaction: Transaction): Future[FundRawTransactionResult]

def generateToAddress(blocks: Int, address: BitcoinAddress, maxTries: Int = 1000000): Future[Vector[DoubleSha256DigestBE]]

def getAccount(address: BitcoinAddress): Future[String]

def getAccountAddress(account: String): Future[BitcoinAddress]

def getAddedNodeInfo(node: URI): Future[Vector[Node]]

def getAddedNodeInfo: Future[Vector[Node]]

def getAddressInfo(address: BitcoinAddress): Future[AddressInfoResult]

def getAddressesByAccount(account: String): Future[Vector[BitcoinAddress]]

def getBalance: Future[Bitcoins]

def getBestBlockHash: Future[DoubleSha256DigestBE]

def getBlock(headerHash: DoubleSha256Digest): Future[GetBlockResult]

def getBlock(headerHash: DoubleSha256DigestBE): Future[GetBlockResult]

def getBlockChainInfo: Future[GetBlockChainInfoResult]

def getBlockCount: Future[Int]

def getBlockHash(height: Int): Future[DoubleSha256DigestBE]

def getBlockHeader(headerHash: DoubleSha256Digest): Future[GetBlockHeaderResult]

def getBlockHeader(headerHash: DoubleSha256DigestBE): Future[GetBlockHeaderResult]

def getBlockHeaderRaw(headerHash: DoubleSha256Digest): Future[BlockHeader]

def getBlockHeaderRaw(headerHash: DoubleSha256DigestBE): Future[BlockHeader]

def getBlockRaw(headerHash: DoubleSha256Digest): Future[Block]

def getBlockRaw(headerHash: DoubleSha256DigestBE): Future[Block]

def getBlockTemplate(request: Option[BlockTemplateRequest] = None): Future[GetBlockTemplateResult]

def getBlockWithTransactions(headerHash: DoubleSha256Digest): Future[GetBlockWithTransactionsResult]

def getBlockWithTransactions(headerHash: DoubleSha256DigestBE): Future[GetBlockWithTransactionsResult]

def getChainTips: Future[Vector[ChainTip]]

def getChainTxStats(blocks: Int, blockHash: DoubleSha256Digest): Future[GetChainTxStatsResult]

def getChainTxStats(blocks: Int, blockHash: DoubleSha256DigestBE): Future[GetChainTxStatsResult]

def getChainTxStats(blocks: Int): Future[GetChainTxStatsResult]

def getChainTxStats: Future[GetChainTxStatsResult]

final def getClass(): Class[_]

def getConnectionCount: Future[Int]

def getDaemon: BitcoindInstance

def getDifficulty: Future[BigDecimal]

def getMemPoolAncestors(txid: DoubleSha256Digest): Future[Vector[DoubleSha256DigestBE]]

def getMemPoolAncestors(txid: DoubleSha256DigestBE): Future[Vector[DoubleSha256DigestBE]]

def getMemPoolAncestorsVerbose(txid: DoubleSha256Digest): Future[Map[DoubleSha256DigestBE, GetMemPoolResult]]

def getMemPoolAncestorsVerbose(txid: DoubleSha256DigestBE): Future[Map[DoubleSha256DigestBE, GetMemPoolResult]]

def getMemPoolDescendants(txid: DoubleSha256Digest): Future[Vector[DoubleSha256DigestBE]]

def getMemPoolDescendants(txid: DoubleSha256DigestBE): Future[Vector[DoubleSha256DigestBE]]

def getMemPoolDescendantsVerbose(txid: DoubleSha256Digest): Future[Map[DoubleSha256DigestBE, GetMemPoolResult]]

def getMemPoolDescendantsVerbose(txid: DoubleSha256DigestBE): Future[Map[DoubleSha256DigestBE, GetMemPoolResult]]

def getMemPoolEntry(txid: DoubleSha256Digest): Future[GetMemPoolEntryResult]

def getMemPoolEntry(txid: DoubleSha256DigestBE): Future[GetMemPoolEntryResult]

def getMemPoolInfo: Future[GetMemPoolInfoResult]

def getMemoryInfo: Future[GetMemoryInfoResult]

def getMiningInfo: Future[GetMiningInfoResult]

def getNetTotals: Future[GetNetTotalsResult]

def getNetworkHashPS(blocks: Int = 120, height: Int = 1): Future[BigDecimal]

def getNetworkInfo: Future[GetNetworkInfoResult]

def getNewAddress(accountOrLabel: String, addressType: AddressType): Future[BitcoinAddress]

def getNewAddress(accountOrLabel: String): Future[BitcoinAddress]

def getNewAddress(addressType: AddressType): Future[BitcoinAddress]

def getNewAddress: Future[BitcoinAddress]

def getPayload(response: HttpResponse, command: String, request: HttpRequest, parameters: List[JsValue] = List.empty): Future[JsValue]

Parses the payload of the given response into JSON.

def getPeerInfo: Future[Vector[Peer]]

def getRawChangeAddress(addressType: AddressType): Future[BitcoinAddress]

def getRawChangeAddress: Future[BitcoinAddress]

def getRawMemPool: Future[Vector[DoubleSha256DigestBE]]

def getRawMemPoolWithTransactions: Future[Map[DoubleSha256DigestBE, GetMemPoolResult]]

def getRawTransaction(txid: DoubleSha256DigestBE, blockhash: Option[DoubleSha256DigestBE] = None): Future[GetRawTransactionResult]

def getRawTransactionRaw(txid: DoubleSha256DigestBE, blockhash: Option[DoubleSha256DigestBE] = None): Future[Transaction]

def getReceivedByAccount(account: String, confirmations: Int = 1): Future[Bitcoins]

def getReceivedByAddress(address: BitcoinAddress, minConfirmations: Int = 1): Future[Bitcoins]

def getTransaction(txid: DoubleSha256DigestBE, watchOnly: Boolean = false): Future[GetTransactionResult]

def getTxOut(txid: DoubleSha256DigestBE, vout: Int, includeMemPool: Boolean = true): Future[GetTxOutResult]

def getTxOutProof(txids: Vector[DoubleSha256DigestBE], headerHash: DoubleSha256DigestBE): Future[MerkleBlock]

def getTxOutProof(txids: Vector[DoubleSha256Digest], headerHash: DoubleSha256Digest): Future[MerkleBlock]

def getTxOutProof(txids: Vector[DoubleSha256DigestBE]): Future[MerkleBlock]

def getTxOutSetInfo: Future[GetTxOutSetInfoResult]

def getUnconfirmedBalance: Future[Bitcoins]

def getWalletInfo: Future[GetWalletInfoResult]

def hashCode(): Int

def help(rpcName: String = ""): Future[String]

def importAddress(address: BitcoinAddress, account: String = "", rescan: Boolean = true, p2sh: Boolean = false): Future[Unit]

def importMulti(requests: Vector[ImportMultiRequest], rescan: Boolean = true): Future[Vector[ImportMultiResult]]

implicit val importMultiAddressWrites: Writes[ImportMultiAddress]

implicit val importMultiRequestWrites: Writes[ImportMultiRequest]

def importPrivKey(key: ECPrivateKey, account: String = "", rescan: Boolean = true): Future[Unit]

def importPrunedFunds(transaction: Transaction, txOutProof: MerkleBlock): Future[Unit]

def importPubKey(pubKey: ECPublicKey, label: String = "", rescan: Boolean = true): Future[Unit]

def importWallet(filePath: String): Future[Unit]

val instance: BitcoindInstance

def invalidateBlock(blockHash: DoubleSha256Digest): Future[Unit]

def invalidateBlock(blockHash: DoubleSha256DigestBE): Future[Unit]

final def isInstanceOf[T0]: Boolean

def isStartedF: Future[Boolean]

Checks whether the underlying bitcoind daemon is running

def isStoppedF: Future[Boolean]

Checks whether the underlyind bitcoind daemon is stopped

def keyPoolRefill(keyPoolSize: Int = 100): Future[Unit]

def listAccounts(confirmations: Int = 1, includeWatchOnly: Boolean = false): Future[Map[String, Bitcoins]]

def listAddressGroupings: Future[Vector[Vector[RpcAddress]]]

def listBanned: Future[Vector[NodeBan]]

def listLockUnspent: Future[Vector[TransactionOutPoint]]

def listReceivedByAccount(confirmations: Int = 1, includeEmpty: Boolean = false, includeWatchOnly: Boolean = false): Future[Vector[ReceivedAccount]]

def listReceivedByAddress(confirmations: Int = 1, includeEmpty: Boolean = false, includeWatchOnly: Boolean = false): Future[Vector[ReceivedAddress]]

def listSinceBlock(headerHash: DoubleSha256Digest, confirmations: Int, includeWatchOnly: Boolean): Future[ListSinceBlockResult]

def listSinceBlock(headerHash: DoubleSha256Digest, includeWatchOnly: Boolean): Future[ListSinceBlockResult]

def listSinceBlock(headerHash: DoubleSha256Digest, confirmations: Int): Future[ListSinceBlockResult]

def listSinceBlock(headerHash: DoubleSha256Digest): Future[ListSinceBlockResult]

def listSinceBlock(headerHash: DoubleSha256DigestBE, confirmations: Int, includeWatchOnly: Boolean): Future[ListSinceBlockResult]

def listSinceBlock(headerHash: DoubleSha256DigestBE, includeWatchOnly: Boolean): Future[ListSinceBlockResult]

def listSinceBlock(headerHash: DoubleSha256DigestBE, confirmations: Int): Future[ListSinceBlockResult]

def listSinceBlock(headerHash: DoubleSha256DigestBE): Future[ListSinceBlockResult]

def listSinceBlock(headerHash: Option[DoubleSha256DigestBE] = None, confirmations: Int = 1, includeWatchOnly: Boolean = false): Future[ListSinceBlockResult]

def listSinceBlock: Future[ListSinceBlockResult]

def listTransactions(account: String = "*", count: Int = 10, skip: Int = 0, includeWatchOnly: Boolean = false): Future[Vector[ListTransactionsResult]]

def listUnspent(minConfirmations: Int, maxConfirmations: Int, addresses: Vector[BitcoinAddress]): Future[Vector[UnspentOutput]]

def listUnspent(addresses: Vector[BitcoinAddress]): Future[Vector[UnspentOutput]]

def listUnspent(minConfirmations: Int, maxConfirmations: Int): Future[Vector[UnspentOutput]]

def listUnspent: Future[Vector[UnspentOutput]]

def listWallets: Future[Vector[String]]

def lockUnspent(unlock: Boolean, outputs: Vector[LockUnspentOutputParameter]): Future[Boolean]

lazy val logFile: Path

The log file of the Bitcoin Core daemon

lazy val logger: Logger

def logging(include: Vector[String] = Vector.empty, exclude: Vector[String] = Vector.empty): Future[Map[String, Boolean]]

def logging: Future[Map[String, Boolean]]

implicit val materializer: ActorMaterializer

def move(fromAccount: String, toAccount: String, amount: CurrencyUnit, comment: String = ""): Future[Boolean]

final def ne(arg0: AnyRef): Boolean

implicit val network: NetworkParameters

final def notify(): Unit

final def notifyAll(): Unit

def ping(): Future[Unit]

def preciousBlock(headerHash: DoubleSha256Digest): Future[Unit]

def preciousBlock(headerHash: DoubleSha256DigestBE): Future[Unit]

def prioritiseTransaction(txid: DoubleSha256Digest, feeDelta: Satoshis): Future[Boolean]

def prioritiseTransaction(txid: DoubleSha256DigestBE, feeDelta: Satoshis): Future[Boolean]

def pruneBlockChain(height: Int): Future[Int]

def removePrunedFunds(txid: DoubleSha256Digest): Future[Unit]

def removePrunedFunds(txid: DoubleSha256DigestBE): Future[Unit]

def rescanBlockChain(start: Int, stop: Int): Future[RescanBlockChainResult]

def rescanBlockChain(start: Int): Future[RescanBlockChainResult]

def rescanBlockChain(): Future[RescanBlockChainResult]

def saveMemPool(): Future[Unit]

def sendFrom(fromAccount: String, toAddress: BitcoinAddress, amount: CurrencyUnit, confirmations: Int = 1, comment: String = "", toComment: String = ""): Future[DoubleSha256DigestBE]

def sendMany(amounts: Map[BitcoinAddress, CurrencyUnit], minconf: Int = 1, comment: String = "", subtractFeeFrom: Vector[BitcoinAddress] = Vector.empty): Future[DoubleSha256DigestBE]

def sendRawTransaction(transaction: Transaction, allowHighFees: Boolean = false): Future[DoubleSha256DigestBE]

def sendRequest(req: HttpRequest): Future[HttpResponse]

def sendToAddress(address: BitcoinAddress, amount: CurrencyUnit, localComment: String = "", toComment: String = "", subractFeeFromAmount: Boolean = false): Future[DoubleSha256DigestBE]

def setAccount(address: BitcoinAddress, account: String): Future[Unit]

def setBan(address: URI, command: SetBanCommand, banTime: Int = 86400, absolute: Boolean = false): Future[Unit]

def setNetworkActive(activate: Boolean): Future[Unit]

def setTxFee(feePerKB: Bitcoins): Future[Boolean]

def signMessage(address: P2PKHAddress, message: String): Future[String]

def signMessageWithPrivKey(key: ECPrivateKey, message: String): Future[String]

def signRawTransaction(transaction: Transaction, utxoDeps: Vector[SignRawTransactionOutputParameter], keys: Vector[ECPrivateKey], sigHash: HashType): Future[SignRawTransactionResult]

def signRawTransaction(transaction: Transaction, utxoDeps: Vector[SignRawTransactionOutputParameter], keys: Vector[ECPrivateKey]): Future[SignRawTransactionResult]

def signRawTransaction(transaction: Transaction, utxoDeps: Vector[SignRawTransactionOutputParameter]): Future[SignRawTransactionResult]

def signRawTransaction(transaction: Transaction): Future[SignRawTransactionResult]

def start(): Future[Unit]

Starts bitcoind on the local system.

def stop(): Future[String]

def submitBlock(block: Block): Future[Unit]

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

implicit val system: ActorSystem

def toString(): String

def uptime: Future[UInt32]

def validateAddress(address: BitcoinAddress): Future[ValidateAddressResult]

def verifyChain(level: Int = 3, blocks: Int = 6): Future[Boolean]

def verifyMessage(address: P2PKHAddress, signature: String, message: String): Future[Boolean]

def verifyTxOutProof(proof: MerkleBlock): Future[Vector[DoubleSha256DigestBE]]

def version: BitcoindVersion

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def walletLock(): Future[Unit]

def walletPassphrase(passphrase: String, seconds: Int): Future[Unit]

def walletPassphraseChange(currentPassphrase: String, newPassphrase: String): Future[Unit]

def generate(blocks: Int, maxTries: Int = 1000000): Future[Vector[DoubleSha256DigestBE]]