From a652c7613f5bf1ebc12dfa20500f183643efc1f3 Mon Sep 17 00:00:00 2001 From: pm47 Date: Fri, 16 Jun 2023 17:41:02 +0200 Subject: [PATCH] use slow/medium/fast notation in FeeratesPerKw --- .../main/scala/fr/acinq/eclair/Setup.scala | 18 +++----- .../fee/BitcoinCoreFeeProvider.scala | 18 +++----- .../blockchain/fee/FallbackFeeProvider.scala | 14 +++--- .../eclair/blockchain/fee/FeeProvider.scala | 44 +++++++++---------- .../blockchain/fee/OnChainFeeConf.scala | 10 ++--- .../blockchain/fee/SmoothFeeProvider.scala | 14 +++--- .../fr/acinq/eclair/channel/Helpers.scala | 6 +-- .../fr/acinq/eclair/channel/fsm/Channel.scala | 2 +- .../publish/ReplaceableTxPublisher.scala | 15 +++---- .../fee/BitcoinCoreFeeProviderSpec.scala | 20 ++++----- .../fee/FallbackFeeProviderSpec.scala | 6 +-- .../blockchain/fee/OnChainFeeConfSpec.scala | 16 +++---- .../fee/SmoothFeeProviderSpec.scala | 12 ++--- .../publish/ReplaceableTxPublisherSpec.scala | 22 ++++------ .../channel/states/e/NormalStateSpec.scala | 8 ++-- .../channel/states/f/ShutdownStateSpec.scala | 6 +-- .../states/g/NegotiatingStateSpec.scala | 6 +-- .../channel/states/h/ClosingStateSpec.scala | 2 +- .../scala/fr/acinq/eclair/io/PeerSpec.scala | 4 +- 19 files changed, 106 insertions(+), 137 deletions(-) diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/Setup.scala b/eclair-core/src/main/scala/fr/acinq/eclair/Setup.scala index 830fbb60d8..8d01570fd3 100644 --- a/eclair-core/src/main/scala/fr/acinq/eclair/Setup.scala +++ b/eclair-core/src/main/scala/fr/acinq/eclair/Setup.scala @@ -207,15 +207,11 @@ class Setup(val datadir: File, defaultFeerates = { val confDefaultFeerates = FeeratesPerKB( - mempoolMinFee = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.1008"))), - block_1 = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.1"))), - blocks_2 = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.2"))), - blocks_6 = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.6"))), - blocks_12 = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.12"))), - blocks_36 = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.36"))), - blocks_72 = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.72"))), - blocks_144 = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.144"))), - blocks_1008 = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.1008"))), + minimum = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.1008"))), + fastest = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.1"))), + fast = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.2"))), + medium = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.12"))), + slow = FeeratePerKB(Satoshi(config.getLong("on-chain-fees.default-feerates.1008"))), ) feeratesPerKw.set(FeeratesPerKw(confDefaultFeerates)) confDefaultFeerates @@ -231,8 +227,8 @@ class Setup(val datadir: File, _ = system.scheduler.scheduleWithFixedDelay(0 seconds, 10 minutes)(() => feeProvider.getFeerates.onComplete { case Success(feeratesPerKB) => feeratesPerKw.set(FeeratesPerKw(feeratesPerKB)) - channel.Monitoring.Metrics.LocalFeeratePerKw.withoutTags().update(feeratesPerKw.get.blocks_2.toLong.toDouble) - blockchain.Monitoring.Metrics.MempoolMinFeeratePerKw.withoutTags().update(feeratesPerKw.get.mempoolMinFee.toLong.toDouble) + channel.Monitoring.Metrics.LocalFeeratePerKw.withoutTags().update(feeratesPerKw.get.fast.toLong.toDouble) + blockchain.Monitoring.Metrics.MempoolMinFeeratePerKw.withoutTags().update(feeratesPerKw.get.minimum.toLong.toDouble) system.eventStream.publish(CurrentFeerates(feeratesPerKw.get)) logger.info(s"current feeratesPerKB=${feeratesPerKB} feeratesPerKw=${feeratesPerKw.get}") feeratesRetrieved.trySuccess(Done) diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/BitcoinCoreFeeProvider.scala b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/BitcoinCoreFeeProvider.scala index 86fb000c4b..53141a96f5 100644 --- a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/BitcoinCoreFeeProvider.scala +++ b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/BitcoinCoreFeeProvider.scala @@ -50,22 +50,14 @@ case class BitcoinCoreFeeProvider(rpcClient: BitcoinJsonRPCClient, defaultFeerat mempoolMinFee <- mempoolMinFee() block_1 <- estimateSmartFee(1) blocks_2 <- estimateSmartFee(2) - blocks_6 <- estimateSmartFee(6) blocks_12 <- estimateSmartFee(12) - blocks_36 <- estimateSmartFee(36) - blocks_72 <- estimateSmartFee(72) - blocks_144 <- estimateSmartFee(144) blocks_1008 <- estimateSmartFee(1008) } yield FeeratesPerKB( - mempoolMinFee = if (mempoolMinFee.feerate > 0.sat) mempoolMinFee else defaultFeerates.mempoolMinFee, - block_1 = if (block_1.feerate > 0.sat) block_1 else defaultFeerates.block_1, - blocks_2 = if (blocks_2.feerate > 0.sat) blocks_2 else defaultFeerates.blocks_2, - blocks_6 = if (blocks_6.feerate > 0.sat) blocks_6 else defaultFeerates.blocks_6, - blocks_12 = if (blocks_12.feerate > 0.sat) blocks_12 else defaultFeerates.blocks_12, - blocks_36 = if (blocks_36.feerate > 0.sat) blocks_36 else defaultFeerates.blocks_36, - blocks_72 = if (blocks_72.feerate > 0.sat) blocks_72 else defaultFeerates.blocks_72, - blocks_144 = if (blocks_144.feerate > 0.sat) blocks_144 else defaultFeerates.blocks_144, - blocks_1008 = if (blocks_1008.feerate > 0.sat) blocks_1008 else defaultFeerates.blocks_1008) + minimum = if (mempoolMinFee.feerate > 0.sat) mempoolMinFee else defaultFeerates.minimum, + fastest = if (block_1.feerate > 0.sat) block_1 else defaultFeerates.fastest, + fast = if (blocks_2.feerate > 0.sat) blocks_2 else defaultFeerates.fast, + medium = if (blocks_12.feerate > 0.sat) blocks_12 else defaultFeerates.medium, + slow = if (blocks_1008.feerate > 0.sat) blocks_1008 else defaultFeerates.slow) } object BitcoinCoreFeeProvider { diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/FallbackFeeProvider.scala b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/FallbackFeeProvider.scala index d8af539e75..40245b1a5a 100644 --- a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/FallbackFeeProvider.scala +++ b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/FallbackFeeProvider.scala @@ -44,15 +44,11 @@ case class FallbackFeeProvider(providers: Seq[FeeProvider], minFeeratePerByte: F object FallbackFeeProvider { private def enforceMinimumFeerate(feeratesPerKB: FeeratesPerKB, minFeeratePerKB: FeeratePerKB): FeeratesPerKB = FeeratesPerKB( - mempoolMinFee = feeratesPerKB.mempoolMinFee.max(minFeeratePerKB), - block_1 = feeratesPerKB.block_1.max(minFeeratePerKB), - blocks_2 = feeratesPerKB.blocks_2.max(minFeeratePerKB), - blocks_6 = feeratesPerKB.blocks_6.max(minFeeratePerKB), - blocks_12 = feeratesPerKB.blocks_12.max(minFeeratePerKB), - blocks_36 = feeratesPerKB.blocks_36.max(minFeeratePerKB), - blocks_72 = feeratesPerKB.blocks_72.max(minFeeratePerKB), - blocks_144 = feeratesPerKB.blocks_144.max(minFeeratePerKB), - blocks_1008 = feeratesPerKB.blocks_1008.max(minFeeratePerKB) + minimum = feeratesPerKB.minimum.max(minFeeratePerKB), + fastest = feeratesPerKB.fastest.max(minFeeratePerKB), + fast = feeratesPerKB.fast.max(minFeeratePerKB), + medium = feeratesPerKB.medium.max(minFeeratePerKB), + slow = feeratesPerKB.slow.max(minFeeratePerKB) ) } diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/FeeProvider.scala b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/FeeProvider.scala index d821857927..90c2044a45 100644 --- a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/FeeProvider.scala +++ b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/FeeProvider.scala @@ -110,36 +110,36 @@ object FeeratePerKw { * The mempoolMinFee is the minimal fee required for a tx to enter the mempool (and then be relayed to other nodes and eventually get confirmed). * If our fee provider doesn't expose this data, using its biggest block target should be a good enough estimation. */ -case class FeeratesPerKB(mempoolMinFee: FeeratePerKB, block_1: FeeratePerKB, blocks_2: FeeratePerKB, blocks_6: FeeratePerKB, blocks_12: FeeratePerKB, blocks_36: FeeratePerKB, blocks_72: FeeratePerKB, blocks_144: FeeratePerKB, blocks_1008: FeeratePerKB) { - require(mempoolMinFee.feerate > 0.sat && block_1.feerate > 0.sat && blocks_2.feerate > 0.sat && blocks_6.feerate > 0.sat && blocks_12.feerate > 0.sat && blocks_36.feerate > 0.sat && blocks_72.feerate > 0.sat && blocks_144.feerate > 0.sat && blocks_1008.feerate > 0.sat, "all feerates must be strictly greater than 0") +case class FeeratesPerKB(minimum: FeeratePerKB, + fastest: FeeratePerKB, + fast: FeeratePerKB, + medium: FeeratePerKB, + slow: FeeratePerKB) { + require(minimum.feerate > 0.sat && fastest.feerate > 0.sat && fast.feerate > 0.sat && medium.feerate > 0.sat && slow.feerate > 0.sat, "all feerates must be strictly greater than 0") } /** Fee rates in satoshi-per-kilo-weight (1 kw = 1000 weight units). */ -case class FeeratesPerKw(mempoolMinFee: FeeratePerKw, block_1: FeeratePerKw, blocks_2: FeeratePerKw, blocks_6: FeeratePerKw, blocks_12: FeeratePerKw, blocks_36: FeeratePerKw, blocks_72: FeeratePerKw, blocks_144: FeeratePerKw, blocks_1008: FeeratePerKw) { - require(mempoolMinFee.feerate > 0.sat && block_1.feerate > 0.sat && blocks_2.feerate > 0.sat && blocks_6.feerate > 0.sat && blocks_12.feerate > 0.sat && blocks_36.feerate > 0.sat && blocks_72.feerate > 0.sat && blocks_144.feerate > 0.sat && blocks_1008.feerate > 0.sat, "all feerates must be strictly greater than 0") +case class FeeratesPerKw(minimum: FeeratePerKw, + fastest: FeeratePerKw, + fast: FeeratePerKw, + medium: FeeratePerKw, + slow: FeeratePerKw) { + require(minimum.feerate > 0.sat && fastest.feerate > 0.sat && fast.feerate > 0.sat && medium.feerate > 0.sat && slow.feerate > 0.sat, "all feerates must be strictly greater than 0") } object FeeratesPerKw { def apply(feerates: FeeratesPerKB): FeeratesPerKw = FeeratesPerKw( - mempoolMinFee = FeeratePerKw(feerates.mempoolMinFee), - block_1 = FeeratePerKw(feerates.block_1), - blocks_2 = FeeratePerKw(feerates.blocks_2), - blocks_6 = FeeratePerKw(feerates.blocks_6), - blocks_12 = FeeratePerKw(feerates.blocks_12), - blocks_36 = FeeratePerKw(feerates.blocks_36), - blocks_72 = FeeratePerKw(feerates.blocks_72), - blocks_144 = FeeratePerKw(feerates.blocks_144), - blocks_1008 = FeeratePerKw(feerates.blocks_1008)) + minimum = FeeratePerKw(feerates.minimum), + fastest = FeeratePerKw(feerates.fastest), + fast = FeeratePerKw(feerates.fast), + medium = FeeratePerKw(feerates.medium), + slow = FeeratePerKw(feerates.slow)) /** Used in tests */ def single(feeratePerKw: FeeratePerKw): FeeratesPerKw = FeeratesPerKw( - mempoolMinFee = feeratePerKw, - block_1 = feeratePerKw, - blocks_2 = feeratePerKw, - blocks_6 = feeratePerKw, - blocks_12 = feeratePerKw, - blocks_36 = feeratePerKw, - blocks_72 = feeratePerKw, - blocks_144 = feeratePerKw, - blocks_1008 = feeratePerKw) + minimum = feeratePerKw, + fastest = feeratePerKw, + fast = feeratePerKw, + medium = feeratePerKw, + slow = feeratePerKw) } diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/OnChainFeeConf.scala b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/OnChainFeeConf.scala index 90a4110acd..060d9c4c1f 100644 --- a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/OnChainFeeConf.scala +++ b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/OnChainFeeConf.scala @@ -25,9 +25,9 @@ import fr.acinq.eclair.transactions.Transactions // @formatter:off sealed trait ConfirmationPriority { def getFeerate(feerates: FeeratesPerKw): FeeratePerKw = this match { - case ConfirmationPriority.Slow => feerates.blocks_1008 - case ConfirmationPriority.Medium => feerates.blocks_12 - case ConfirmationPriority.Fast => feerates.blocks_2 + case ConfirmationPriority.Slow => feerates.slow + case ConfirmationPriority.Medium => feerates.medium + case ConfirmationPriority.Fast => feerates.fast } override def toString: String = super.toString.toLowerCase } @@ -89,8 +89,8 @@ case class OnChainFeeConf(feeTargets: FeeTargets, safeUtxosThreshold: Int, spend * @param currentFeerates_opt if provided, will be used to compute the most up-to-date network fee, otherwise we rely on the fee estimator */ def getCommitmentFeerate(feerates: FeeratesPerKw, remoteNodeId: PublicKey, channelType: SupportedChannelType, channelCapacity: Satoshi): FeeratePerKw = { - val networkFeerate = feerates.blocks_2 - val networkMinFee = feerates.mempoolMinFee + val networkFeerate = feerates.fast + val networkMinFee = feerates.minimum channelType.commitmentFormat match { case Transactions.DefaultCommitmentFormat => networkFeerate diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/SmoothFeeProvider.scala b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/SmoothFeeProvider.scala index b24c70c4ec..b346a4db85 100644 --- a/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/SmoothFeeProvider.scala +++ b/eclair-core/src/main/scala/fr/acinq/eclair/blockchain/fee/SmoothFeeProvider.scala @@ -43,14 +43,10 @@ object SmoothFeeProvider { def smooth(rates: Seq[FeeratesPerKB]): FeeratesPerKB = FeeratesPerKB( - mempoolMinFee = avg(rates.map(_.mempoolMinFee)), - block_1 = avg(rates.map(_.block_1)), - blocks_2 = avg(rates.map(_.blocks_2)), - blocks_6 = avg(rates.map(_.blocks_6)), - blocks_12 = avg(rates.map(_.blocks_12)), - blocks_36 = avg(rates.map(_.blocks_36)), - blocks_72 = avg(rates.map(_.blocks_72)), - blocks_144 = avg(rates.map(_.blocks_144)), - blocks_1008 = avg(rates.map(_.blocks_1008))) + minimum = avg(rates.map(_.minimum)), + fastest = avg(rates.map(_.fastest)), + fast = avg(rates.map(_.fast)), + medium = avg(rates.map(_.medium)), + slow = avg(rates.map(_.slow))) } diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/channel/Helpers.scala b/eclair-core/src/main/scala/fr/acinq/eclair/channel/Helpers.scala index e47c010a37..cd872bdaf5 100644 --- a/eclair-core/src/main/scala/fr/acinq/eclair/channel/Helpers.scala +++ b/eclair-core/src/main/scala/fr/acinq/eclair/channel/Helpers.scala @@ -932,7 +932,7 @@ object Helpers { val localPaymentPubkey = Generators.derivePubKey(keyManager.paymentPoint(channelKeyPath).publicKey, remoteCommit.remotePerCommitmentPoint) val outputs = makeCommitTxOutputs(!commitment.localParams.isInitiator, commitment.remoteParams.dustLimit, remoteRevocationPubkey, commitment.localParams.toSelfDelay, remoteDelayedPaymentPubkey, localPaymentPubkey, remoteHtlcPubkey, localHtlcPubkey, commitment.remoteFundingPubKey, localFundingPubkey, remoteCommit.spec, commitment.params.commitmentFormat) // we need to use a rather high fee for htlc-claim because we compete with the counterparty - val feeratePerKwHtlc = feerates.blocks_2 + val feeratePerKwHtlc = feerates.fast // those are the preimages to existing received htlcs val hash2Preimage: Map[ByteVector32, ByteVector32] = commitment.changes.localChanges.all.collect { case u: UpdateFulfillHtlc => u.paymentPreimage }.map(r => Crypto.sha256(r) -> r).toMap @@ -1028,7 +1028,7 @@ object Helpers { val feerateMain = onChainFeeConf.getClosingFeerate(feerates) // we need to use a high fee here for punishment txs because after a delay they can be spent by the counterparty - val feeratePenalty = feerates.blocks_2 + val feeratePenalty = feerates.fast // first we will claim our main output right away val mainTx = channelFeatures match { @@ -1125,7 +1125,7 @@ object Helpers { val remoteRevocationPubkey = Generators.revocationPubKey(keyManager.revocationPoint(channelKeyPath).publicKey, remotePerCommitmentPoint) // we need to use a high fee here for punishment txs because after a delay they can be spent by the counterparty - val feeratePerKwPenalty = feerates.block_1 + val feeratePerKwPenalty = feerates.fastest val penaltyTxs = Transactions.makeClaimHtlcDelayedOutputPenaltyTxs(htlcTx, localParams.dustLimit, remoteRevocationPubkey, localParams.toSelfDelay, remoteDelayedPaymentPubkey, finalScriptPubKey, feeratePerKwPenalty).flatMap(claimHtlcDelayedOutputPenaltyTx => { withTxGenerationLog("htlc-delayed-penalty") { diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/channel/fsm/Channel.scala b/eclair-core/src/main/scala/fr/acinq/eclair/channel/fsm/Channel.scala index 70957d7f37..e37b4622b1 100644 --- a/eclair-core/src/main/scala/fr/acinq/eclair/channel/fsm/Channel.scala +++ b/eclair-core/src/main/scala/fr/acinq/eclair/channel/fsm/Channel.scala @@ -829,7 +829,7 @@ class Channel(val nodeParams: NodeParams, val wallet: OnChainChannelFunder with if (!d.commitments.isIdle) { log.info("rejecting splice request: channel not idle") stay() using d.copy(spliceStatus = SpliceStatus.SpliceAborted) sending TxAbort(d.channelId, InvalidSpliceRequest(d.channelId).getMessage) - } else if (msg.feerate < nodeParams.currentFeerates.mempoolMinFee) { + } else if (msg.feerate < nodeParams.currentFeerates.minimum) { log.info("rejecting splice request: feerate too low") stay() using d.copy(spliceStatus = SpliceStatus.SpliceAborted) sending TxAbort(d.channelId, InvalidSpliceRequest(d.channelId).getMessage) } else { diff --git a/eclair-core/src/main/scala/fr/acinq/eclair/channel/publish/ReplaceableTxPublisher.scala b/eclair-core/src/main/scala/fr/acinq/eclair/channel/publish/ReplaceableTxPublisher.scala index 45cc07aad7..d55f47c81c 100644 --- a/eclair-core/src/main/scala/fr/acinq/eclair/channel/publish/ReplaceableTxPublisher.scala +++ b/eclair-core/src/main/scala/fr/acinq/eclair/channel/publish/ReplaceableTxPublisher.scala @@ -83,21 +83,18 @@ object ReplaceableTxPublisher { if (hasEnoughSafeUtxos) { remainingBlocks match { // If our target is still very far in the future, no need to rush - case t if t >= 144 => feerates.blocks_144 - case t if t >= 72 => feerates.blocks_72 - case t if t >= 36 => feerates.blocks_36 + case t if t >= 36 => feerates.slow // However, if we get closer to the target, we start being more aggressive - case t if t >= 18 => feerates.blocks_12 - case t if t >= 12 => feerates.blocks_6 - case t if t >= 2 => feerates.blocks_2 - case _ => feerates.block_1 + case t if t >= 12 => feerates.medium + case t if t >= 2 => feerates.fast + case _ => feerates.fastest } } else { // We don't have many safe utxos so we want the transaction to confirm quickly. if (remainingBlocks <= 1) { - feerates.block_1 + feerates.fastest } else { - feerates.blocks_2 + feerates.fast } } case ConfirmationTarget.Priority(priority) => diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/BitcoinCoreFeeProviderSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/BitcoinCoreFeeProviderSpec.scala index b18d773f48..0bdbd936fb 100644 --- a/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/BitcoinCoreFeeProviderSpec.scala +++ b/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/BitcoinCoreFeeProviderSpec.scala @@ -74,26 +74,22 @@ class BitcoinCoreFeeProviderSpec extends TestKitBaseClass with BitcoindService w ) val ref = FeeratesPerKB( - mempoolMinFee = FeeratePerKB(300 sat), - block_1 = fees(1), - blocks_2 = fees(2), - blocks_6 = fees(6), - blocks_12 = fees(12), - blocks_36 = fees(36), - blocks_72 = fees(72), - blocks_144 = fees(144), - blocks_1008 = fees(1008) + minimum = FeeratePerKB(300 sat), + fastest = fees(1), + fast = fees(2), + medium = fees(12), + slow = fees(1008) ) - val mockBitcoinClient = createMockBitcoinClient(fees, ref.mempoolMinFee) + val mockBitcoinClient = createMockBitcoinClient(fees, ref.minimum) - val mockProvider = BitcoinCoreFeeProvider(mockBitcoinClient, FeeratesPerKB(FeeratePerKB(1 sat), FeeratePerKB(1 sat), FeeratePerKB(2 sat), FeeratePerKB(3 sat), FeeratePerKB(4 sat), FeeratePerKB(5 sat), FeeratePerKB(6 sat), FeeratePerKB(7 sat), FeeratePerKB(8 sat))) + val mockProvider = BitcoinCoreFeeProvider(mockBitcoinClient, FeeratesPerKB(FeeratePerKB(1 sat), FeeratePerKB(5 sat), FeeratePerKB(4 sat), FeeratePerKB(3 sat), FeeratePerKB(2 sat))) mockProvider.getFeerates.pipeTo(sender.ref) assert(sender.expectMsgType[FeeratesPerKB] == ref) } test("get mempool minimum fee") { - val regtestProvider = BitcoinCoreFeeProvider(bitcoinrpcclient, FeeratesPerKB(FeeratePerKB(1 sat), FeeratePerKB(1 sat), FeeratePerKB(2 sat), FeeratePerKB(3 sat), FeeratePerKB(4 sat), FeeratePerKB(5 sat), FeeratePerKB(6 sat), FeeratePerKB(7 sat), FeeratePerKB(8 sat))) + val regtestProvider = BitcoinCoreFeeProvider(bitcoinrpcclient, FeeratesPerKB(FeeratePerKB(1 sat), FeeratePerKB(5 sat), FeeratePerKB(4 sat), FeeratePerKB(3 sat), FeeratePerKB(2 sat))) val sender = TestProbe() regtestProvider.mempoolMinFee().pipeTo(sender.ref) val mempoolMinFee = sender.expectMsgType[FeeratePerKB] diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/FallbackFeeProviderSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/FallbackFeeProviderSpec.scala index d268adaa6c..d7e7d84457 100644 --- a/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/FallbackFeeProviderSpec.scala +++ b/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/FallbackFeeProviderSpec.scala @@ -42,7 +42,7 @@ class FallbackFeeProviderSpec extends AnyFunSuite { def dummyFeerate = FeeratePerKB(1000.sat + Random.nextInt(10000).sat) - def dummyFeerates = FeeratesPerKB(dummyFeerate, dummyFeerate, dummyFeerate, dummyFeerate, dummyFeerate, dummyFeerate, dummyFeerate, dummyFeerate, dummyFeerate) + def dummyFeerates = FeeratesPerKB(dummyFeerate, dummyFeerate, dummyFeerate, dummyFeerate, dummyFeerate) def await[T](f: Future[T]): T = Await.result(f, 3 seconds) @@ -71,11 +71,11 @@ class FallbackFeeProviderSpec extends AnyFunSuite { } test("ensure minimum feerate") { - val constantFeeProvider = ConstantFeeProvider(FeeratesPerKB(FeeratePerKB(64000 sat), FeeratePerKB(32000 sat), FeeratePerKB(16000 sat), FeeratePerKB(8000 sat), FeeratePerKB(4000 sat), FeeratePerKB(2000 sat), FeeratePerKB(1500 sat), FeeratePerKB(1000 sat), FeeratePerKB(1000 sat))) + val constantFeeProvider = ConstantFeeProvider(FeeratesPerKB(FeeratePerKB(1000 sat), FeeratePerKB(64_000 sat), FeeratePerKB(32_000 sat), FeeratePerKB(16_000 sat), FeeratePerKB(8_000 sat))) val minFeeratePerByte = FeeratePerByte(2 sat) val minFeeratePerKB = FeeratePerKB(minFeeratePerByte) val fallbackFeeProvider = new FallbackFeeProvider(constantFeeProvider :: Nil, minFeeratePerByte) - assert(await(fallbackFeeProvider.getFeerates) == FeeratesPerKB(FeeratePerKB(64000 sat), FeeratePerKB(32000 sat), FeeratePerKB(16000 sat), FeeratePerKB(8000 sat), FeeratePerKB(4000 sat), minFeeratePerKB, minFeeratePerKB, minFeeratePerKB, minFeeratePerKB)) + assert(await(fallbackFeeProvider.getFeerates) == FeeratesPerKB(minFeeratePerKB, FeeratePerKB(64_000 sat), FeeratePerKB(32_000 sat), FeeratePerKB(16_000 sat), FeeratePerKB(8_000 sat))) } } diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/OnChainFeeConfSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/OnChainFeeConfSpec.scala index b8259ed162..cb7d9cf5c2 100644 --- a/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/OnChainFeeConfSpec.scala +++ b/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/OnChainFeeConfSpec.scala @@ -41,10 +41,10 @@ class OnChainFeeConfSpec extends AnyFunSuite { val channelType = ChannelTypes.Standard() val feeConf = OnChainFeeConf(defaultFeeTargets, safeUtxosThreshold = 0, spendAnchorWithoutHtlcs = true, closeOnOfflineMismatch = true, updateFeeMinDiffRatio = 0.1, defaultFeerateTolerance, Map.empty) - val feerates1 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(blocks_2 = FeeratePerKw(5000 sat)) + val feerates1 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(fast = FeeratePerKw(5000 sat)) assert(feeConf.getCommitmentFeerate(feerates1, randomKey().publicKey, channelType, 100000 sat) == FeeratePerKw(5000 sat)) - val feerates2 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(blocks_2 = FeeratePerKw(4000 sat)) + val feerates2 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(fast = FeeratePerKw(4000 sat)) assert(feeConf.getCommitmentFeerate(feerates2, randomKey().publicKey, channelType, 100000 sat) == FeeratePerKw(4000 sat)) } @@ -55,31 +55,31 @@ class OnChainFeeConfSpec extends AnyFunSuite { val overrideMaxCommitFeerate = defaultMaxCommitFeerate * 2 val feeConf = OnChainFeeConf(defaultFeeTargets, safeUtxosThreshold = 0, spendAnchorWithoutHtlcs = true, closeOnOfflineMismatch = true, updateFeeMinDiffRatio = 0.1, defaultFeerateTolerance, Map(overrideNodeId -> defaultFeerateTolerance.copy(anchorOutputMaxCommitFeerate = overrideMaxCommitFeerate))) - val feerates1 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(blocks_2 = defaultMaxCommitFeerate / 2, mempoolMinFee = FeeratePerKw(250 sat)) + val feerates1 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(fast = defaultMaxCommitFeerate / 2, minimum = FeeratePerKw(250 sat)) assert(feeConf.getCommitmentFeerate(feerates1, defaultNodeId, ChannelTypes.AnchorOutputs(), 100000 sat) == defaultMaxCommitFeerate / 2) assert(feeConf.getCommitmentFeerate(feerates1, defaultNodeId, ChannelTypes.AnchorOutputsZeroFeeHtlcTx(), 100000 sat) == defaultMaxCommitFeerate / 2) - val feerates2 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(blocks_2 = defaultMaxCommitFeerate * 2, mempoolMinFee = FeeratePerKw(250 sat)) + val feerates2 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(fast = defaultMaxCommitFeerate * 2, minimum = FeeratePerKw(250 sat)) assert(feeConf.getCommitmentFeerate(feerates2, defaultNodeId, ChannelTypes.AnchorOutputs(), 100000 sat) == defaultMaxCommitFeerate) assert(feeConf.getCommitmentFeerate(feerates2, defaultNodeId, ChannelTypes.AnchorOutputsZeroFeeHtlcTx(), 100000 sat) == defaultMaxCommitFeerate) assert(feeConf.getCommitmentFeerate(feerates2, overrideNodeId, ChannelTypes.AnchorOutputs(), 100000 sat) == overrideMaxCommitFeerate) assert(feeConf.getCommitmentFeerate(feerates2, overrideNodeId, ChannelTypes.AnchorOutputsZeroFeeHtlcTx(), 100000 sat) == overrideMaxCommitFeerate) - val feerates3 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(blocks_2 = defaultMaxCommitFeerate / 2, mempoolMinFee = FeeratePerKw(250 sat)) + val feerates3 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(fast = defaultMaxCommitFeerate / 2, minimum = FeeratePerKw(250 sat)) assert(feeConf.getCommitmentFeerate(feerates3, defaultNodeId, ChannelTypes.AnchorOutputs(), 100000 sat) == defaultMaxCommitFeerate / 2) assert(feeConf.getCommitmentFeerate(feerates3, defaultNodeId, ChannelTypes.AnchorOutputsZeroFeeHtlcTx(), 100000 sat) == defaultMaxCommitFeerate / 2) - val feerates4 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(blocks_2 = defaultMaxCommitFeerate * 1.5, mempoolMinFee = FeeratePerKw(250 sat)) + val feerates4 = FeeratesPerKw.single(FeeratePerKw(10000 sat)).copy(fast = defaultMaxCommitFeerate * 1.5, minimum = FeeratePerKw(250 sat)) assert(feeConf.getCommitmentFeerate(feerates4, defaultNodeId, ChannelTypes.AnchorOutputs(), 100000 sat) == defaultMaxCommitFeerate) assert(feeConf.getCommitmentFeerate(feerates4, defaultNodeId, ChannelTypes.AnchorOutputsZeroFeeHtlcTx(), 100000 sat) == defaultMaxCommitFeerate) - val feerates5 = FeeratesPerKw.single(FeeratePerKw(25000 sat)).copy(mempoolMinFee = FeeratePerKw(10000 sat)) + val feerates5 = FeeratesPerKw.single(FeeratePerKw(25000 sat)).copy(minimum = FeeratePerKw(10000 sat)) assert(feeConf.getCommitmentFeerate(feerates5, defaultNodeId, ChannelTypes.AnchorOutputs(), 100000 sat) == FeeratePerKw(10000 sat) * 1.25) assert(feeConf.getCommitmentFeerate(feerates5, defaultNodeId, ChannelTypes.AnchorOutputsZeroFeeHtlcTx(), 100000 sat) == FeeratePerKw(10000 sat) * 1.25) assert(feeConf.getCommitmentFeerate(feerates5, overrideNodeId, ChannelTypes.AnchorOutputs(), 100000 sat) == FeeratePerKw(10000 sat) * 1.25) assert(feeConf.getCommitmentFeerate(feerates5, overrideNodeId, ChannelTypes.AnchorOutputsZeroFeeHtlcTx(), 100000 sat) == FeeratePerKw(10000 sat) * 1.25) - val feerates6 = FeeratesPerKw.single(FeeratePerKw(25000 sat)).copy(mempoolMinFee = FeeratePerKw(10000 sat)) + val feerates6 = FeeratesPerKw.single(FeeratePerKw(25000 sat)).copy(minimum = FeeratePerKw(10000 sat)) assert(feeConf.getCommitmentFeerate(feerates6, defaultNodeId, ChannelTypes.AnchorOutputs(), 100000 sat) == FeeratePerKw(10000 sat) * 1.25) assert(feeConf.getCommitmentFeerate(feerates6, defaultNodeId, ChannelTypes.AnchorOutputsZeroFeeHtlcTx(), 100000 sat) == FeeratePerKw(10000 sat) * 1.25) assert(feeConf.getCommitmentFeerate(feerates6, overrideNodeId, ChannelTypes.AnchorOutputs(), 100000 sat) == FeeratePerKw(10000 sat) * 1.25) diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/SmoothFeeProviderSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/SmoothFeeProviderSpec.scala index 05160c8c98..b7a33e06fa 100644 --- a/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/SmoothFeeProviderSpec.scala +++ b/eclair-core/src/test/scala/fr/acinq/eclair/blockchain/fee/SmoothFeeProviderSpec.scala @@ -27,11 +27,11 @@ class SmoothFeeProviderSpec extends AnyFunSuite { test("smooth fee rates") { val rates = Array( - FeeratesPerKB(FeeratePerKB(50 sat), FeeratePerKB(100 sat), FeeratePerKB(200 sat), FeeratePerKB(300 sat), FeeratePerKB(400 sat), FeeratePerKB(500 sat), FeeratePerKB(600 sat), FeeratePerKB(650 sat), FeeratePerKB(700 sat)), - FeeratesPerKB(FeeratePerKB(60 sat), FeeratePerKB(200 sat), FeeratePerKB(300 sat), FeeratePerKB(400 sat), FeeratePerKB(500 sat), FeeratePerKB(600 sat), FeeratePerKB(700 sat), FeeratePerKB(750 sat), FeeratePerKB(800 sat)), - FeeratesPerKB(FeeratePerKB(70 sat), FeeratePerKB(300 sat), FeeratePerKB(400 sat), FeeratePerKB(500 sat), FeeratePerKB(600 sat), FeeratePerKB(700 sat), FeeratePerKB(800 sat), FeeratePerKB(850 sat), FeeratePerKB(900 sat)), - FeeratesPerKB(FeeratePerKB(70 sat), FeeratePerKB(300 sat), FeeratePerKB(400 sat), FeeratePerKB(500 sat), FeeratePerKB(600 sat), FeeratePerKB(700 sat), FeeratePerKB(800 sat), FeeratePerKB(850 sat), FeeratePerKB(900 sat)), - FeeratesPerKB(FeeratePerKB(70 sat), FeeratePerKB(300 sat), FeeratePerKB(400 sat), FeeratePerKB(500 sat), FeeratePerKB(600 sat), FeeratePerKB(700 sat), FeeratePerKB(800 sat), FeeratePerKB(850 sat), FeeratePerKB(900 sat)) + FeeratesPerKB(FeeratePerKB(50 sat), FeeratePerKB(700 sat), FeeratePerKB(650 sat), FeeratePerKB(500 sat), FeeratePerKB(400 sat)), + FeeratesPerKB(FeeratePerKB(60 sat), FeeratePerKB(800 sat), FeeratePerKB(750 sat), FeeratePerKB(600 sat), FeeratePerKB(500 sat)), + FeeratesPerKB(FeeratePerKB(70 sat), FeeratePerKB(900 sat), FeeratePerKB(850 sat), FeeratePerKB(700 sat), FeeratePerKB(600 sat)), + FeeratesPerKB(FeeratePerKB(70 sat), FeeratePerKB(900 sat), FeeratePerKB(850 sat), FeeratePerKB(700 sat), FeeratePerKB(600 sat)), + FeeratesPerKB(FeeratePerKB(70 sat), FeeratePerKB(900 sat), FeeratePerKB(850 sat), FeeratePerKB(700 sat), FeeratePerKB(600 sat)) ) val provider: FeeProvider = new FeeProvider { var index = 0 @@ -56,7 +56,7 @@ class SmoothFeeProviderSpec extends AnyFunSuite { assert(rate1 == rates(0)) assert(rate2 == SmoothFeeProvider.smooth(Seq(rates(0), rates(1)))) assert(rate3 == SmoothFeeProvider.smooth(Seq(rates(0), rates(1), rates(2)))) - assert(rate3 == FeeratesPerKB(FeeratePerKB(60 sat), FeeratePerKB(200 sat), FeeratePerKB(300 sat), FeeratePerKB(400 sat), FeeratePerKB(500 sat), FeeratePerKB(600 sat), FeeratePerKB(700 sat), FeeratePerKB(750 sat), FeeratePerKB(800 sat))) + assert(rate3 == FeeratesPerKB(FeeratePerKB(60 sat), FeeratePerKB(800 sat), FeeratePerKB(750 sat), FeeratePerKB(600 sat), FeeratePerKB(500 sat))) assert(rate4 == SmoothFeeProvider.smooth(Seq(rates(1), rates(2), rates(3)))) assert(rate5 == rates(4)) // since the last 3 values are the same } diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/channel/publish/ReplaceableTxPublisherSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/channel/publish/ReplaceableTxPublisherSpec.scala index 2ea2cb630d..216e2af3ef 100644 --- a/eclair-core/src/test/scala/fr/acinq/eclair/channel/publish/ReplaceableTxPublisherSpec.scala +++ b/eclair-core/src/test/scala/fr/acinq/eclair/channel/publish/ReplaceableTxPublisherSpec.scala @@ -89,14 +89,10 @@ class ReplaceableTxPublisherSpec extends TestKitBaseClass with AnyFunSuiteLike w /** Set feerate for a specific block target. */ def setFeerate(feerate: FeeratePerKw, blockTarget: Int): Unit = { def updateFeerates(currentFeerates: FeeratesPerKw): FeeratesPerKw = blockTarget match { - case 1 => currentFeerates.copy(block_1 = feerate) - case 2 => currentFeerates.copy(blocks_2 = feerate) - case t if t <= 6 => currentFeerates.copy(blocks_6 = feerate) - case t if t <= 12 => currentFeerates.copy(blocks_12 = feerate) - case t if t <= 36 => currentFeerates.copy(blocks_36 = feerate) - case t if t <= 72 => currentFeerates.copy(blocks_72 = feerate) - case t if t <= 144 => currentFeerates.copy(blocks_144 = feerate) - case _ => currentFeerates.copy(blocks_1008 = feerate) + case 1 => currentFeerates.copy(fastest = feerate) + case 2 => currentFeerates.copy(fast = feerate) + case t if t <= 12 => currentFeerates.copy(medium = feerate) + case _ => currentFeerates.copy(slow = feerate) } alice.underlyingActor.nodeParams.setFeerates(updateFeerates(alice.underlyingActor.nodeParams.currentFeerates)) @@ -551,7 +547,7 @@ class ReplaceableTxPublisherSpec extends TestKitBaseClass with AnyFunSuiteLike w withFixture(Seq(10.4 millibtc, 5 millibtc), ChannelTypes.AnchorOutputsZeroFeeHtlcTx()) { f => import f._ - val (commitTx, anchorTx) = closeChannelWithoutHtlcs(f, aliceBlockHeight() + 30) + val (commitTx, anchorTx) = closeChannelWithoutHtlcs(f, aliceBlockHeight() + 40) wallet.publishTransaction(commitTx.tx).pipeTo(probe.ref) probe.expectMsg(commitTx.tx.txid) @@ -590,7 +586,7 @@ class ReplaceableTxPublisherSpec extends TestKitBaseClass with AnyFunSuiteLike w withFixture(Seq(10.2 millibtc), ChannelTypes.AnchorOutputsZeroFeeHtlcTx()) { f => import f._ - val (commitTx, anchorTx) = closeChannelWithoutHtlcs(f, aliceBlockHeight() + 30) + val (commitTx, anchorTx) = closeChannelWithoutHtlcs(f, aliceBlockHeight() + 40) wallet.publishTransaction(commitTx.tx).pipeTo(probe.ref) probe.expectMsg(commitTx.tx.txid) @@ -624,7 +620,7 @@ class ReplaceableTxPublisherSpec extends TestKitBaseClass with AnyFunSuiteLike w withFixture(Seq(10.2 millibtc), ChannelTypes.AnchorOutputsZeroFeeHtlcTx()) { f => import f._ - val (commitTx, anchorTx) = closeChannelWithoutHtlcs(f, aliceBlockHeight() + 30) + val (commitTx, anchorTx) = closeChannelWithoutHtlcs(f, aliceBlockHeight() + 40) wallet.publishTransaction(commitTx.tx).pipeTo(probe.ref) probe.expectMsg(commitTx.tx.txid) @@ -655,7 +651,7 @@ class ReplaceableTxPublisherSpec extends TestKitBaseClass with AnyFunSuiteLike w withFixture(Seq(500 millibtc), ChannelTypes.AnchorOutputsZeroFeeHtlcTx()) { f => import f._ - val (commitTx, anchorTx) = closeChannelWithoutHtlcs(f, aliceBlockHeight() + 30) + val (commitTx, anchorTx) = closeChannelWithoutHtlcs(f, aliceBlockHeight() + 40) wallet.publishTransaction(commitTx.tx).pipeTo(probe.ref) probe.expectMsg(commitTx.tx.txid) @@ -1442,7 +1438,7 @@ class ReplaceableTxPublisherSpec extends TestKitBaseClass with AnyFunSuiteLike w withFixture(Seq(11 millibtc), ChannelTypes.AnchorOutputsZeroFeeHtlcTx()) { f => import f._ - val currentFeerate = alice.underlyingActor.nodeParams.currentFeerates.blocks_2 + val currentFeerate = alice.underlyingActor.nodeParams.currentFeerates.fast val (remoteCommitTx, claimHtlcSuccess, claimHtlcTimeout) = remoteCloseChannelWithHtlcs(f, aliceBlockHeight() + 50, nextCommit = false) val claimHtlcSuccessTx = testPublishClaimHtlcSuccess(f, remoteCommitTx, claimHtlcSuccess, currentFeerate) assert(claimHtlcSuccess.txInfo.fee > 0.sat) diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/e/NormalStateSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/e/NormalStateSpec.scala index ef4d87e76a..047c67cb40 100644 --- a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/e/NormalStateSpec.scala +++ b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/e/NormalStateSpec.scala @@ -2876,7 +2876,7 @@ class NormalStateSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike with test("recv CurrentFeerate (when funder, triggers an UpdateFee)") { f => import f._ val initialState = alice.stateData.asInstanceOf[DATA_NORMAL] - val event = CurrentFeerates(FeeratesPerKw(FeeratePerKw(50 sat), FeeratePerKw(100 sat), FeeratePerKw(200 sat), FeeratePerKw(600 sat), FeeratePerKw(1200 sat), FeeratePerKw(3600 sat), FeeratePerKw(7200 sat), FeeratePerKw(14400 sat), FeeratePerKw(100800 sat))) + val event = CurrentFeerates(FeeratesPerKw(FeeratePerKw(250 sat), FeeratePerKw(10_000 sat), FeeratePerKw(5_000 sat), FeeratePerKw(1000 sat), FeeratePerKw(500 sat))) alice.setFeerates(event.feeratesPerKw) alice ! event alice2bob.expectMsg(UpdateFee(initialState.commitments.channelId, alice.underlyingActor.nodeParams.onChainFeeConf.getCommitmentFeerate(alice.underlyingActor.nodeParams.currentFeerates, alice.underlyingActor.remoteNodeId, initialState.commitments.params.channelType, initialState.commitments.latest.capacity))) @@ -2886,13 +2886,13 @@ class NormalStateSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike with import f._ val initialState = alice.stateData.asInstanceOf[DATA_NORMAL] assert(initialState.commitments.latest.localCommit.spec.commitTxFeerate == TestConstants.anchorOutputsFeeratePerKw) - val event1 = CurrentFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw / 2).copy(mempoolMinFee = FeeratePerKw(250 sat))) + val event1 = CurrentFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw / 2).copy(minimum = FeeratePerKw(250 sat))) alice.setFeerates(event1.feeratesPerKw) alice ! event1 alice2bob.expectMsg(UpdateFee(initialState.commitments.channelId, TestConstants.anchorOutputsFeeratePerKw / 2)) alice2bob.expectMsgType[CommitSig] // The configured maximum feerate is bypassed if it's below the propagation threshold. - val event2 = CurrentFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw * 2).copy(mempoolMinFee = TestConstants.anchorOutputsFeeratePerKw)) + val event2 = CurrentFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw * 2).copy(minimum = TestConstants.anchorOutputsFeeratePerKw)) alice.setFeerates(event2.feeratesPerKw) alice ! event2 alice2bob.expectMsg(UpdateFee(initialState.commitments.channelId, TestConstants.anchorOutputsFeeratePerKw * 1.25)) @@ -2910,7 +2910,7 @@ class NormalStateSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike with import f._ val initialState = alice.stateData.asInstanceOf[DATA_NORMAL] assert(initialState.commitments.latest.localCommit.spec.commitTxFeerate == TestConstants.anchorOutputsFeeratePerKw) - val event = CurrentFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw * 2).copy(mempoolMinFee = FeeratePerKw(250 sat))) + val event = CurrentFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw * 2).copy(minimum = FeeratePerKw(250 sat))) alice.setFeerates(event.feeratesPerKw) alice ! event alice2bob.expectNoMessage(500 millis) diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/f/ShutdownStateSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/f/ShutdownStateSpec.scala index 2b22a0051a..2bac070c33 100644 --- a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/f/ShutdownStateSpec.scala +++ b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/f/ShutdownStateSpec.scala @@ -627,7 +627,7 @@ class ShutdownStateSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike wit test("recv CurrentFeerate (when funder, triggers an UpdateFee)") { f => import f._ val initialState = alice.stateData.asInstanceOf[DATA_SHUTDOWN] - val event = CurrentFeerates(FeeratesPerKw(FeeratePerKw(50 sat), FeeratePerKw(100 sat), FeeratePerKw(200 sat), FeeratePerKw(600 sat), FeeratePerKw(1200 sat), FeeratePerKw(3600 sat), FeeratePerKw(7200 sat), FeeratePerKw(14400 sat), FeeratePerKw(100800 sat))) + val event = CurrentFeerates(FeeratesPerKw(FeeratePerKw(250 sat), FeeratePerKw(10_000 sat), FeeratePerKw(5_000 sat), FeeratePerKw(1000 sat), FeeratePerKw(500 sat))) alice.setFeerates(event.feeratesPerKw) alice ! event alice2bob.expectMsg(UpdateFee(initialState.commitments.channelId, alice.underlyingActor.nodeParams.onChainFeeConf.getCommitmentFeerate(alice.underlyingActor.nodeParams.currentFeerates, alice.underlyingActor.remoteNodeId, initialState.commitments.params.channelType, initialState.commitments.latest.capacity))) @@ -637,7 +637,7 @@ class ShutdownStateSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike wit import f._ val initialState = alice.stateData.asInstanceOf[DATA_SHUTDOWN] assert(initialState.commitments.latest.localCommit.spec.commitTxFeerate == TestConstants.anchorOutputsFeeratePerKw) - val event = CurrentFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw / 2).copy(mempoolMinFee = FeeratePerKw(250 sat))) + val event = CurrentFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw / 2).copy(minimum = FeeratePerKw(250 sat))) alice.setFeerates(event.feeratesPerKw) alice ! event alice2bob.expectMsg(UpdateFee(initialState.commitments.channelId, TestConstants.anchorOutputsFeeratePerKw / 2)) @@ -655,7 +655,7 @@ class ShutdownStateSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike wit import f._ val initialState = alice.stateData.asInstanceOf[DATA_SHUTDOWN] assert(initialState.commitments.latest.localCommit.spec.commitTxFeerate == TestConstants.anchorOutputsFeeratePerKw) - val event = CurrentFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw * 2).copy(mempoolMinFee = FeeratePerKw(250 sat))) + val event = CurrentFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw * 2).copy(minimum = FeeratePerKw(250 sat))) alice.setFeerates(event.feeratesPerKw) alice ! event alice2bob.expectNoMessage(500 millis) diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/g/NegotiatingStateSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/g/NegotiatingStateSpec.scala index 3b1cfff82b..6147b732d7 100644 --- a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/g/NegotiatingStateSpec.scala +++ b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/g/NegotiatingStateSpec.scala @@ -87,7 +87,7 @@ class NegotiatingStateSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike } def buildFeerates(feerate: FeeratePerKw, minFeerate: FeeratePerKw = FeeratePerKw(250 sat)): FeeratesPerKw = - FeeratesPerKw.single(feerate).copy(mempoolMinFee = minFeerate, blocks_1008 = minFeerate) + FeeratesPerKw.single(feerate).copy(minimum = minFeerate, slow = minFeerate) test("recv CMD_ADD_HTLC") { f => import f._ @@ -105,8 +105,8 @@ class NegotiatingStateSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike import f._ // alice and bob see different on-chain feerates - alice.setFeerates(FeeratesPerKw(FeeratePerKw(250 sat), FeeratePerKw(10_000 sat), FeeratePerKw(8000 sat), FeeratePerKw(7500 sat), FeeratePerKw(5000 sat), FeeratePerKw(2000 sat), FeeratePerKw(2000 sat), FeeratePerKw(2000 sat), FeeratePerKw(2000 sat))) - bob.setFeerates(FeeratesPerKw(FeeratePerKw(250 sat), FeeratePerKw(15_000 sat), FeeratePerKw(12_500 sat), FeeratePerKw(10_000 sat), FeeratePerKw(7500 sat), FeeratePerKw(3000 sat), FeeratePerKw(3000 sat), FeeratePerKw(3000 sat), FeeratePerKw(3000 sat))) + alice.setFeerates(FeeratesPerKw(FeeratePerKw(250 sat), FeeratePerKw(10_000 sat), FeeratePerKw(8000 sat), FeeratePerKw(5000 sat), FeeratePerKw(2000 sat))) + bob.setFeerates(FeeratesPerKw(FeeratePerKw(250 sat), FeeratePerKw(15_000 sat), FeeratePerKw(12_500 sat), FeeratePerKw(7500 sat), FeeratePerKw(3000 sat))) if (bobInitiates) { bobClose(f) diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/h/ClosingStateSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/h/ClosingStateSpec.scala index 0e31c13b19..4be325daea 100644 --- a/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/h/ClosingStateSpec.scala +++ b/eclair-core/src/test/scala/fr/acinq/eclair/channel/states/h/ClosingStateSpec.scala @@ -288,7 +288,7 @@ class ClosingStateSpec extends TestKitBaseClass with FixtureAnyFunSuiteLike with import f._ val sender = TestProbe() assert(alice.stateData.asInstanceOf[DATA_NORMAL].commitments.params.channelFeatures == channelFeatures) - bob.underlyingActor.nodeParams.setFeerates(FeeratesPerKw.single(FeeratePerKw(2500 sat)).copy(mempoolMinFee = FeeratePerKw(250 sat), blocks_1008 = FeeratePerKw(250 sat))) + bob.underlyingActor.nodeParams.setFeerates(FeeratesPerKw.single(FeeratePerKw(2500 sat)).copy(minimum = FeeratePerKw(250 sat), slow = FeeratePerKw(250 sat))) // alice initiates a closing with a low fee alice ! CMD_CLOSE(sender.ref, None, Some(ClosingFeerates(FeeratePerKw(500 sat), FeeratePerKw(250 sat), FeeratePerKw(1000 sat)))) alice2bob.expectMsgType[Shutdown] diff --git a/eclair-core/src/test/scala/fr/acinq/eclair/io/PeerSpec.scala b/eclair-core/src/test/scala/fr/acinq/eclair/io/PeerSpec.scala index c3d0b63c88..452a8bb9f6 100644 --- a/eclair-core/src/test/scala/fr/acinq/eclair/io/PeerSpec.scala +++ b/eclair-core/src/test/scala/fr/acinq/eclair/io/PeerSpec.scala @@ -465,7 +465,7 @@ class PeerSpec extends FixtureSpec { assert(peer.stateData.channels.isEmpty) // We ensure the current network feerate is higher than the default anchor output feerate. - nodeParams.setFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw * 2).copy(mempoolMinFee = FeeratePerKw(250 sat))) + nodeParams.setFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw * 2).copy(minimum = FeeratePerKw(250 sat))) probe.send(peer, Peer.OpenChannel(remoteNodeId, 15000 sat, None, None, None, None, None)) val init = channel.expectMsgType[INPUT_INIT_CHANNEL_INITIATOR] assert(init.channelType == ChannelTypes.AnchorOutputs()) @@ -483,7 +483,7 @@ class PeerSpec extends FixtureSpec { assert(peer.stateData.channels.isEmpty) // We ensure the current network feerate is higher than the default anchor output feerate. - nodeParams.setFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw * 2).copy(mempoolMinFee = FeeratePerKw(250 sat))) + nodeParams.setFeerates(FeeratesPerKw.single(TestConstants.anchorOutputsFeeratePerKw * 2).copy(minimum = FeeratePerKw(250 sat))) probe.send(peer, Peer.OpenChannel(remoteNodeId, 15000 sat, None, None, None, None, None)) val init = channel.expectMsgType[INPUT_INIT_CHANNEL_INITIATOR] assert(init.channelType == ChannelTypes.AnchorOutputsZeroFeeHtlcTx())