fix!: Correct absolute timelock boundary checks

Fix off-by-one error in absolute timelock checks. Bitcoin Core's
`IsFinalTx` uses strict less-than: tx is final when `nLockTime < MTP`
(for time) or `nLockTime < blockHeight` (for height). The previous
checks used `>` but should use `>=` to match Core's behavior.

Also add 4 new time-based timelock tests that verify BDK's predictions
match Bitcoin Core's actual broadcast acceptance at exact boundaries:
- test_absolute_time_timelock_logic (integration)
- test_relative_time_timelock_logic (integration)
- test_is_time_timelocked_absolute_unit
- test_is_time_timelocked_relative_unit

Patch miniscript to fix Plan::satisfy() not appending witnessScript
for P2WSH descriptors (rust-bitcoin/rust-miniscript#XXX).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: evanlinjin

Cargo.toml

@@ -47,6 +47,7 @@ bdk_testenv = { git = "https://github.com/evanlinjin/bdk", branch = "feature/bit
 bdk_chain = { git = "https://github.com/evanlinjin/bdk", branch = "feature/bitcoind_rpc_emit_header" }
 bdk_core = { git = "https://github.com/evanlinjin/bdk", branch = "feature/bitcoind_rpc_emit_header" }
 bdk_bitcoind_rpc = { git = "https://github.com/evanlinjin/bdk", branch = "feature/bitcoind_rpc_emit_header" }
+miniscript = { git = "https://github.com/evanlinjin/rust-miniscript", branch = "fix/plan-satisfy-does-not-append-witness-script-for-p2wsh" }
 
 # bdk_chain = { git = "https://github.com/bitcoindevkit/bdk", branch = "master" }
 # bdk_core = { git = "https://github.com/bitcoindevkit/bdk", branch = "master" }

src/input.rs

@@ -368,12 +368,17 @@ impl Input {
             .checked_add(1)
             .expect("must not overflow");
         if let Some(absolute::LockTime::Blocks(lt_height)) = self.plan.absolute_timelock() {
-            return lt_height.to_consensus_u32() > spending_height;
+            // Bitcoin Core's `IsFinalTx` uses strict less-than: a tx is final (unlocked) when
+            // `nLockTime < blockHeight`. This means `nLockTime = 100` is first spendable in
+            // block 101, not block 100. We return "locked" when the inverse is true.
+            return lt_height.to_consensus_u32() >= spending_height;
         }
 
         if let (Some(relative::LockTime::Blocks(lt_height)), Some(conf_status)) =
             (self.plan.relative_timelock(), self.status)
         {
+            // BIP 68: relative lock is satisfied when `height_diff >= lock_value`.
+            // We return "locked" when `lock_value > height_diff`.
             let height_diff = spending_height.saturating_sub(conf_status.height.to_consensus_u32());
             return lt_height.to_consensus_u32() > height_diff;
         }
@@ -388,12 +393,17 @@ impl Input {
     /// `tip_mtp` is `MTP(tip)`, or `MTP(spending_block - 1)`, as per BIP-0068.
     pub fn is_time_timelocked(&self, tip_mtp: absolute::Time) -> Option<bool> {
         if let Some(absolute::LockTime::Seconds(lt_time)) = self.plan.absolute_timelock() {
-            return Some(lt_time.to_consensus_u32() > tip_mtp.to_consensus_u32());
+            // Bitcoin Core's `IsFinalTx` (with BIP 113) uses strict less-than: a tx is final
+            // (unlocked) when `nLockTime < MTP`. This means `nLockTime = T` is first spendable
+            // when `MTP > T`, not when `MTP == T`. We return "locked" when the inverse is true.
+            return Some(lt_time.to_consensus_u32() >= tip_mtp.to_consensus_u32());
         }
 
         if let (Some(relative::LockTime::Time(lt_time)), Some(conf_status)) =
             (self.plan.relative_timelock(), self.status)
         {
+            // BIP 68: relative time lock is satisfied when `time_diff >= lock_value * 512`.
+            // We return "locked" when `lock_value * 512 > time_diff`.
             let time_diff = tip_mtp
                 .to_consensus_u32()
                 .saturating_sub(conf_status.prev_mtp?.to_consensus_u32());