test: migrate specs to new status taxonomy + add HLR coverage (#460)

Update all wallet specs to reflect the status changes introduced by HLR
#455: broadcaster is now required (no_send: true exempted), successful
broadcast sets status to 'unproven', and 'completed' is reserved for
actions that have received a merkle proof via internalize_action.

Add new specs covering: validate_broadcast_configuration! guard in
create_action and sign_action, internalize_action status ('unproven' vs
'completed' based on BUMP presence), and SolidQueueAdapter job-vs-wallet
status distinction.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sgbett

gem/bsv-wallet-postgres/spec/bsv/wallet_postgres/solid_queue_adapter_spec.rb

@@ -259,8 +259,9 @@ def action_status(txid)
       expect(output_state('chg:0').to_s).to eq('spendable')
     end
 
-    it 'updates action status to completed' do
-      expect(action_status(txid_a)).to eq('completed')
+    # Post-HLR #455: 'unproven' until a merkle proof lands via internalize_action
+    it 'updates action status to unproven' do
+      expect(action_status(txid_a)).to eq('unproven')
     end
   end
 
@@ -329,8 +330,9 @@ def action_status(txid)
       adapter.drain
     end
 
-    it 'updates action status to completed' do
-      expect(action_status(txid_a)).to eq('completed')
+    # Post-HLR #455: 'unproven' until a merkle proof lands via internalize_action
+    it 'updates action status to unproven' do
+      expect(action_status(txid_a)).to eq('unproven')
     end
 
     it 'marks job as completed' do

gem/bsv-wallet/spec/bsv/wallet_interface/auto_funding_spec.rb

@@ -66,7 +66,19 @@ def p2pkh_hex
 
   let(:private_key) { BSV::Primitives::PrivateKey.generate }
   let(:storage) { BSV::Wallet::MemoryStore.new }
-  let(:wallet) { BSV::Wallet::WalletClient.new(private_key, storage: storage) }
+  # Post-HLR #455: broadcaster required; create_action raises when absent and no_send unset.
+  let(:broadcaster) { double('broadcaster') } # rubocop:disable RSpec/VerifiedDoubles
+  let(:wallet) do
+    BSV::Wallet::WalletClient.new(private_key, storage: storage, broadcaster: broadcaster)
+  end
+
+  # Stub broadcast for all tests — auto_funding_spec tests auto-fund plumbing,
+  # not broadcast behaviour. SEEN_ON_NETWORK is the standard success response.
+  before do
+    allow(broadcaster).to receive(:broadcast).and_return(
+      BSV::Network::BroadcastResponse.new(txid: 'stub', tx_status: 'SEEN_ON_NETWORK')
+    )
+  end
 
   # ---------------------------------------------------------------------------
   # 1. Happy path — simple spend
@@ -130,11 +142,12 @@ def p2pkh_hex
       expect(change[:basket]).to eq('default')
     end
 
-    it 'stores the action as completed' do
+    # Post-HLR #455: 'unproven' until a merkle proof lands via internalize_action
+    it 'stores the action as unproven' do
       result
       actions = storage.find_actions({})
       expect(actions).not_to be_empty
-      expect(actions.last[:status]).to eq('completed')
+      expect(actions.last[:status]).to eq('unproven')
     end
 
     it 'produces a valid BEEF' do
@@ -418,6 +431,7 @@ def p2pkh_hex
       bad_wallet = BSV::Wallet::WalletClient.new(
         private_key,
         storage: storage,
+        broadcaster: broadcaster,
         change_generator: bad_generator
       )
 
@@ -656,6 +670,7 @@ def p2pkh_hex
       custom_wallet = BSV::Wallet::WalletClient.new(
         private_key,
         storage: storage,
+        broadcaster: broadcaster,
         fee_estimator: fee_estimator,
         coin_selector: coin_selector,
         change_generator: change_generator

gem/bsv-wallet/spec/bsv/wallet_interface/broadcast_rollback_spec.rb

@@ -130,11 +130,12 @@ def recipient_lock_hex
       change.each { |o| expect(o[:state]).to eq(:spendable) }
     end
 
-    it 'stores the action with status "completed"' do
+    # Post-HLR #455: 'unproven' until a merkle proof lands via internalize_action
+    it 'stores the action with status "unproven"' do
       txid = result[:txid]
       actions = storage.find_actions({ limit: 100, offset: 0 })
       action = actions.find { |a| a[:txid] == txid }
-      expect(action[:status]).to eq('completed')
+      expect(action[:status]).to eq('unproven')
     end
   end
 

gem/bsv-wallet/spec/bsv/wallet_interface/inline_queue_spec.rb

@@ -115,11 +115,12 @@ def build_payload(txid:, input_outpoints:, change_outpoints:, fund_ref: 'ref-001
       expect(outpoints).to include('xyz:0')
     end
 
-    it 'updates action status to "completed"' do
+    # Post-HLR #455: 'unproven' until a merkle proof lands via internalize_action
+    it 'updates action status to "unproven"' do
       result
       actions = storage.find_actions({ limit: 10, offset: 0 })
       action = actions.find { |a| a[:txid] == txid }
-      expect(action[:status]).to eq('completed')
+      expect(action[:status]).to eq('unproven')
     end
   end
 
@@ -181,9 +182,9 @@ def build_payload(txid:, input_outpoints:, change_outpoints:, fund_ref: 'ref-001
   end
 
   # --------------------------------------------------------------------------
-  # 3. Without broadcaster — promotes immediately
+  # 3. Without broadcaster — raises WalletError (HLR #455: no silent fallback)
   # --------------------------------------------------------------------------
-  describe 'without broadcaster' do
+  describe 'without broadcaster, no accept_delayed_broadcast' do
     let(:queue) { described_class.new(storage: storage) }
     let(:payload) do
       build_payload(
@@ -193,48 +194,21 @@ def build_payload(txid:, input_outpoints:, change_outpoints:, fund_ref: 'ref-001
         fund_ref: 'ref-nb'
       )
     end
-    let(:result) { queue.enqueue(payload) }
-    let(:txid)   { 'c' * 64 }
-    let(:input1) { seed_pending_output(storage, outpoint: 'in2:0', fund_ref: 'ref-nb') }
-    let(:change1) { seed_change_output(storage, outpoint: 'ch2:0') }
+    let(:txid) { 'c' * 64 }
 
     before do
-      input1
-      change1
+      seed_pending_output(storage, outpoint: 'in2:0', fund_ref: 'ref-nb')
+      seed_change_output(storage, outpoint: 'ch2:0')
       seed_action(storage, txid: txid)
     end
 
-    it 'returns the txid' do
-      expect(result[:txid]).to eq(txid)
-    end
-
-    it 'returns tx bytes' do
-      expect(result[:tx]).to be_an(Array)
-    end
-
-    it 'does not return broadcast_status' do
-      expect(result).not_to have_key(:broadcast_status)
-    end
-
-    it 'promotes input outputs to :spent' do
-      result
-      all = storage.find_outputs({ include_spent: true, limit: 100, offset: 0 })
-      input = all.find { |o| o[:outpoint] == 'in2:0' }
-      expect(input[:state]).to eq(:spent)
-    end
-
-    it 'promotes change outputs to :spendable' do
-      result
-      spendable = storage.find_spendable_outputs
-      outpoints = spendable.map { |o| o[:outpoint] }
-      expect(outpoints).to include('ch2:0')
-    end
-
-    it 'sets action status to "completed"' do
-      result
-      actions = storage.find_actions({ limit: 10, offset: 0 })
-      action = actions.find { |a| a[:txid] == txid }
-      expect(action[:status]).to eq('completed')
+    # Post-HLR #455: silent fallback to 'completed' removed; raises WalletError
+    # unless accept_delayed_broadcast is explicitly set on the payload.
+    it 'raises WalletError when accept_delayed_broadcast is false' do
+      expect { queue.enqueue(payload) }.to raise_error(
+        BSV::Wallet::WalletError,
+        /accept_delayed_broadcast/
+      )
     end
   end
 
@@ -299,11 +273,12 @@ def build_payload(txid:, input_outpoints:, change_outpoints:, fund_ref: 'ref-001
       expect(result[:broadcast_status]).to eq('success')
     end
 
-    it 'updates action status to "completed"' do
+    # Post-HLR #455: 'unproven' until a merkle proof lands via internalize_action
+    it 'updates action status to "unproven"' do
       result
       actions = storage.find_actions({ limit: 10, offset: 0 })
       action = actions.find { |a| a[:txid] == txid }
-      expect(action[:status]).to eq('completed')
+      expect(action[:status]).to eq('unproven')
     end
 
     it 'does not add any extra outputs' do

gem/bsv-wallet/spec/bsv/wallet_interface/pending_lock_spec.rb

@@ -121,7 +121,17 @@ def seed_output(outpoint: 'tx0:0', satoshis: 1000, basket: 'default')
   describe 'abort_action releases pending UTXOs' do
     let(:private_key) { BSV::Primitives::PrivateKey.generate }
     let(:storage)     { BSV::Wallet::MemoryStore.new }
-    let(:wallet)      { BSV::Wallet::WalletClient.new(private_key, storage: storage) }
+    # Post-HLR #455: broadcaster required; create_action raises without one.
+    let(:broadcaster) { double('broadcaster') } # rubocop:disable RSpec/VerifiedDoubles
+    let(:wallet) do
+      BSV::Wallet::WalletClient.new(private_key, storage: storage, broadcaster: broadcaster)
+    end
+
+    before do
+      allow(broadcaster).to receive(:broadcast).and_return(
+        BSV::Network::BroadcastResponse.new(txid: 'stub', tx_status: 'SEEN_ON_NETWORK')
+      )
+    end
 
     def seed_wallet_utxo(satoshis:)
       prefix = SecureRandom.hex(16)

gem/bsv-wallet/spec/bsv/wallet_interface/proof_round_trip_spec.rb

@@ -5,10 +5,6 @@
 
 RSpec.describe 'Proof round-trip: internalize_action → create_action → valid BEEF' do
   let(:private_key) { BSV::Primitives::PrivateKey.generate }
-  let(:pub_key) { private_key.public_key }
-  let(:storage) { BSV::Wallet::MemoryStore.new }
-  let(:wallet) { BSV::Wallet::WalletClient.new(private_key, storage: storage) }
-
   # Build a minimal source transaction (coin we're receiving).
   let(:source_tx) do
     tx = BSV::Transaction::Transaction.new
@@ -20,7 +16,6 @@
     )
     tx
   end
-
   # Build a simple merkle proof for the source transaction.
   # Level 0 leaf hashes are in internal byte order (reverse of display
   # order), matching the BRC-74 wire format and compute_root lookup.
@@ -35,7 +30,6 @@
     )
     BSV::Transaction::MerklePath.new(block_height: 800_000, path: [[tx_elem, sibling_elem]])
   end
-
   # Attach the proof to the source tx, then build a BEEF that carries it.
   let(:beef_for_internalize) do
     source_tx.merkle_path = merkle_path
@@ -71,13 +65,11 @@
 
     beef.to_binary
   end
-
   let(:subject_txid) do
     # Parse the BEEF to retrieve the subject transaction's txid.
     beef = BSV::Transaction::Beef.from_binary(beef_for_internalize)
     beef.transactions.last.transaction.txid_hex
   end
-
   let(:internalize_args) do
     {
       tx: beef_for_internalize.unpack('C*'),
@@ -91,6 +83,17 @@
       ]
     }
   end
+  let(:pub_key) { private_key.public_key }
+  let(:storage) { BSV::Wallet::MemoryStore.new }
+  # Post-HLR #455: broadcaster required; create_action raises without one.
+  let(:broadcaster) { double('broadcaster') } # rubocop:disable RSpec/VerifiedDoubles
+  let(:wallet) { BSV::Wallet::WalletClient.new(private_key, storage: storage, broadcaster: broadcaster) }
+
+  before do
+    allow(broadcaster).to receive(:broadcast).and_return(
+      BSV::Network::BroadcastResponse.new(txid: 'stub', tx_status: 'SEEN_ON_NETWORK')
+    )
+  end
 
   describe 'internalize_action' do
     it 'stores the merkle proof from the BEEF' do