mirrors/bitcoin-s
1
0
Fork 0
mirror of https://github.com/bitcoin-s/bitcoin-s.git synced 2025-02-23 22:56:52 +01:00
Code Issues Projects Releases Packages Wiki Activity

Remove support for v19 of bitcoind (#4991)

Browse source 
* Remove support for v19 of bitcoind

* Remove downloading v19 bitcoind inside of bitcoind-rpc.sbt

* Clean up docs

* Move unit tests in BitcoindV19RpcClientTest into other test files so we don't remove them, these rpcs are supported in future versions of bitcoind
This commit is contained in:
Chris Stewart 2023-02-16 10:27:56 -06:00 • committed by GitHub
parent a9e17684fe
commit af349d2179
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
43 changed files with 167 additions and 776 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
app-commons/src/main/scala/org/bitcoins/commons/jsonmodels/bitcoind/NetworkResult.scala
View file

@ -114,24 +114,6 @@ sealed trait Peer extends NetworkResult {
def minfeefilter: Option[SatoshisPerKiloByte]
}
case class PeerPreV20(
id: Int,
networkInfo: PeerNetworkInfoPreV21,
version: Int,
subver: String,
inbound: Boolean,
addnode: Boolean,
startingheight: Int,
banscore: Int,
synced_headers: Int,
synced_blocks: Int,
inflight: Vector[Int],
whitelisted: Boolean,
bytessent_per_msg: Map[String, Int],
bytesrecv_per_msg: Map[String, Int],
minfeefilter: Option[SatoshisPerKiloByte])
extends Peer
case class PeerV20(
id: Int,
networkInfo: PeerNetworkInfoPreV21,

5
app-commons/src/main/scala/org/bitcoins/commons/jsonmodels/bitcoind/WalletResult.scala
View file

@ -26,11 +26,6 @@ trait MultiSigResult extends WalletResult {
def redeemScript: ScriptPubKey
}
case class MultiSigResultPreV20(
address: BitcoinAddress,
redeemScript: ScriptPubKey)
extends MultiSigResult
case class MultiSigResultPostV20(
address: BitcoinAddress,
redeemScript: ScriptPubKey,

20
app-commons/src/main/scala/org/bitcoins/commons/serializers/JsonSerializers.scala
View file

@ -245,22 +245,6 @@ object JsonSerializers {
implicit val peerNetworkInfoPostV21Reads: Reads[PeerNetworkInfoPostV21] =
Json.reads[PeerNetworkInfoPostV21]
implicit val peerPreV20Reads: Reads[PeerPreV20] = ((__ \ "id").read[Int] and
__.read[PeerNetworkInfoPreV21] and
(__ \ "version").read[Int] and
(__ \ "subver").read[String] and
(__ \ "inbound").read[Boolean] and
(__ \ "addnode").read[Boolean] and
(__ \ "startingheight").read[Int] and
(__ \ "banscore").read[Int] and
(__ \ "synced_headers").read[Int] and
(__ \ "synced_blocks").read[Int] and
(__ \ "inflight").read[Vector[Int]] and
(__ \ "whitelisted").read[Boolean] and
(__ \ "bytessent_per_msg").read[Map[String, Int]] and
(__ \ "bytesrecv_per_msg").read[Map[String, Int]] and
(__ \ "minfeefilter").readNullable[SatoshisPerKiloByte])(PeerPreV20)
implicit val peerV20Reads: Reads[PeerV20] = ((__ \ "id").read[Int] and
__.read[PeerNetworkInfoPreV21] and
(__ \ "version").read[Int] and
@ -404,10 +388,6 @@ object JsonSerializers {
JsString(o.toString)
}
// Wallet Models
implicit val multiSigPreV20Reads: Reads[MultiSigResultPreV20] =
Json.reads[MultiSigResultPreV20]
implicit val multiSigPostV20Reads: Reads[MultiSigResultPostV20] =
Json.reads[MultiSigResultPostV20]

6
bitcoind-rpc-test/src/test/scala/org/bitcoins/rpc/common/BitcoindVersionTest.scala
View file

@ -1,7 +1,7 @@
package org.bitcoins.rpc.common
import org.bitcoins.rpc.client.common.BitcoindVersion
import org.bitcoins.rpc.client.common.BitcoindVersion.{V19, V20, V21}
import org.bitcoins.rpc.client.common.BitcoindVersion.{V20, V21}
import org.bitcoins.testkit.util.BitcoindRpcTest
class BitcoindVersionTest extends BitcoindRpcTest {
@ -15,9 +15,5 @@ class BitcoindVersionTest extends BitcoindRpcTest {
val version = BitcoindVersion.fromNetworkVersion(200309)
assert(version.equals(V20))
}
it should "return version 19" in {
val version = BitcoindVersion.fromNetworkVersion(190100)
assert(version.equals(V19))
}
}

30
bitcoind-rpc-test/src/test/scala/org/bitcoins/rpc/common/BlockchainRpcTest.scala
View file

@ -1,15 +1,18 @@
package org.bitcoins.rpc.common
import org.bitcoins.commons.jsonmodels.bitcoind.{GetBlockChainInfoResultPostV23}
import org.bitcoins.commons.jsonmodels.bitcoind.GetBlockChainInfoResultPostV23
import org.bitcoins.commons.jsonmodels.bitcoind.RpcOpts.AddressType
import org.bitcoins.core.config.RegTest
import org.bitcoins.core.currency.Bitcoins
import org.bitcoins.core.gcs.{BlockFilter, FilterType}
import org.bitcoins.core.number.UInt32
import org.bitcoins.testkit.rpc.{
BitcoindFixturesCachedPairNewest,
BitcoindRpcTestUtil
}
import scala.concurrent.Future
class BlockchainRpcTest extends BitcoindFixturesCachedPairNewest {
behavior of "BlockchainRpc"
@ -217,4 +220,29 @@ class BlockchainRpcTest extends BitcoindFixturesCachedPairNewest {
assert(medianTime > oneHourAgo)
}
}
it should "get a block filter given a block hash" in { nodePair =>
val client = nodePair.node1
for {
blocks <- client.generate(1)
blockFilter <- client.getBlockFilter(blocks.head, FilterType.Basic)
block <- client.getBlockRaw(blocks.head)
txs <- Future.sequence(
block.transactions
.filterNot(_.isCoinbase)
.map(tx => client.getTransaction(tx.txIdBE)))
prevFilter <- client.getBlockFilter(block.blockHeader.previousBlockHashBE,
FilterType.Basic)
} yield {
val pubKeys = txs.flatMap(_.hex.outputs.map(_.scriptPubKey)).toVector
val filter = BlockFilter(block, pubKeys)
assert(filter.hash == blockFilter.filter.hash)
assert(
blockFilter.header == filter
.getHeader(prevFilter.header.flip)
.hash
.flip)
}
}
}

19
bitcoind-rpc-test/src/test/scala/org/bitcoins/rpc/common/MultiWalletRpcTest.scala
View file

@ -11,11 +11,10 @@ import org.bitcoins.core.wallet.fee.SatoshisPerByte
import org.bitcoins.crypto.{ECPrivateKey, ECPublicKey}
import org.bitcoins.rpc._
import org.bitcoins.rpc.client.common._
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.rpc.config.{BitcoindInstanceLocal, BitcoindInstanceRemote}
import org.bitcoins.rpc.util.{NodePair, RpcUtil}
import org.bitcoins.testkit.rpc.{
BitcoindFixturesCachedPairV19,
BitcoindFixturesCachedPairNewest,
BitcoindRpcTestUtil
}
import org.bitcoins.testkit.util.AkkaUtil
@ -27,7 +26,7 @@ import scala.concurrent.Future
import scala.concurrent.duration.DurationInt
/** These tests are all copied over from WalletRpcTest and changed to be for multi-wallet */
class MultiWalletRpcTest extends BitcoindFixturesCachedPairV19 {
class MultiWalletRpcTest extends BitcoindFixturesCachedPairNewest {
val walletName = "other"
@ -42,15 +41,15 @@ class MultiWalletRpcTest extends BitcoindFixturesCachedPairV19 {
new FutureOutcome(f)
}
private val cachedSetupClientsF: Future[NodePair[BitcoindV19RpcClient]] = {
private val cachedSetupClientsF: Future[NodePair[BitcoindRpcClient]] = {
clientsF.flatMap(setupWalletClient)
}
/** We need to test bitcoin core's wallet specific features, so we need to set that up */
private def setupWalletClient(pair: NodePair[BitcoindV19RpcClient]): Future[
NodePair[BitcoindV19RpcClient]] = {
val NodePair(client: BitcoindV19RpcClient,
walletClient: BitcoindV19RpcClient) = pair
private def setupWalletClient(pair: NodePair[BitcoindRpcClient]): Future[
NodePair[BitcoindRpcClient]] = {
val NodePair(client: BitcoindRpcClient, walletClient: BitcoindRpcClient) =
pair
for {
_ <- walletClient.createWallet(walletName)
_ <- walletClient.encryptWallet(password, Some(walletName))
@ -73,9 +72,7 @@ class MultiWalletRpcTest extends BitcoindFixturesCachedPairV19 {
wallets2 <- client.listWallets
_ = require(wallets.size == 2)
_ = require(wallets2.size == 2)
} yield NodePair[BitcoindV19RpcClient](
client,
started.asInstanceOf[BitcoindV19RpcClient])
} yield NodePair[BitcoindRpcClient](client, started)
}
behavior of "WalletRpc"

47
bitcoind-rpc-test/src/test/scala/org/bitcoins/rpc/common/WalletRpcTest.scala
View file

@ -1,7 +1,10 @@
package org.bitcoins.rpc.common
import org.bitcoins.commons.jsonmodels.bitcoind.RpcOpts
import org.bitcoins.commons.jsonmodels.bitcoind.RpcOpts.AddressType
import org.bitcoins.commons.jsonmodels.bitcoind.RpcOpts.{
AddressType,
WalletFlag
}
import org.bitcoins.core.config.RegTest
import org.bitcoins.core.crypto.ECPrivateKeyUtil
import org.bitcoins.core.currency.{Bitcoins, CurrencyUnit, Satoshis}
@ -9,6 +12,7 @@ import org.bitcoins.core.number.UInt32
import org.bitcoins.core.protocol.script._
import org.bitcoins.core.protocol.transaction._
import org.bitcoins.core.protocol.{Bech32Address, BitcoinAddress, P2PKHAddress}
import org.bitcoins.core.psbt.PSBT
import org.bitcoins.core.wallet.fee.SatoshisPerByte
import org.bitcoins.core.wallet.signer.BitcoinSigner
import org.bitcoins.core.wallet.utxo.{ECSignatureParams, P2WPKHV0InputInfo}
@ -657,6 +661,47 @@ class WalletRpcTest extends BitcoindFixturesCachedPairV21 {
}
}
it should "be able to set the wallet flag 'avoid_reuse'" in { nodePair =>
val client = nodePair.node1
for {
unspentPre <- client.listUnspent
result <- client.setWalletFlag(WalletFlag.AvoidReuse, value = true)
unspentPost <- client.listUnspent
} yield {
assert(result.flag_name == "avoid_reuse")
assert(result.flag_state)
assert(unspentPre.forall(utxo => utxo.reused.isEmpty))
assert(unspentPost.forall(utxo => utxo.reused.isDefined))
}
}
it should "create a wallet with a passphrase" in { nodePair =>
val client = nodePair.node1
for {
_ <- client.createWallet("suredbits", passphrase = "stackingsats")
wallets <- client.listWallets
} yield {
assert(wallets.contains("suredbits"))
}
}
it should "check to see if the utxoUpdate input has been updated" in {
nodePair =>
val client = nodePair.node1
val descriptor =
"pk(0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798)"
val psbt =
PSBT.fromBase64(
"cHNidP8BACoCAAAAAAFAQg8AAAAAABepFG6Rty1Vk+fUOR4v9E6R6YXDFkHwhwAAAAAAAA==")
for {
result <- client.utxoUpdatePsbt(psbt, Seq(descriptor))
} yield {
assert(result == psbt)
}
}
def startClient(client: BitcoindRpcClient): Future[Unit] = {
BitcoindRpcTestUtil.startServers(Vector(client))
}

127
bitcoind-rpc-test/src/test/scala/org/bitcoins/rpc/v19/BitcoindV19RpcClientTest.scala
View file

@ -1,127 +0,0 @@
package org.bitcoins.rpc.v19
import org.bitcoins.commons.jsonmodels.bitcoind.RpcOpts.WalletFlag
import org.bitcoins.commons.jsonmodels.bitcoind.{
Bip9SoftforkPostV19,
GetBlockChainInfoResultPostV19
}
import org.bitcoins.core.config.RegTest
import org.bitcoins.core.gcs.{BlockFilter, FilterType}
import org.bitcoins.core.psbt.PSBT
import org.bitcoins.rpc.client.common.BitcoindVersion
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.testkit.rpc.BitcoindFixturesFundedCachedV19
import scala.concurrent.Future
class BitcoindV19RpcClientTest extends BitcoindFixturesFundedCachedV19 {
behavior of "BitcoindV19RpcClient"
it should "be able to start a V19 bitcoind instance" in {
client: BitcoindV19RpcClient =>
for {
v <- client.version
} yield {
assert(v == BitcoindVersion.V19)
}
}
it should "get a block filter given a block hash" in {
client: BitcoindV19RpcClient =>
for {
blocks <- client.generate(1)
blockFilter <- client.getBlockFilter(blocks.head, FilterType.Basic)
block <- client.getBlockRaw(blocks.head)
txs <- Future.sequence(
block.transactions
.filterNot(_.isCoinbase)
.map(tx => client.getTransaction(tx.txIdBE)))
prevFilter <- client.getBlockFilter(
block.blockHeader.previousBlockHashBE,
FilterType.Basic)
} yield {
val pubKeys = txs.flatMap(_.hex.outputs.map(_.scriptPubKey)).toVector
val filter = BlockFilter(block, pubKeys)
assert(filter.hash == blockFilter.filter.hash)
assert(
blockFilter.header == filter
.getHeader(prevFilter.header.flip)
.hash
.flip)
}
}
it should "be able to get the balances" in { client: BitcoindV19RpcClient =>
for {
immatureBalance <- client.getBalances
_ <- client.generate(1)
newImmatureBalance <- client.getBalances
} yield {
val blockReward = 50
assert(immatureBalance.mine.immature.toBigDecimal >= 0)
assert(
immatureBalance.mine.trusted.toBigDecimal + blockReward == newImmatureBalance.mine.trusted.toBigDecimal)
}
}
it should "be able to get blockchain info" in {
client: BitcoindV19RpcClient =>
for {
info <- client.getBlockChainInfo
bestHash <- client.getBestBlockHash
} yield {
assert(info.isInstanceOf[GetBlockChainInfoResultPostV19])
val preV19Info = info.asInstanceOf[GetBlockChainInfoResultPostV19]
assert(preV19Info.chain == RegTest)
assert(preV19Info.softforks.size >= 5)
assert(
preV19Info.softforks.values.exists(
_.isInstanceOf[Bip9SoftforkPostV19]))
assert(preV19Info.bestblockhash == bestHash)
}
}
it should "be able to set the wallet flag 'avoid_reuse'" in {
client: BitcoindV19RpcClient =>
for {
unspentPre <- client.listUnspent
result <- client.setWalletFlag(WalletFlag.AvoidReuse, value = true)
unspentPost <- client.listUnspent
} yield {
assert(result.flag_name == "avoid_reuse")
assert(result.flag_state)
assert(unspentPre.forall(utxo => utxo.reused.isEmpty))
assert(unspentPost.forall(utxo => utxo.reused.isDefined))
}
}
it should "create a wallet with a passphrase" in {
client: BitcoindV19RpcClient =>
for {
_ <- client.createWallet("suredbits", passphrase = "stackingsats")
wallets <- client.listWallets
} yield {
assert(wallets.contains("suredbits"))
}
}
it should "check to see if the utxoUpdate input has been updated" in {
client: BitcoindV19RpcClient =>
val descriptor =
"pk(0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798)"
val psbt =
PSBT.fromBase64(
"cHNidP8BACoCAAAAAAFAQg8AAAAAABepFG6Rty1Vk+fUOR4v9E6R6YXDFkHwhwAAAAAAAA==")
for {
result <- client.utxoUpdatePsbt(psbt, Seq(descriptor))
} yield {
assert(result == psbt)
}
}
}

11
bitcoind-rpc/bitcoind-rpc.sbt
View file

@ -23,7 +23,7 @@ TaskKeys.downloadBitcoind := {
}
val versions =
List("24.0", "23.0", "22.0", "0.21.1", "0.20.1", "0.19.0.1")
List("24.0", "23.0", "22.0", "0.21.1", "0.20.1")
logger.debug(
s"(Maybe) downloading Bitcoin Core binaries for versions: ${versions.mkString(",")}")
@ -99,8 +99,7 @@ TaskKeys.downloadBitcoind := {
"23.0" -> "2cca490c1f2842884a3c5b0606f179f9f937177da4eadd628e3f7fd7e25d26d0",
"22.0" -> "59ebd25dd82a51638b7a6bb914586201e67db67b919b2a1ff08925a7936d1b16",
"0.21.1" -> "366eb44a7a0aa5bd342deea215ec19a184a11f2ca22220304ebb20b9c8917e2b",
"0.20.1" -> "376194f06596ecfa40331167c39bc70c355f960280bd2a645fdbf18f66527397",
"0.19.0.1" -> "732cc96ae2e5e25603edf76b8c8af976fe518dd925f7e674710c6c8ee5189204"
"0.20.1" -> "376194f06596ecfa40331167c39bc70c355f960280bd2a645fdbf18f66527397"
)
else if (Properties.isMac)
Map(
@ -114,8 +113,7 @@ TaskKeys.downloadBitcoind := {
"c816780583009a9dad426dc0c183c89be9da98906e1e2c7ebae91041c1aaaaf3"),
"22.0" -> "2744d199c3343b2d94faffdfb2c94d75a630ba27301a70e47b0ad30a7e0155e9",
"0.21.1" -> "1ea5cedb64318e9868a66d3ab65de14516f9ada53143e460d50af428b5aec3c7",
"0.20.1" -> "b9024dde373ea7dad707363e07ec7e265383204127539ae0c234bff3a61da0d1",
"0.19.0.1" -> "a64e4174e400f3a389abd76f4d6b1853788730013ab1dedc0e64b0a0025a0923"
"0.20.1" -> "b9024dde373ea7dad707363e07ec7e265383204127539ae0c234bff3a61da0d1"
)
else if (Properties.isWin)
Map(
@ -123,8 +121,7 @@ TaskKeys.downloadBitcoind := {
"23.0" -> "004b2e25b21e0f14cbcce6acec37f221447abbb3ea7931c689e508054bfc6cf6",
"22.0" -> "9485e4b52ed6cebfe474ab4d7d0c1be6d0bb879ba7246a8239326b2230a77eb1",
"0.21.1" -> "94c80f90184cdc7e7e75988a55b38384de262336abd80b1b30121c6e965dc74e",
"0.20.1" -> "e59fba67afce011d32b5d723a3a0be12da1b8a34f5d7966e504520c48d64716d",
"0.19.0.1" -> "7706593de727d893e4b1e750dc296ea682ccee79acdd08bbc81eaacf3b3173cf"
"0.20.1" -> "e59fba67afce011d32b5d723a3a0be12da1b8a34f5d7966e504520c48d64716d"
)
else sys.error(s"Unsupported OS: ${Properties.osName}")

13
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/common/BitcoindRpcClient.scala
View file

@ -22,7 +22,7 @@ import org.bitcoins.crypto.{
DoubleSha256DigestBE,
StringFactory
}
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.rpc.client.v19.V19BlockFilterRpc
import org.bitcoins.rpc.client.v20.BitcoindV20RpcClient
import org.bitcoins.rpc.client.v21.BitcoindV21RpcClient
import org.bitcoins.rpc.client.v22.BitcoindV22RpcClient
@ -62,7 +62,8 @@ class BitcoindRpcClient(override val instance: BitcoindInstance)(implicit
with UTXORpc
with WalletRpc
with PsbtRpc
with UtilRpc {
with UtilRpc
with V19BlockFilterRpc {
private val syncing = new AtomicBoolean(false)
@ -344,7 +345,6 @@ object BitcoindRpcClient {
def fromVersion(version: BitcoindVersion, instance: BitcoindInstance)(implicit
system: ActorSystem): BitcoindRpcClient = {
val bitcoind = version match {
case BitcoindVersion.V19 => BitcoindV19RpcClient.withActorSystem(instance)
case BitcoindVersion.V20 => BitcoindV20RpcClient.withActorSystem(instance)
case BitcoindVersion.V21 => BitcoindV21RpcClient.withActorSystem(instance)
case BitcoindVersion.V22 => BitcoindV22RpcClient.withActorSystem(instance)
@ -373,14 +373,10 @@ object BitcoindVersion extends StringFactory[BitcoindVersion] with Logging {
val newest: BitcoindVersion = V24
val standard: Vector[BitcoindVersion] =
Vector(V19, V20, V21, V22, V23, V24)
Vector(V20, V21, V22, V23, V24)
val known: Vector[BitcoindVersion] = standard
case object V19 extends BitcoindVersion {
override def toString: String = "v0.19"
}
case object V20 extends BitcoindVersion {
override def toString: String = "v0.20"
}
@ -419,7 +415,6 @@ object BitcoindVersion extends StringFactory[BitcoindVersion] with Logging {
def fromNetworkVersion(int: Int): BitcoindVersion = {
//need to translate the int 210100 (as an example) to a BitcoindVersion
int.toString.substring(0, 2) match {
case "19" => V19
case "20" => V20
case "21" => V21
case "22" => V22

4
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/common/BlockchainRpc.scala
View file

@ -29,7 +29,7 @@ trait BlockchainRpc { self: Client =>
def getBlockChainInfo: Future[GetBlockChainInfoResult] = {
self.version.flatMap {
case V22 | V21 | V20 | V19 =>
case V22 | V21 | V20 =>
bitcoindCall[GetBlockChainInfoResultPostV19]("getblockchaininfo")
case V23 | V24 | Unknown =>
bitcoindCall[GetBlockChainInfoResultPostV23]("getblockchaininfo")
@ -83,7 +83,7 @@ trait BlockchainRpc { self: Client =>
"getblock",
List(JsString(headerHash.hex), isVerboseJsonObject))
case V19 | V20 | V21 =>
case V20 | V21 =>
bitcoindCall[GetBlockWithTransactionsResultPreV22](
"getblock",
List(JsString(headerHash.hex), isVerboseJsonObject))

8
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/common/MempoolRpc.scala
View file

@ -36,7 +36,7 @@ trait MempoolRpc { self: Client =>
bitcoindCall[Map[DoubleSha256DigestBE, GetMemPoolResultPostV23]](
"getmempoolancestors",
List(JsString(txid.hex), JsBoolean(true)))
case V22 | V21 | V20 | V19 | Unknown =>
case V22 | V21 | V20 | Unknown =>
bitcoindCall[Map[DoubleSha256DigestBE, GetMemPoolResultPostV19]](
"getmempoolancestors",
List(JsString(txid.hex), JsBoolean(true)))
@ -67,7 +67,7 @@ trait MempoolRpc { self: Client =>
bitcoindCall[Map[DoubleSha256DigestBE, GetMemPoolResultPostV23]](
"getmempooldescendants",
List(JsString(txid.hex), JsBoolean(true)))
case V22 | V21 | V20 | V19 | Unknown =>
case V22 | V21 | V20 | Unknown =>
bitcoindCall[Map[DoubleSha256DigestBE, GetMemPoolResultPostV19]](
"getmempooldescendants",
List(JsString(txid.hex), JsBoolean(true)))
@ -86,7 +86,7 @@ trait MempoolRpc { self: Client =>
case V24 | V23 | V24 | Unknown =>
bitcoindCall[GetMemPoolEntryResultPostV23]("getmempoolentry",
List(JsString(txid.hex)))
case V22 | V21 | V20 | V19 | Unknown =>
case V22 | V21 | V20 | Unknown =>
bitcoindCall[GetMemPoolEntryResultPostV19]("getmempoolentry",
List(JsString(txid.hex)))
}
@ -129,7 +129,7 @@ trait MempoolRpc { self: Client =>
bitcoindCall[Map[DoubleSha256DigestBE, GetMemPoolResultPostV23]](
"getrawmempool",
List(JsBoolean(true)))
case V22 | V21 | V20 | V19 | Unknown =>
case V22 | V21 | V20 | Unknown =>
bitcoindCall[Map[DoubleSha256DigestBE, GetMemPoolResultPostV19]](
"getrawmempool",
List(JsBoolean(true)))

41
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/common/MultisigRpc.scala
View file

@ -3,8 +3,7 @@ package org.bitcoins.rpc.client.common
import org.bitcoins.commons.jsonmodels.bitcoind.RpcOpts.AddressType
import org.bitcoins.commons.jsonmodels.bitcoind.{
MultiSigResult,
MultiSigResultPostV20,
MultiSigResultPreV20
MultiSigResultPostV20
}
import org.bitcoins.commons.serializers.JsonSerializers._
import org.bitcoins.commons.serializers.JsonWriters._
@ -40,17 +39,11 @@ trait MultisigRpc { self: Client =>
JsArray(keys.map(keyToString)),
JsString(account)) ++ addressType.map(Json.toJson(_)).toList
self.version.flatMap {
case V24 | V23 | V22 | V21 | V20 | Unknown =>
bitcoindCall[MultiSigResultPostV20](
"addmultisigaddress",
params,
uriExtensionOpt = walletNameOpt.map(walletExtension))
case V19 =>
bitcoindCall[MultiSigResultPreV20]("addmultisigaddress",
params,
uriExtensionOpt =
walletNameOpt.map(walletExtension))
self.version.flatMap { case V24 | V23 | V22 | V21 | V20 | Unknown =>
bitcoindCall[MultiSigResultPostV20]("addmultisigaddress",
params,
uriExtensionOpt =
walletNameOpt.map(walletExtension))
}
}
@ -83,20 +76,14 @@ trait MultisigRpc { self: Client =>
keys: Vector[ECPublicKey],
addressType: AddressType,
walletNameOpt: Option[String] = None): Future[MultiSigResult] = {
self.version.flatMap {
case V24 | V23 | V22 | V21 | V20 | Unknown =>
bitcoindCall[MultiSigResultPostV20](
"createmultisig",
List(JsNumber(minSignatures),
Json.toJson(keys.map(_.hex)),
Json.toJson(addressType)),
uriExtensionOpt = walletNameOpt.map(walletExtension)
)
case V19 =>
bitcoindCall[MultiSigResultPreV20](
"createmultisig",
List(JsNumber(minSignatures), Json.toJson(keys.map(_.hex))),
uriExtensionOpt = walletNameOpt.map(walletExtension))
self.version.flatMap { case V24 | V23 | V22 | V21 | V20 | Unknown =>
bitcoindCall[MultiSigResultPostV20](
"createmultisig",
List(JsNumber(minSignatures),
Json.toJson(keys.map(_.hex)),
Json.toJson(addressType)),
uriExtensionOpt = walletNameOpt.map(walletExtension)
)
}
}
}

4
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/common/P2PRpc.scala
View file

@ -68,8 +68,6 @@ trait P2PRpc { self: Client =>
bitcoindCall[Vector[PeerPostV21]]("getpeerinfo")
case V20 =>
bitcoindCall[Vector[PeerV20]]("getpeerinfo")
case V19 =>
bitcoindCall[Vector[PeerPreV20]]("getpeerinfo")
}
}
@ -79,8 +77,6 @@ trait P2PRpc { self: Client =>
bitcoindCall[Vector[NodeBanPostV22]]("listbanned")
case V21 | V20 =>
bitcoindCall[Vector[NodeBanPostV20]]("listbanned")
case V19 =>
bitcoindCall[Vector[NodeBanPreV20]]("listbanned")
}
}

2
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/common/PsbtRpc.scala
View file

@ -88,7 +88,7 @@ trait PsbtRpc {
self.version.flatMap {
case V22 | V23 | V24 | Unknown =>
bitcoindCall[DecodePsbtResultV22]("decodepsbt", List(Json.toJson(psbt)))
case V19 | V20 | V21 =>
case V20 | V21 =>
bitcoindCall[DecodePsbtResultPreV22]("decodepsbt",
List(Json.toJson(psbt)))
}

4
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/common/RawTransactionRpc.scala
View file

@ -47,7 +47,7 @@ trait RawTransactionRpc { self: Client =>
bitcoindCall[RpcTransactionV22]("decoderawtransaction",
List(JsString(transaction.hex)))
case V19 | V20 | V21 =>
case V20 | V21 =>
bitcoindCall[RpcTransactionPreV22]("decoderawtransaction",
List(JsString(transaction.hex)))
}
@ -104,7 +104,7 @@ trait RawTransactionRpc { self: Client =>
self.version.flatMap {
case V22 | V23 | V24 | Unknown =>
bitcoindCall[GetRawTransactionResultV22]("getrawtransaction", params)
case V19 | V20 | V21 =>
case V20 | V21 =>
bitcoindCall[GetRawTransactionResultPreV22]("getrawtransaction", params)
}

5
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/common/TransactionRpc.scala
View file

@ -8,7 +8,6 @@ import org.bitcoins.core.protocol.blockchain.MerkleBlock
import org.bitcoins.crypto.{DoubleSha256Digest, DoubleSha256DigestBE}
import org.bitcoins.rpc.client.common.BitcoindVersion.{
Unknown,
V19,
V20,
V21,
V22,
@ -94,7 +93,7 @@ trait TransactionRpc { self: Client =>
"gettxout",
List(JsString(txid.hex), JsNumber(vout), JsBoolean(includeMemPool)))
case V19 | V20 | V21 =>
case V20 | V21 =>
bitcoindCall[GetTxOutResultPreV22](
"gettxout",
List(JsString(txid.hex), JsNumber(vout), JsBoolean(includeMemPool)))
@ -112,7 +111,7 @@ trait TransactionRpc { self: Client =>
"gettxout",
List(JsString(txid.hex), JsNumber(vout), JsBoolean(includeMemPool)))
case V19 | V20 | V21 =>
case V20 | V21 =>
bitcoindCall[GetTxOutResultPreV22](
"gettxout",
List(JsString(txid.hex), JsNumber(vout), JsBoolean(includeMemPool)))

6
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/common/UtilRpc.scala
View file

@ -25,7 +25,7 @@ trait UtilRpc { self: Client =>
case V22 | V23 | V24 | Unknown =>
bitcoindCall[DecodeScriptResultV22]("decodescript",
List(Json.toJson(script)))
case V19 | V20 | V21 =>
case V20 | V21 =>
bitcoindCall[DecodeScriptResultPreV22]("decodescript",
List(Json.toJson(script)))
}
@ -36,7 +36,7 @@ trait UtilRpc { self: Client =>
version.flatMap {
case V24 | V23 | V22 | V21 | Unknown =>
bitcoindCall[Map[String, IndexInfoResult]]("getindexinfo")
case V19 | V20 =>
case V20 =>
Future.failed(
new RuntimeException(
s"getIndexInfo is only for version V21+, got $version"))
@ -49,7 +49,7 @@ trait UtilRpc { self: Client =>
bitcoindCall[Map[String, IndexInfoResult]](
"getindexinfo",
List(JsString(indexName))).map(_.head._2)
case V19 | V20 =>
case V20 =>
Future.failed(
new RuntimeException(
s"getIndexInfo is only for version V21+, got $version"))

6
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/common/WalletRpc.scala
View file

@ -169,7 +169,7 @@ trait WalletRpc { self: Client =>
bitcoindCall[GetWalletInfoResultPostV22](
"getwalletinfo",
uriExtensionOpt = walletName.map(walletExtension))
case BitcoindVersion.V19 | BitcoindVersion.V20 | BitcoindVersion.V21 =>
case BitcoindVersion.V20 | BitcoindVersion.V21 =>
bitcoindCall[GetWalletInfoResultPreV22](
"getwalletinfo",
uriExtensionOpt = walletName.map(walletExtension))
@ -404,7 +404,7 @@ trait WalletRpc { self: Client =>
JsBoolean(avoidReuse),
JsBoolean(descriptors))
)
case V21 | V20 | V19 | Unknown =>
case V21 | V20 | Unknown =>
bitcoindCall[CreateWalletResult](
"createwallet",
List(JsString(walletName),
@ -419,7 +419,7 @@ trait WalletRpc { self: Client =>
address: BitcoinAddress,
walletNameOpt: Option[String] = None): Future[AddressInfoResult] = {
self.version.flatMap {
case V19 | V20 | Unknown =>
case V20 | Unknown =>
bitcoindCall[AddressInfoResultPostV18](
"getaddressinfo",
List(JsString(address.value)),

2
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/v18/V18AssortedRpc.scala
View file

@ -33,7 +33,7 @@ trait V18AssortedRpc {
bitcoindCall[Vector[GetNodeAddressesResultPostV22]](
"getnodeaddresses",
List(Json.toJson(count)))
case BitcoindVersion.V19 | BitcoindVersion.V20 | BitcoindVersion.V21 =>
case BitcoindVersion.V20 | BitcoindVersion.V21 =>
bitcoindCall[Vector[GetNodeAddressesResultPreV22]](
"getnodeaddresses",
List(Json.toJson(count)))

148
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/v19/BitcoindV19RpcClient.scala
View file

@ -1,148 +0,0 @@
package org.bitcoins.rpc.client.v19
import akka.actor.ActorSystem
import org.bitcoins.commons.jsonmodels.bitcoind.{
RpcOpts,
SignRawTransactionResult
}
import org.bitcoins.commons.serializers.JsonSerializers._
import org.bitcoins.commons.serializers.JsonWriters._
import org.bitcoins.core.api.chain.ChainQueryApi
import org.bitcoins.core.api.chain.ChainQueryApi.FilterResponse
import org.bitcoins.core.api.chain.db.CompactFilterDb
import org.bitcoins.core.gcs.FilterType
import org.bitcoins.core.protocol.transaction.Transaction
import org.bitcoins.core.util.FutureUtil
import org.bitcoins.crypto.{DoubleSha256DigestBE, ECPrivateKey, HashType}
import org.bitcoins.rpc.client.common.{
BitcoindRpcClient,
BitcoindVersion,
DescriptorRpc,
PsbtRpc
}
import org.bitcoins.rpc.config.BitcoindInstance
import play.api.libs.json._
import scala.concurrent.Future
import scala.util.Try
/** Class for creating a BitcoindV19 instance that can access RPCs
*/
class BitcoindV19RpcClient(override val instance: BitcoindInstance)(implicit
actorSystem: ActorSystem)
extends BitcoindRpcClient(instance)
with DescriptorRpc
with PsbtRpc
with V19BlockFilterRpc {
override def getFiltersBetweenHeights(
startHeight: Int,
endHeight: Int): Future[Vector[ChainQueryApi.FilterResponse]] = {
val allHeights = startHeight.to(endHeight)
def f(range: Vector[Int]): Future[Vector[FilterResponse]] = {
val filterFs = range.map { height =>
for {
hash <- getBlockHash(height)
filter <- getBlockFilter(hash, FilterType.Basic)
} yield {
FilterResponse(filter.filter, hash, height)
}
}
Future.sequence(filterFs)
}
FutureUtil.batchAndSyncExecute(elements = allHeights.toVector,
f = f,
batchSize = FutureUtil.getParallelism)
}
override def getFilterCount(): Future[Int] = getBlockCount
override def getFilterHeaderCount(): Future[Int] = getBlockCount
override def getFilter(
hash: DoubleSha256DigestBE): Future[Option[CompactFilterDb]] = {
for {
header <- getBlockHeader(hash)
filter <- getBlockFilter(hash, FilterType.Basic)
} yield Some(filter.filterDb(header.height))
}
override def getFiltersAtHeight(
height: Int): Future[Vector[CompactFilterDb]] = {
for {
hash <- getBlockHash(height)
filter <- getBlockFilter(hash, FilterType.Basic)
} yield Vector(filter.filterDb(height))
}
override lazy val version: Future[BitcoindVersion.V19.type] =
Future.successful(BitcoindVersion.V19)
/** $signRawTx
*
* This RPC call signs the raw transaction with keys found in
* the Bitcoin Core wallet.
*/
def signRawTransactionWithWallet(
transaction: Transaction,
utxoDeps: Vector[RpcOpts.SignRawTransactionOutputParameter] =
Vector.empty,
sigHash: HashType = HashType.sigHashAll
): Future[SignRawTransactionResult] =
bitcoindCall[SignRawTransactionResult]("signrawtransactionwithwallet",
List(JsString(transaction.hex),
Json.toJson(utxoDeps),
Json.toJson(sigHash)))
/** $signRawTx
*
* This RPC call signs the raw transaction with keys provided
* manually.
*/
def signRawTransactionWithKey(
transaction: Transaction,
keys: Vector[ECPrivateKey],
utxoDeps: Vector[RpcOpts.SignRawTransactionOutputParameter] =
Vector.empty,
sigHash: HashType = HashType.sigHashAll
): Future[SignRawTransactionResult] =
bitcoindCall[SignRawTransactionResult]("signrawtransactionwithkey",
List(JsString(transaction.hex),
Json.toJson(keys),
Json.toJson(utxoDeps),
Json.toJson(sigHash)))
}
object BitcoindV19RpcClient {
/** Creates an RPC client from the given instance.
*
* Behind the scenes, we create an actor system for
* you. You can use `withActorSystem` if you want to
* manually specify an actor system for the RPC client.
*/
def apply(instance: BitcoindInstance): BitcoindV19RpcClient = {
implicit val system =
ActorSystem.create(BitcoindRpcClient.ActorSystemName)
withActorSystem(instance)
}
/** Creates an RPC client from the given instance,
* together with the given actor system. This is for
* advanced users, where you need fine grained control
* over the RPC client.
*/
def withActorSystem(instance: BitcoindInstance)(implicit
system: ActorSystem): BitcoindV19RpcClient =
new BitcoindV19RpcClient(instance)(system)
def fromUnknownVersion(
rpcClient: BitcoindRpcClient): Try[BitcoindV19RpcClient] =
Try {
new BitcoindV19RpcClient(rpcClient.instance)(rpcClient.system)
}
}

28
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/client/v20/V20MultisigRpc.scala
View file

@ -36,12 +36,8 @@ trait V20MultisigRpc extends MultisigRpc { self: Client =>
JsArray(keys.map(keyToString)),
JsString(account)) ++ addressType.map(Json.toJson(_)).toList
self.version.flatMap {
case V20 | V21 | V22 | V23 | V24 | Unknown =>
bitcoindCall[MultiSigResultPostV20]("addmultisigaddress", params)
case version @ V19 =>
throw new RuntimeException(
s"Cannot use v20MultisigRpc on an older version, got $version")
self.version.flatMap { case V20 | V21 | V22 | V23 | V24 | Unknown =>
bitcoindCall[MultiSigResultPostV20]("addmultisigaddress", params)
}
}
@ -75,18 +71,14 @@ trait V20MultisigRpc extends MultisigRpc { self: Client =>
keys: Vector[ECPublicKey],
addressType: AddressType,
walletNameOpt: Option[String] = None): Future[MultiSigResultPostV20] = {
self.version.flatMap {
case V20 | V21 | V22 | V23 | V24 | Unknown =>
bitcoindCall[MultiSigResultPostV20](
"createmultisig",
List(JsNumber(minSignatures),
Json.toJson(keys.map(_.hex)),
Json.toJson(addressType)),
uriExtensionOpt = walletNameOpt.map(walletExtension)
)
case version @ V19 =>
throw new RuntimeException(
s"Cannot use v20MultisigRpc on an older version, got $version")
self.version.flatMap { case V20 | V21 | V22 | V23 | V24 | Unknown =>
bitcoindCall[MultiSigResultPostV20](
"createmultisig",
List(JsNumber(minSignatures),
Json.toJson(keys.map(_.hex)),
Json.toJson(addressType)),
uriExtensionOpt = walletNameOpt.map(walletExtension)
)
}
}
}

3
bitcoind-rpc/src/main/scala/org/bitcoins/rpc/config/BitcoindInstance.scala
View file

@ -56,9 +56,6 @@ sealed trait BitcoindInstanceLocal extends BitcoindInstance {
.last
foundVersion match {
case _: String
if foundVersion.startsWith(BitcoindVersion.V19.toString) =>
BitcoindVersion.V19
case _: String
if foundVersion.startsWith(BitcoindVersion.V20.toString) =>
BitcoindVersion.V20

6
docs/chain/chain-query-api.md
View file

@ -15,7 +15,7 @@ import org.bitcoins.core.protocol.transaction.Transaction
import org.bitcoins.core.wallet.fee._
import org.bitcoins.feeprovider._
import org.bitcoins.node._
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.rpc.client.common.BitcoindRpcClient
import org.bitcoins.rpc.config._
import org.bitcoins.testkit.BitcoinSTestAppConfig
org.bitcoins.testkit.chain.MockChainQueryApi
@ -75,10 +75,8 @@ implicit val ec: ExecutionContextExecutor = system.dispatcher
implicit val walletConf: WalletAppConfig =
BitcoinSTestAppConfig.getNeutrinoTestConfig().walletConf
// let's use a helper method to get a v19 bitcoind
// and a ChainApi
val instance = BitcoindInstanceLocal.fromConfigFile(BitcoindConfig.DEFAULT_CONF_FILE)
val bitcoind = BitcoindV19RpcClient(instance)
val bitcoind = BitcoindRpcClient(instance)
val nodeApi = MockNodeApi.mock
// This function can be used to create a callback for when our chain api receives a transaction, block, or

15
docs/chain/filter-sync.md
View file

@ -27,10 +27,11 @@ import akka.actor.ActorSystem
import org.bitcoins.core.gcs._
import org.bitcoins.core.protocol.blockchain.BlockHeader
import org.bitcoins.chain.blockchain.sync._
import org.bitcoins.rpc.config._
import org.bitcoins.rpc.client.common.BitcoindRpcClient
import org.bitcoins.testkit.BitcoinSTestAppConfig
import org.bitcoins.testkit.chain._
import org.bitcoins.testkit.chain.fixture.BitcoindBlockFilterRpcChainHandler
import org.bitcoins.testkit.chain.fixture.BitcoindBaseVersionChainHandlerViaRpc
```
@ -55,10 +56,10 @@ implicit val system = ActorSystem(s"filter-sync-example")
implicit val ec = system.dispatcher
implicit val chainAppConfig = BitcoinSTestAppConfig.getNeutrinoTestConfig().chainConf
//let's use a helper method to get a v19 bitcoind
//instance and a chainApi
val bitcoindWithChainApiF: Future[BitcoindBlockFilterRpcChainHandler] = {
ChainUnitTest.createBitcoindV19ChainHandler()
val instance = BitcoindInstanceLocal.fromConfigFile(BitcoindConfig.DEFAULT_CONF_FILE)
val bitcoind = BitcoindRpcClient(instance)
val bitcoindWithChainApiF: Future[BitcoindBaseVersionChainHandlerViaRpc] = {
ChainUnitTest.createChainApiWithBitcoindRpc(bitcoind)
}
val bitcoindF = bitcoindWithChainApiF.map(_.bitcoindRpc)
val chainApiF = bitcoindWithChainApiF.map(_.chainHandler)
@ -114,7 +115,7 @@ val resultF = for {
resultF.onComplete { _ =>
for {
c <- bitcoindWithChainApiF
_ <- ChainUnitTest.destroyBitcoindV19ChainApi(c)
_ <- ChainUnitTest.destroyBitcoindChainApiViaRpc(c)
_ <- system.terminate()
} yield ()
}

1
docs/core/txbuilder.md
View file

@ -12,7 +12,6 @@ import org.bitcoins.core._
import number._
import currency._
import org.bitcoins.crypto._
import script.crypto._
import protocol.transaction._
import protocol.script._

5
docs/node/node-api.md
View file

@ -12,10 +12,9 @@ import org.bitcoins.core.wallet.fee._
import org.bitcoins.core.util._
import org.bitcoins.feeprovider._
import org.bitcoins.node._
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.rpc.client.common.BitcoindRpcClient
import org.bitcoins.rpc.config._
import org.bitcoins.testkit.BitcoinSTestAppConfig
import org.bitcoins.testkit.wallet.BitcoinSWalletTest
import org.bitcoins.wallet.Wallet
import org.bitcoins.wallet.config.WalletAppConfig
import org.bitcoins.testkit.chain.MockChainQueryApi
@ -55,7 +54,7 @@ implicit val walletConf: WalletAppConfig =
// let's use a helper method to get a v19 bitcoind
// and a ChainApi
val instance = BitcoindInstanceLocal.fromConfigFile(BitcoindConfig.DEFAULT_CONF_FILE)
val bitcoind = BitcoindV19RpcClient(instance)
val bitcoind = BitcoindRpcClient(instance)
val chainApi = MockChainQueryApi.mock
val aesPasswordOpt = Some(AesPassword.fromString("password"))

1
docs/node/node.md
View file

@ -44,7 +44,6 @@ For your node to be able to service these filters you will need set
import akka.actor.ActorSystem
import org.bitcoins.core.protocol.blockchain.Block
import org.bitcoins.node._
import org.bitcoins.node.networking.peer._
import org.bitcoins.rpc.client.common.BitcoindVersion
import org.bitcoins.testkit.node._
import org.bitcoins.testkit.node.fixture._

4
docs/testkit/testkit.md
View file

@ -38,9 +38,7 @@ implicit val system = ActorSystem("bitcoind-testkit-example")
implicit val ec = system.dispatcher
//pick our bitcoind version we want to spin up
//you can pick older versions if you want
//we support versions 16-19
val bitcoindV = BitcoindVersion.V19
val bitcoindV = BitcoindVersion.newest
//create an instance
val instance = BitcoindRpcTestUtil.instance(versionOpt = Some(bitcoindV))

7
docs/wallet/wallet-callbacks.md
View file

@ -37,7 +37,7 @@ import org.bitcoins.crypto._
import org.bitcoins.core.protocol.transaction.Transaction
import org.bitcoins.core.wallet.fee._
import org.bitcoins.feeprovider._
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.rpc.client.common.BitcoindRpcClient
import org.bitcoins.rpc.config.BitcoindInstanceLocal
import org.bitcoins.testkit.BitcoinSTestAppConfig
import org.bitcoins.wallet._
@ -52,10 +52,7 @@ implicit val ec: ExecutionContextExecutor = system.dispatcher
implicit val walletConf: WalletAppConfig =
BitcoinSTestAppConfig.getNeutrinoTestConfig().walletConf
// let's use a helper method to get a v19 bitcoind
// and a ChainApi
val bitcoind = BitcoindV19RpcClient(BitcoindInstanceLocal.fromConfFile())
val bitcoind = BitcoindRpcClient(BitcoindInstanceLocal.fromConfFile())
val aesPasswordOpt = Some(AesPassword.fromString("password"))
// Here is a super simple example of a callback, this could be replaced with anything, from

1
docs/wallet/wallet-rescan.md
View file

@ -43,7 +43,6 @@ You can download this with bitcoin-s by doing `sbt downloadBitcoind`
```scala mdoc:invisible
import org.bitcoins.testkit.chain.MockChainQueryApi
import org.bitcoins.testkit.BitcoinSTestAppConfig
import org.bitcoins.testkit.fixtures._
import org.bitcoins.testkit.wallet._
import org.bitcoins.rpc.client.common.BitcoindVersion
import org.bitcoins.server.BitcoinSAppConfig

3
docs/wallet/wallet-sync.md
View file

@ -77,9 +77,6 @@ import org.bitcoins.crypto._
import org.bitcoins.feeprovider._
import org.bitcoins.keymanager.config._
import org.bitcoins.keymanager.bip39._
import org.bitcoins.wallet._
import org.bitcoins.wallet.config._
import org.bitcoins.wallet.sync._

2
docs/wallet/wallet.md
View file

@ -60,7 +60,6 @@ import org.bitcoins.core.protocol.transaction._
import org.bitcoins.core.currency._
import org.bitcoins.core.wallet.fee._
import org.bitcoins.feeprovider._
import org.bitcoins.keymanager.bip39._
import org.bitcoins.rpc.client.common.BitcoindRpcClient
import org.bitcoins.rpc.config._
import org.bitcoins.wallet.config.WalletAppConfig
@ -69,7 +68,6 @@ import org.bitcoins.wallet.Wallet
import com.typesafe.config.ConfigFactory
import java.nio.file.Files
import java.time.Instant
import scala.concurrent._
import akka.actor.ActorSystem

16
testkit/src/main/scala/org/bitcoins/testkit/chain/ChainUnitTest.scala
View file

@ -16,8 +16,8 @@ import org.bitcoins.core.p2p.CompactFilterMessage
import org.bitcoins.core.protocol.blockchain.{Block, BlockHeader}
import org.bitcoins.core.util.FutureUtil
import org.bitcoins.crypto.DoubleSha256DigestBE
import org.bitcoins.rpc.client.common.{BitcoindRpcClient, BitcoindVersion}
import org.bitcoins.rpc.client.v19.{BitcoindV19RpcClient, V19BlockFilterRpc}
import org.bitcoins.rpc.client.common.{BitcoindRpcClient}
import org.bitcoins.rpc.client.v19.{V19BlockFilterRpc}
import org.bitcoins.testkit.chain.ChainUnitTest.createChainHandler
import org.bitcoins.testkit.chain.fixture._
import org.bitcoins.testkit.chain.models.{
@ -695,18 +695,6 @@ object ChainUnitTest extends ChainVerificationLogger {
ChainSync.sync(chainHandler, getBlockHeaderFunc, getBestBlockHashFunc)
}
def createBitcoindV19ChainHandler()(implicit
system: ActorSystem,
chainAppConfig: ChainAppConfig): Future[
BitcoindBlockFilterRpcChainHandler] = {
import system.dispatcher
val bitcoindV = BitcoindVersion.V19
val bitcoindF = BitcoinSFixture
.createBitcoind(Some(bitcoindV))
.map(_.asInstanceOf[BitcoindV19RpcClient])
bitcoindF.flatMap(b => createBitcoindBlockFilterRpcChainHandler(b))
}
def createBitcoindBlockFilterRpcChainHandler(
bitcoindV19RpcClient: BitcoindRpcClient with V19BlockFilterRpc)(implicit
ec: ExecutionContext,

13
testkit/src/main/scala/org/bitcoins/testkit/node/NodeTestWithCachedBitcoind.scala
View file

@ -15,8 +15,7 @@ import org.bitcoins.testkit.rpc.{
CachedBitcoind,
CachedBitcoindNewest,
CachedBitcoindNewestNoP2pBlockFilters,
CachedBitcoindPairNewest,
CachedBitcoindV19
CachedBitcoindPairNewest
}
import org.bitcoins.testkit.tor.CachedTor
import org.bitcoins.testkit.wallet.BitcoinSWalletTest
@ -225,16 +224,6 @@ trait NodeTestWithCachedBitcoindPair
}
}
trait NodeTestWithCachedBitcoindV19
extends NodeTestWithCachedBitcoind
with CachedBitcoindV19 {
override def afterAll(): Unit = {
super[CachedBitcoindV19].afterAll()
super[NodeTestWithCachedBitcoind].afterAll()
}
}
trait NodeTestWithCachedBitcoindNoP2pBlockFilters
extends NodeTestWithCachedBitcoind
with CachedBitcoindNewestNoP2pBlockFilters {

58
testkit/src/main/scala/org/bitcoins/testkit/rpc/BitcoindFixtures.scala
View file

@ -1,7 +1,6 @@
package org.bitcoins.testkit.rpc
import org.bitcoins.rpc.client.common.{BitcoindRpcClient, BitcoindVersion}
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.rpc.client.v20.BitcoindV20RpcClient
import org.bitcoins.rpc.client.v21.BitcoindV21RpcClient
import org.bitcoins.rpc.client.v22.BitcoindV22RpcClient
@ -50,41 +49,6 @@ trait BitcoindFixturesFundedCached extends BitcoindFixtures {
}
}
/** Test trait that caches a [[BitcoindV19RpcClient]] that is funded
* and available to use with fixtures
*/
trait BitcoindFixturesFundedCachedV19
extends BitcoinSAsyncFixtureTest
with BitcoindFixturesFundedCached
with CachedBitcoindV19 {
override type FixtureParam = BitcoindV19RpcClient
override def withFixture(test: OneArgAsyncTest): FutureOutcome = {
val f: Future[Outcome] = for {
bitcoind <- cachedBitcoindWithFundsF
futOutcome = withV19FundedBitcoindCached(test, bitcoind)
fut <- futOutcome.toFuture
} yield fut
new FutureOutcome(f)
}
def withV19FundedBitcoindCached(
test: OneArgAsyncTest,
bitcoind: BitcoindV19RpcClient): FutureOutcome = {
makeDependentFixture[BitcoindV19RpcClient](
() => Future.successful(bitcoind),
{ case _ =>
Future.unit // don't want to destroy anything since it is cached
})(test)
}
override def afterAll(): Unit = {
super[CachedBitcoindV19].afterAll()
super[BitcoinSAsyncFixtureTest].afterAll()
}
}
/** Test trait that caches a [[BitcoindV20RpcClient]] that is funded
* and available to use with fixtures
*/
@ -294,28 +258,6 @@ trait BitcoindFixturesCachedPair[T <: BitcoindRpcClient]
}
}
trait BitcoindFixturesCachedPairV19
extends BitcoinSAsyncFixtureTest
with BitcoindFixturesCachedPair[BitcoindV19RpcClient] {
override type FixtureParam = NodePair[BitcoindV19RpcClient]
override val version: BitcoindVersion = BitcoindVersion.V19
override def withFixture(test: OneArgAsyncTest): FutureOutcome = {
val futOutcome = for {
pair <- clientsF
futOutcome = with2BitcoindsCached(test, pair)
f <- futOutcome.toFuture
} yield f
new FutureOutcome(futOutcome)
}
override def afterAll(): Unit = {
super[BitcoindFixturesCachedPair].afterAll()
super[BitcoinSAsyncFixtureTest].afterAll()
}
}
trait BitcoindFixturesCachedPairV21
extends BitcoinSAsyncFixtureTest
with BitcoindFixturesCachedPair[BitcoindV21RpcClient] {

53
testkit/src/main/scala/org/bitcoins/testkit/rpc/BitcoindRpcTestUtil.scala
View file

@ -30,7 +30,6 @@ import org.bitcoins.crypto.{
import org.bitcoins.rpc.BitcoindException
import org.bitcoins.rpc.client.common.BitcoindVersion._
import org.bitcoins.rpc.client.common.{BitcoindRpcClient, BitcoindVersion}
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.rpc.client.v20.BitcoindV20RpcClient
import org.bitcoins.rpc.client.v21.BitcoindV21RpcClient
import org.bitcoins.rpc.client.v22.BitcoindV22RpcClient
@ -176,7 +175,7 @@ trait BitcoindRpcTestUtil extends Logging {
version match {
// default to newest version
case Unknown => getBinary(BitcoindVersion.newest, binaryDirectory)
case known @ (V19 | V20 | V21 | V22 | V23 | V24) =>
case known @ (V20 | V21 | V22 | V23 | V24) =>
val fileList = Files
.list(binaryDirectory)
.iterator()
@ -236,20 +235,6 @@ trait BitcoindRpcTestUtil extends Logging {
BitcoindInstanceLocal.fromConfig(conf, binary)
}
def v19Instance(
port: Int = RpcUtil.randomPort,
rpcPort: Int = RpcUtil.randomPort,
zmqConfig: ZmqConfig = RpcUtil.zmqConfig,
pruneMode: Boolean = false,
binaryDirectory: Path = BitcoindRpcTestClient.sbtBinaryDirectory
)(implicit system: ActorSystem): BitcoindInstanceLocal =
instance(port = port,
rpcPort = rpcPort,
zmqConfig = zmqConfig,
pruneMode = pruneMode,
versionOpt = Some(BitcoindVersion.V19),
binaryDirectory = binaryDirectory)
def v20Instance(
port: Int = RpcUtil.randomPort,
rpcPort: Int = RpcUtil.randomPort,
@ -330,12 +315,6 @@ trait BitcoindRpcTestUtil extends Logging {
binaryDirectory: Path = BitcoindRpcTestClient.sbtBinaryDirectory)(implicit
system: ActorSystem): BitcoindInstanceLocal = {
bitcoindVersion match {
case BitcoindVersion.V19 =>
BitcoindRpcTestUtil.v19Instance(port,
rpcPort,
zmqConfig,
pruneMode,
binaryDirectory = binaryDirectory)
case BitcoindVersion.V20 =>
BitcoindRpcTestUtil.v20Instance(port,
rpcPort,
@ -379,7 +358,7 @@ trait BitcoindRpcTestUtil extends Logging {
val createWalletF = for {
version <- server.version
descriptors = version match {
case V19 | V20 | V21 | V22 | Unknown =>
case V20 | V21 | V22 | Unknown =>
false
case V23 | V24 => true
}
@ -681,9 +660,6 @@ trait BitcoindRpcTestUtil extends Logging {
val rpc = version match {
case BitcoindVersion.Unknown =>
BitcoindRpcClient.withActorSystem(BitcoindRpcTestUtil.instance())
case BitcoindVersion.V19 =>
BitcoindV19RpcClient.withActorSystem(
BitcoindRpcTestUtil.v19Instance())
case BitcoindVersion.V20 =>
BitcoindV20RpcClient.withActorSystem(
BitcoindRpcTestUtil.v20Instance())
@ -780,13 +756,6 @@ trait BitcoindRpcTestUtil extends Logging {
}
}
/** Returns a pair of [[org.bitcoins.rpc.client.v19.BitcoindV19RpcClient BitcoindV19RpcClient]]
* that are connected with some blocks in the chain
*/
def createNodePairV19(clientAccum: RpcClientAccum)(implicit
system: ActorSystem): Future[(BitcoindV19RpcClient, BitcoindV19RpcClient)] =
createNodePairInternal(BitcoindVersion.V19, clientAccum)
/** Returns a pair of [[org.bitcoins.rpc.client.v20.BitcoindV20RpcClient BitcoindV20RpcClient]]
* that are connected with some blocks in the chain
*/
@ -864,13 +833,6 @@ trait BitcoindRpcTestUtil extends Logging {
createNodeTripleInternal(version)
}
def createNodeTripleV19(
clientAccum: RpcClientAccum
)(implicit system: ActorSystem): Future[
(BitcoindV19RpcClient, BitcoindV19RpcClient, BitcoindV19RpcClient)] = {
createNodeTripleInternal(BitcoindVersion.V19, clientAccum)
}
def createRawCoinbaseTransaction(
sender: BitcoindRpcClient,
receiver: BitcoindRpcClient,
@ -922,15 +884,8 @@ trait BitcoindRpcTestUtil extends Logging {
case v21: BitcoindV21RpcClient =>
v21.signRawTransactionWithWallet(transaction, utxoDeps)
case unknown: BitcoindRpcClient =>
val v19T = BitcoindV19RpcClient.fromUnknownVersion(unknown)
v19T match {
case Failure(_) =>
throw new RuntimeException(
"Could not figure out version of provided bitcoind RPC client!" +
"This should not happen, managed to construct different versioned RPC clients from one single client")
case Success(v19) =>
v19.signRawTransactionWithWallet(transaction, utxoDeps)
}
sys.error(
s"Cannot sign tx with unknown version of bitcoind, got=$unknown")
}
/** Gets the pubkey (if it exists) asscociated with a given

14
testkit/src/main/scala/org/bitcoins/testkit/rpc/CachedBitcoind.scala
View file

@ -1,7 +1,7 @@
package org.bitcoins.testkit.rpc
import org.bitcoins.rpc.client.common.{BitcoindRpcClient, BitcoindVersion}
import org.bitcoins.rpc.client.v19.{BitcoindV19RpcClient, V19BlockFilterRpc}
import org.bitcoins.rpc.client.v19.{V19BlockFilterRpc}
import org.bitcoins.rpc.client.v20.BitcoindV20RpcClient
import org.bitcoins.rpc.client.v21.BitcoindV21RpcClient
import org.bitcoins.rpc.client.v22.BitcoindV22RpcClient
@ -133,18 +133,6 @@ trait CachedBitcoindBlockFilterRpcNewest
}
}
trait CachedBitcoindV19 extends CachedBitcoindFunded[BitcoindV19RpcClient] {
_: BitcoinSAkkaAsyncTest =>
override protected lazy val cachedBitcoindWithFundsF: Future[
BitcoindV19RpcClient] = {
val _ = isBitcoindUsed.set(true)
BitcoinSFixture
.createBitcoindWithFunds(Some(BitcoindVersion.V19))
.map(_.asInstanceOf[BitcoindV19RpcClient])
}
}
trait CachedBitcoindV20 extends CachedBitcoindFunded[BitcoindV20RpcClient] {
_: BitcoinSAkkaAsyncTest =>

72
testkit/src/main/scala/org/bitcoins/testkit/wallet/BitcoinSWalletTest.scala
View file

@ -13,7 +13,6 @@ import org.bitcoins.core.wallet.fee._
import org.bitcoins.dlc.wallet.{DLCAppConfig, DLCWallet}
import org.bitcoins.node.NodeCallbacks
import org.bitcoins.rpc.client.common.{BitcoindRpcClient, BitcoindVersion}
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.server.BitcoinSAppConfig
import org.bitcoins.server.util.CallbackUtil
import org.bitcoins.testkit.EmbeddedPg
@ -186,53 +185,6 @@ trait BitcoinSWalletTest
destroy = destroyWalletWithBitcoind(_: WalletWithBitcoindRpc))(test)
}
def withNewWalletAndBitcoindV19(test: OneArgAsyncTest)(implicit
walletAppConfig: WalletAppConfig): FutureOutcome = {
val builder: () => Future[WalletWithBitcoindV19] =
BitcoinSFixture.composeBuildersAndWrap(
builder = { () =>
BitcoinSFixture
.createBitcoindWithFunds(Some(BitcoindVersion.V19))
.map(_.asInstanceOf[BitcoindV19RpcClient])
},
dependentBuilder = { (bitcoind: BitcoindV19RpcClient) =>
createWalletWithBitcoindV19(bitcoind)
},
wrap = (
_: BitcoindV19RpcClient,
walletWithBitcoind: WalletWithBitcoindV19) => walletWithBitcoind
)
makeDependentFixture(
builder,
destroy = destroyWalletWithBitcoind(_: WalletWithBitcoindV19))(test)
}
def withFundedWalletAndBitcoindV19(test: OneArgAsyncTest)(implicit
walletAppConfig: WalletAppConfig): FutureOutcome = {
val builder: () => Future[WalletWithBitcoindV19] = { () =>
for {
bitcoind <-
BitcoinSFixture
.createBitcoindWithFunds(Some(BitcoindVersion.V19))
.map(_.asInstanceOf[BitcoindV19RpcClient])
wallet <- createWalletWithBitcoindCallbacks(bitcoind)
fundedWallet <- FundWalletUtil.fundWalletWithBitcoind(wallet)
_ <- SyncUtil.syncWalletFullBlocks(wallet = fundedWallet.wallet,
bitcoind = bitcoind)
_ <- BitcoinSWalletTest.awaitWalletBalances(fundedWallet)
} yield {
WalletWithBitcoindV19(fundedWallet.wallet,
bitcoind,
wallet.walletConfig)
}
}
makeDependentFixture(
builder,
destroy = destroyWalletWithBitcoind(_: WalletWithBitcoindV19))(test)
}
def withWalletConfig(test: OneArgAsyncTest): FutureOutcome = {
val builder: () => Future[WalletAppConfig] = () => {
createWalletAppConfig(pgUrl, Vector.empty)
@ -468,30 +420,6 @@ object BitcoinSWalletTest extends WalletLogger {
createWalletWithBitcoindCallbacks(bitcoind)
}
def createWalletWithBitcoindV19(bitcoind: BitcoindV19RpcClient)(implicit
system: ActorSystem,
config: WalletAppConfig): Future[WalletWithBitcoindV19] = {
import system.dispatcher
val resultF = createWalletWithBitcoindCallbacks(bitcoind)
resultF.map { result =>
WalletWithBitcoindV19(result.wallet, bitcoind, config)
}
}
def createWalletWithBitcoindV19(wallet: Wallet)(implicit
system: ActorSystem): Future[WalletWithBitcoindV19] = {
import system.dispatcher
val createdF =
createWalletWithBitcoind(wallet, versionOpt = Some(BitcoindVersion.V19))
for {
created <- createdF
} yield WalletWithBitcoindV19(
created.wallet,
created.bitcoind.asInstanceOf[BitcoindV19RpcClient],
wallet.walletConfig)
}
def createWalletWithBitcoind(
wallet: Wallet,
bitcoindRpcClient: BitcoindRpcClient

90
testkit/src/main/scala/org/bitcoins/testkit/wallet/BitcoinSWalletTestCachedBitcoind.scala
View file

@ -1,16 +1,13 @@
package org.bitcoins.testkit.wallet
import com.typesafe.config.Config
import org.bitcoins.rpc.client.common.BitcoindRpcClient
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.testkit.EmbeddedPg
import org.bitcoins.testkit.chain.SyncUtil
import org.bitcoins.testkit.fixtures.BitcoinSFixture
import org.bitcoins.testkit.rpc.{
BitcoindRpcTestUtil,
CachedBitcoind,
CachedBitcoindNewest,
CachedBitcoindV19
CachedBitcoindNewest
}
import org.bitcoins.testkit.wallet.BitcoinSWalletTest.{
createWalletWithBitcoind,
@ -149,88 +146,3 @@ trait BitcoinSWalletTestCachedBitcoindNewest
super[BitcoinSWalletTestCachedBitcoind].afterAll()
}
}
trait BitcoinSWalletTestCachedBitcoinV19
extends BitcoinSWalletTestCachedBitcoind
with CachedBitcoindV19 {
override def afterAll(): Unit = {
super[CachedBitcoindV19].afterAll()
super[BitcoinSWalletTestCachedBitcoind].afterAll()
}
/** Creates a funded wallet fixture with bitcoind
* This is different than [[withFundedWalletAndBitcoind()]]
* in the sense that it does NOT destroy the given bitcoind.
* It is the responsibility of the caller of this method to
* do that, if needed.
*/
def withFundedWalletAndBitcoindCachedV19(
test: OneArgAsyncTest,
bip39PasswordOpt: Option[String],
bitcoind: BitcoindV19RpcClient,
walletAppConfig: WalletAppConfig): FutureOutcome = {
val bip39PasswordConfig: Config =
BitcoinSWalletTest.buildBip39PasswordConfig(bip39PasswordOpt)
implicit val newWalletConf =
walletAppConfig.withOverrides(bip39PasswordConfig)
val builder: () => Future[WalletWithBitcoindV19] = { () =>
for {
walletWithBitcoind <- createWalletWithBitcoindCallbacks(
bitcoind = bitcoind)
walletWithBitcoindV19 = WalletWithBitcoindV19(
walletWithBitcoind.wallet,
bitcoind,
walletWithBitcoind.walletConfig)
fundedWallet <- FundWalletUtil
.fundWalletWithBitcoind(walletWithBitcoindV19)
_ <- SyncUtil.syncWalletFullBlocks(wallet = fundedWallet.wallet,
bitcoind = bitcoind)
_ <- BitcoinSWalletTest.awaitWalletBalances(fundedWallet)
} yield fundedWallet
}
makeDependentFixture[WalletWithBitcoind[_]](
builder,
destroy = { case walletWithBitcoind: WalletWithBitcoind[_] =>
destroyOnlyWalletWithBitcoindCached(walletWithBitcoind)
})(test)
}
def withNewWalletAndBitcoindCachedV19(
test: OneArgAsyncTest,
bitcoind: BitcoindV19RpcClient)(implicit
walletAppConfig: WalletAppConfig): FutureOutcome = {
val builder: () => Future[WalletWithBitcoind[_]] =
BitcoinSFixture.composeBuildersAndWrap(
builder = { () =>
Future.successful(bitcoind)
},
dependentBuilder = { (bitcoind: BitcoindV19RpcClient) =>
BitcoinSWalletTest.createWalletWithBitcoindV19(bitcoind)
},
wrap =
(_: BitcoindRpcClient, walletWithBitcoind: WalletWithBitcoindV19) =>
walletWithBitcoind
)
makeDependentFixture[WalletWithBitcoind[_]](
builder,
{ case walletWithBitcoind: WalletWithBitcoind[_] =>
destroyOnlyWalletWithBitcoindCached(walletWithBitcoind)
})(test)
}
override def withFixture(test: OneArgAsyncTest): FutureOutcome = {
val f: Future[Outcome] = for {
bitcoind <- cachedBitcoindWithFundsF
futOutcome = withFundedWalletAndBitcoindCachedV19(test,
getBIP39PasswordOpt(),
bitcoind,
getFreshWalletAppConfig)
fut <- futOutcome.toFuture
} yield fut
new FutureOutcome(f)
}
}

7
testkit/src/main/scala/org/bitcoins/testkit/wallet/WalletWithBitcoind.scala
View file

@ -2,7 +2,6 @@ package org.bitcoins.testkit.wallet
import org.bitcoins.core.api.wallet.NeutrinoHDWalletApi
import org.bitcoins.rpc.client.common.BitcoindRpcClient
import org.bitcoins.rpc.client.v19.BitcoindV19RpcClient
import org.bitcoins.wallet.config.WalletAppConfig
sealed trait WalletWithBitcoind[T <: BitcoindRpcClient] {
@ -20,9 +19,3 @@ case class WalletWithBitcoindRpc(
bitcoind: BitcoindRpcClient,
walletConfig: WalletAppConfig)
extends WalletWithBitcoind[BitcoindRpcClient]
case class WalletWithBitcoindV19(
wallet: NeutrinoHDWalletApi,
bitcoind: BitcoindV19RpcClient,
walletConfig: WalletAppConfig)
extends WalletWithBitcoind[BitcoindV19RpcClient]

10
wallet-test/src/test/scala/org/bitcoins/wallet/ProcessBlockTest.scala
View file

@ -11,22 +11,22 @@ import org.bitcoins.core.psbt.PSBT
import org.bitcoins.core.util.FutureUtil
import org.bitcoins.core.wallet.utxo.TxoState
import org.bitcoins.testkit.wallet.{
BitcoinSWalletTestCachedBitcoinV19,
WalletWithBitcoindV19
BitcoinSWalletTestCachedBitcoindNewest,
WalletWithBitcoindRpc
}
import org.bitcoins.wallet.models.AccountDAO
import org.scalatest.{FutureOutcome, Outcome}
import scala.concurrent.Future
class ProcessBlockTest extends BitcoinSWalletTestCachedBitcoinV19 {
class ProcessBlockTest extends BitcoinSWalletTestCachedBitcoindNewest {
override type FixtureParam = WalletWithBitcoindV19
override type FixtureParam = WalletWithBitcoindRpc
override def withFixture(test: OneArgAsyncTest): FutureOutcome = {
val f: Future[Outcome] = for {
bitcoind <- cachedBitcoindWithFundsF
futOutcome = withNewWalletAndBitcoindCachedV19(test, bitcoind)(
futOutcome = withNewWalletAndBitcoindCached(test, bitcoind)(
getFreshWalletAppConfig)
fut <- futOutcome.toFuture
} yield fut

8
wallet-test/src/test/scala/org/bitcoins/wallet/sync/WalletSyncTest.scala
View file

@ -2,15 +2,15 @@ package org.bitcoins.wallet.sync
import org.bitcoins.testkit.chain.SyncUtil
import org.bitcoins.testkit.wallet.{
BitcoinSWalletTestCachedBitcoinV19,
WalletWithBitcoindV19
BitcoinSWalletTestCachedBitcoindNewest,
WalletWithBitcoindRpc
}
class WalletSyncTest extends BitcoinSWalletTestCachedBitcoinV19 {
class WalletSyncTest extends BitcoinSWalletTestCachedBitcoindNewest {
behavior of "WalletSync"
override type FixtureParam = WalletWithBitcoindV19
override type FixtureParam = WalletWithBitcoindRpc
it must "sync a wallet with bitcoind" in { param =>
val wallet = param.wallet