bsv-sdk 0.15.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27489947d80a203e32fad08b53cfee4edabca7df61f244dff2ca12c5fa45e261
-  data.tar.gz: d3bd5ead19a4fa67f4111e9bd3a203a1cad3c083ad4b8e174ee114b5b7fdb4bd
+  metadata.gz: 0c528b336af4735e247429423231a5c6a0dd681718e94d7a3d9598b65b75a6a0
+  data.tar.gz: 21efe7a43b3ba356953af1668cb35227d9c72bd3b17a1f08a54fac2f55f0d577
 SHA512:
-  metadata.gz: 5ebdd5176602d584debb675d470dc31079cb16a29bb858c806123227efe03783c7c7f77eccf38174e254b7579fae9bad71d17c9e71791c21a694653647e15ad6
-  data.tar.gz: cedddebaec0eeb9c2fa037af4227ad7307492146c2b4dc18d3a7f4dfc7f3179c20428245424d0a8542db97bbad08831a334d7821f17fd3c05264d38289271552
+  metadata.gz: 94b507d613413fbb96ab08f72d5db324ea33626f0f32af34f248b7d3133bd847aff1527de7ea1e68c1a1cbc1f5140f7654d4be99726348d85b852483ea00519a
+  data.tar.gz: 71c1fd8a86414cce69c1c4ec4fe1df52bab863c624ba70b806f37e2e016968eca9ac0244c42b0d52407c1817f56d9133403d3aec04a41bb39766776eb4b8c108

data/CHANGELOG.md

@@ -5,6 +5,44 @@ All notable changes to the `bsv-sdk` gem are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 and this gem adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.17.0 — 2026-05-02
+
+### Breaking Changes
+- Renamed `TransactionInput#prev_tx_id` to `#prev_wtxid` — all call sites must update (#678)
+- Renamed MerklePath parameters from `txid_hex` to `dtxid_hex` throughout (#681)
+
+### Added
+- `Transaction#wtxid` — wire-order transaction ID (raw SHA-256d bytes) (#673)
+- `Transaction#dtxid` / `#dtxid_hex` — display-order hex aliases (#680)
+- `TransactionInput#dtxid_hex` — display-order hex of the referenced transaction (#678)
+- `TransactionInput.wtxid_from_hex` — convert display-order hex to wire-order bytes (#678)
+- `Hex.validate_wtxid!` / `Hex.validate_dtxid_hex!` — runtime validation for wire/display txid formats (#685)
+- `Hex.validate_hash32!` — general-purpose 32-byte binary hash validator (#686)
+- `BSV.logger` — opt-in debug instrumentation with zero overhead when unused (#686)
+- Debug logging at txid conversions, sighash preimage, script interpreter, ARC broadcast, BEEF ancestry, and ProtoWallet key derivation (#686, #688)
+
+### Changed
+- All internal txid variables renamed to `wtxid` (wire-order) convention (#679)
+- BEEF internals enforce wire-order throughout — no byte-reversals inside the bundle (#675)
+- MerklePath `compute_root_hex` and `from_tsc` now validate hex input (#686)
+
+### Fixed
+- `BeefTx#dtxid` now returns hex string (was returning binary) (#677)
+- Certificate field naming aligned with BRC-52 convention (#677)
+
+## 0.16.0 — 2026-05-01
+
+### Breaking Changes
+- Removed `bsv-wallet` and `bsv-wallet-postgres` gems from the monorepo (#662)
+- Unified `BSV::Wallet` namespace with canonical BRC-100 interface, error reconciliation, and idiomatic ProtoWallet (#664)
+- Hard-deprecated `Network::ARC` and `Network::WhatsOnChain` facades (#659)
+
+### Added
+- `BSV::Wallet::ProtoWallet` for SDK-native cryptographic operations (signing, encryption, HMAC, key derivation) (#662)
+
+### Fixed
+- Guard nil `status_code` in MCP error messages (#659)
+
 ## 0.15.0 — 2026-04-29
 
 ### Added

data/lib/bsv/auth/auth_middleware.rb

@@ -180,12 +180,12 @@ module BSV
         response_nonce = ::Base64.strict_encode64(::SecureRandom.random_bytes(32))
         key_id         = "#{response_nonce} #{session.peer_nonce}"
 
-        sig_result = @wallet.create_signature({
-                                                data: response_payload_bin.bytes,
-                                                protocol_id: Peer::AUTH_PROTOCOL,
-                                                key_id: key_id,
-                                                counterparty: identity_key
-                                              })
+        sig_result = @wallet.create_signature(
+          data: response_payload_bin.bytes,
+          protocol_id: Peer::AUTH_PROTOCOL,
+          key_id: key_id,
+          counterparty: identity_key
+        )
 
         our_identity_key = @peer.identity_key
         sig_hex_out      = sig_result[:signature].pack('C*').unpack1('H*')

data/lib/bsv/auth/certificate.rb

@@ -81,6 +81,9 @@ module BSV
         buf << [@subject].pack('H*')
         buf << [@certifier].pack('H*')
 
+        # Certificate binary format: revocation outpoint txid stored in display byte
+        # order (matching TS and Go SDKs). Go encodes via WriteBytesReverse(wire_order),
+        # TS encodes via toArray(display_hex) — both produce identical display-order bytes.
         txid_hex, output_index_str = @revocation_outpoint.to_s.split('.', 2)
         buf << [txid_hex].pack('H*')
         buf << BSV::Transaction::VarInt.encode(output_index_str.to_i)
@@ -124,7 +127,8 @@ module BSV
         certifier_bytes = data.byteslice(pos, 33)
         pos += 33
 
-        txid_bytes = data.byteslice(pos, 32)
+        # Outpoint txid bytes — stored in display byte order (matching TS and Go SDKs).
+        outpoint_txid = data.byteslice(pos, 32)
         pos += 32
         output_index, vi_len = BSV::Transaction::VarInt.decode(data, pos)
         pos += vi_len
@@ -158,7 +162,7 @@ module BSV
           serial_number: Base64.strict_encode64(serial_bytes),
           subject: subject_bytes.unpack1('H*'),
           certifier: certifier_bytes.unpack1('H*'),
-          revocation_outpoint: "#{txid_bytes.unpack1('H*')}.#{output_index}",
+          revocation_outpoint: "#{outpoint_txid.unpack1('H*')}.#{output_index}",
           fields: fields,
           signature: signature
         )
@@ -166,27 +170,27 @@ module BSV
 
       # Verify the certificate's signature.
       #
-      # Uses a fresh +'anyone'+ Client as the verifier, which matches the
+      # Uses a fresh +'anyone'+ ProtoWallet as the verifier, which matches the
       # TS SDK behaviour. If no signature is present, raises +ArgumentError+.
       #
       # @param verifier_wallet [#verify_signature, nil] wallet to verify with;
-      #   defaults to +BSV::Wallet::Client.new('anyone', storage: BSV::Wallet::Store::Memory.new)+
+      #   defaults to +BSV::Wallet::ProtoWallet.new('anyone')+
       # @return [Boolean] +true+ if the signature is valid
       # @raise [ArgumentError] if the certificate has no signature
       def verify(verifier_wallet = nil)
         raise ArgumentError, 'certificate has no signature to verify' if @signature.nil? || @signature.empty?
 
-        verifier_wallet ||= BSV::Wallet::Client.new('anyone', storage: BSV::Wallet::Store::Memory.new, allow_memory_store: true)
+        verifier_wallet ||= BSV::Wallet::ProtoWallet.new('anyone')
         preimage  = to_binary(include_signature: false)
         sig_bytes = [@signature].pack('H*').unpack('C*')
 
-        result = verifier_wallet.verify_signature({
-                                                    data: preimage.unpack('C*'),
-                                                    signature: sig_bytes,
-                                                    protocol_id: CERT_SIG_PROTOCOL,
-                                                    key_id: "#{@type} #{@serial_number}",
-                                                    counterparty: @certifier
-                                                  })
+        result = verifier_wallet.verify_signature(
+          data: preimage.unpack('C*'),
+          signature: sig_bytes,
+          protocol_id: CERT_SIG_PROTOCOL,
+          key_id: "#{@type} #{@serial_number}",
+          counterparty: @certifier
+        )
 
         result.is_a?(Hash) && result[:valid] == true
       rescue BSV::Wallet::InvalidSignatureError
@@ -203,14 +207,14 @@ module BSV
       def sign(certifier_wallet)
         raise ArgumentError, "certificate has already been signed: #{@signature}" if @signature && !@signature.empty?
 
-        @certifier = certifier_wallet.get_public_key({ identity_key: true })[:public_key]
+        @certifier = certifier_wallet.get_public_key(identity_key: true)[:public_key]
 
         preimage = to_binary(include_signature: false)
-        result   = certifier_wallet.create_signature({
-                                                       data: preimage.unpack('C*'),
-                                                       protocol_id: CERT_SIG_PROTOCOL,
-                                                       key_id: "#{@type} #{@serial_number}"
-                                                     })
+        result   = certifier_wallet.create_signature(
+          data: preimage.unpack('C*'),
+          protocol_id: CERT_SIG_PROTOCOL,
+          key_id: "#{@type} #{@serial_number}"
+        )
         @signature = result[:signature].pack('C*').unpack1('H*')
       end
 

data/lib/bsv/auth/master_certificate.rb

@@ -128,7 +128,7 @@ module BSV
             privileged_reason: privileged_reason
           }.merge(Certificate.certificate_field_encryption_details(field_name))
 
-          result = creator_wallet.encrypt(enc_args)
+          result = creator_wallet.encrypt(**enc_args)
           master_keyring[field_name] = Base64.strict_encode64(result[:ciphertext].pack('C*'))
         end
 
@@ -187,7 +187,7 @@ module BSV
             privileged_reason: privileged_reason
           }.merge(Certificate.certificate_field_encryption_details(field_name, serial_number))
 
-          result = subject_wallet.encrypt(enc_args)
+          result = subject_wallet.encrypt(**enc_args)
           keyring[field_name] = Base64.strict_encode64(result[:ciphertext].pack('C*'))
         end
 
@@ -218,7 +218,7 @@ module BSV
         keyring = result[:master_keyring]
 
         subject_key = if subject == 'self'
-                        certifier_wallet.get_public_key({ identity_key: true })[:public_key]
+                        certifier_wallet.get_public_key(identity_key: true)[:public_key]
                       else
                         subject
                       end
@@ -229,7 +229,7 @@ module BSV
                                 "#{'00' * 32}.0"
                               end
 
-        certifier_key = certifier_wallet.get_public_key({ identity_key: true })[:public_key]
+        certifier_key = certifier_wallet.get_public_key(identity_key: true)[:public_key]
 
         cert = new(
           type: certificate_type,
@@ -309,7 +309,7 @@ module BSV
             privileged_reason: privileged_reason
           }.merge(Certificate.certificate_field_encryption_details(field_name))
 
-          field_revelation_key = wallet.decrypt(dec_args)[:plaintext]
+          field_revelation_key = wallet.decrypt(**dec_args)[:plaintext]
 
           sym_key = BSV::Primitives::SymmetricKey.new(field_revelation_key.pack('C*'))
           decrypted_bytes = sym_key.decrypt(Base64.strict_decode64(field_value))

data/lib/bsv/auth/nonce.rb

@@ -34,12 +34,12 @@ module BSV
         first_half = SecureRandom.random_bytes(RANDOM_BYTES)
         key_id     = decode_as_utf8(first_half)
 
-        result = wallet.create_hmac({
-                                      data: first_half.bytes,
-                                      protocol_id: PROTOCOL_ID,
-                                      key_id: key_id,
-                                      counterparty: counterparty
-                                    })
+        result = wallet.create_hmac(
+          data: first_half.bytes,
+          protocol_id: PROTOCOL_ID,
+          key_id: key_id,
+          counterparty: counterparty
+        )
 
         nonce_bytes = first_half + result[:hmac].pack('C*')
         ::Base64.strict_encode64(nonce_bytes)
@@ -60,13 +60,13 @@ module BSV
         hmac_bytes = nonce_bytes.byteslice(RANDOM_BYTES, nonce_bytes.bytesize - RANDOM_BYTES)
         key_id     = decode_as_utf8(first_half)
 
-        wallet.verify_hmac({
-                             data: first_half.bytes,
-                             hmac: hmac_bytes.bytes,
-                             protocol_id: PROTOCOL_ID,
-                             key_id: key_id,
-                             counterparty: counterparty
-                           })
+        wallet.verify_hmac(
+          data: first_half.bytes,
+          hmac: hmac_bytes.bytes,
+          protocol_id: PROTOCOL_ID,
+          key_id: key_id,
+          counterparty: counterparty
+        )
 
         true
       rescue BSV::Wallet::InvalidHmacError

data/lib/bsv/auth/peer.rb

@@ -180,7 +180,7 @@ module BSV
       #
       # @return [String] compressed public key hex
       def identity_key
-        @identity_key ||= @wallet.get_public_key({ identity_key: true })[:public_key]
+        @identity_key ||= @wallet.get_public_key(identity_key: true)[:public_key]
       end
 
       # Checks whether we have an authenticated session with a peer.
@@ -318,12 +318,12 @@ module BSV
         key_id        = key_id_for(request_nonce, session.peer_nonce)
         data          = JSON.generate(certificates_to_request).encode('UTF-8').bytes
 
-        sig_result = @wallet.create_signature({
-                                                data: data,
-                                                protocol_id: AUTH_PROTOCOL,
-                                                key_id: key_id,
-                                                counterparty: session.peer_identity_key
-                                              })
+        sig_result = @wallet.create_signature(
+          data: data,
+          protocol_id: AUTH_PROTOCOL,
+          key_id: key_id,
+          counterparty: session.peer_identity_key
+        )
 
         session.last_update = current_time_ms
         @session_manager.update_session(session)
@@ -355,12 +355,12 @@ module BSV
         cert_data     = certificates.map { |c| c.respond_to?(:to_h) ? c.to_h : c }
         data          = JSON.generate(cert_data).encode('UTF-8').bytes
 
-        sig_result = @wallet.create_signature({
-                                                data: data,
-                                                protocol_id: AUTH_PROTOCOL,
-                                                key_id: key_id,
-                                                counterparty: session.peer_identity_key
-                                              })
+        sig_result = @wallet.create_signature(
+          data: data,
+          protocol_id: AUTH_PROTOCOL,
+          key_id: key_id,
+          counterparty: session.peer_identity_key
+        )
 
         session.last_update = current_time_ms
         @session_manager.update_session(session)
@@ -394,12 +394,12 @@ module BSV
         request_nonce = ::Base64.strict_encode64(SecureRandom.random_bytes(32))
         key_id        = key_id_for(request_nonce, session.peer_nonce)
 
-        sig_result = @wallet.create_signature({
-                                                data: payload,
-                                                protocol_id: AUTH_PROTOCOL,
-                                                key_id: key_id,
-                                                counterparty: session.peer_identity_key
-                                              })
+        sig_result = @wallet.create_signature(
+          data: payload,
+          protocol_id: AUTH_PROTOCOL,
+          key_id: key_id,
+          counterparty: session.peer_identity_key
+        )
 
         session.last_update = current_time_ms
         @session_manager.update_session(session)
@@ -455,12 +455,12 @@ module BSV
         sig_data = b64_decode(their_nonce) + b64_decode(our_nonce)
         key_id   = key_id_for(their_nonce, our_nonce)
 
-        sig_result = @wallet.create_signature({
-                                                data: sig_data,
-                                                protocol_id: AUTH_PROTOCOL,
-                                                key_id: key_id,
-                                                counterparty: peer_key
-                                              })
+        sig_result = @wallet.create_signature(
+          data: sig_data,
+          protocol_id: AUTH_PROTOCOL,
+          key_id: key_id,
+          counterparty: peer_key
+        )
 
         @last_interacted_peer ||= peer_key if @auto_persist_last_session
 
@@ -498,13 +498,13 @@ module BSV
         sig_data = b64_decode(our_nonce) + b64_decode(their_nonce)
         key_id   = key_id_for(our_nonce, their_nonce)
 
-        @wallet.verify_signature({
-                                   data: sig_data,
-                                   signature: signature,
-                                   protocol_id: AUTH_PROTOCOL,
-                                   key_id: key_id,
-                                   counterparty: peer_key
-                                 })
+        @wallet.verify_signature(
+          data: sig_data,
+          signature: signature,
+          protocol_id: AUTH_PROTOCOL,
+          key_id: key_id,
+          counterparty: peer_key
+        )
 
         # Authentication complete
         session.peer_nonce        = their_nonce
@@ -574,13 +574,13 @@ module BSV
         # Verify signature: signed over payload with key_id "msg_nonce session_nonce"
         key_id = key_id_for(msg_nonce, session.session_nonce)
 
-        @wallet.verify_signature({
-                                   data: payload,
-                                   signature: signature,
-                                   protocol_id: AUTH_PROTOCOL,
-                                   key_id: key_id,
-                                   counterparty: session.peer_identity_key
-                                 })
+        @wallet.verify_signature(
+          data: payload,
+          signature: signature,
+          protocol_id: AUTH_PROTOCOL,
+          key_id: key_id,
+          counterparty: session.peer_identity_key
+        )
 
         session.last_update = current_time_ms
         @session_manager.update_session(session)
@@ -610,13 +610,13 @@ module BSV
         data   = JSON.generate(requested).encode('UTF-8').bytes
         key_id = key_id_for(msg_nonce, session.session_nonce)
 
-        @wallet.verify_signature({
-                                   data: data,
-                                   signature: signature,
-                                   protocol_id: AUTH_PROTOCOL,
-                                   key_id: key_id,
-                                   counterparty: session.peer_identity_key
-                                 })
+        @wallet.verify_signature(
+          data: data,
+          signature: signature,
+          protocol_id: AUTH_PROTOCOL,
+          key_id: key_id,
+          counterparty: session.peer_identity_key
+        )
 
         session.last_update = current_time_ms
         @session_manager.update_session(session)
@@ -655,13 +655,13 @@ module BSV
         data   = JSON.generate(certs).encode('UTF-8').bytes
         key_id = key_id_for(msg_nonce, session.session_nonce)
 
-        @wallet.verify_signature({
-                                   data: data,
-                                   signature: signature,
-                                   protocol_id: AUTH_PROTOCOL,
-                                   key_id: key_id,
-                                   counterparty: session.peer_identity_key
-                                 })
+        @wallet.verify_signature(
+          data: data,
+          signature: signature,
+          protocol_id: AUTH_PROTOCOL,
+          key_id: key_id,
+          counterparty: session.peer_identity_key
+        )
 
         if certs.is_a?(Array) && !certs.empty?
           validation_msg = { identity_key: session.peer_identity_key, certificates: certs }

data/lib/bsv/auth/verifiable_certificate.rb

@@ -130,7 +130,7 @@ module BSV
               privileged_reason: privileged_reason
             }.merge(Certificate.certificate_field_encryption_details(field_name, @serial_number))
 
-            field_revelation_key = verifier_wallet.decrypt(dec_args)[:plaintext]
+            field_revelation_key = verifier_wallet.decrypt(**dec_args)[:plaintext]
 
             sym_key = BSV::Primitives::SymmetricKey.new(field_revelation_key.pack('C*'))
             decrypted_bytes = sym_key.decrypt(Base64.strict_decode64(@fields[field_name]))

data/lib/bsv/identity/client.rb

@@ -71,7 +71,7 @@ module BSV
         args[:limit]  = limit  unless limit.nil?
         args[:offset] = offset unless offset.nil?
 
-        result = @wallet.discover_by_identity_key(args, originator: @originator)
+        result = @wallet.discover_by_identity_key(**args, originator: @originator)
         parse_certificates(result)
       end
 
@@ -89,7 +89,7 @@ module BSV
         args[:limit]  = limit  unless limit.nil?
         args[:offset] = offset unless offset.nil?
 
-        result = @wallet.discover_by_attributes(args, originator: @originator)
+        result = @wallet.discover_by_attributes(**args, originator: @originator)
         parse_certificates(result)
       end
 
@@ -117,7 +117,7 @@ module BSV
         # Prove the certificate to the "anyone" verifier (PrivateKey(1) public key)
         anyone_pubkey = BSV::Script::PushDropTemplate::GENERATOR_PUBKEY_HEX
         prove_result  = @wallet.prove_certificate(
-          { certificate: certificate, fields_to_reveal: fields_to_reveal, verifier: anyone_pubkey },
+          certificate: certificate, fields_to_reveal: fields_to_reveal, verifier: anyone_pubkey,
           originator: @originator
         )
         keyring = prove_result[:keyring_for_verifier]
@@ -155,17 +155,15 @@ module BSV
 
         # Create the transaction
         create_result = @wallet.create_action(
-          {
-            description: 'Create a new Identity Token',
-            outputs: [
-              {
-                satoshis: @options.token_amount,
-                locking_script: locking_script.to_hex,
-                output_description: 'Identity Token'
-              }
-            ],
-            options: { randomize_outputs: false }
-          },
+          description: 'Create a new Identity Token',
+          outputs: [
+            {
+              satoshis: @options.token_amount,
+              locking_script: locking_script.to_hex,
+              output_description: 'Identity Token'
+            }
+          ],
+          options: { randomize_outputs: false },
           originator: @originator
         )
 
@@ -209,24 +207,23 @@ module BSV
         raise 'Revoke failed: no transaction found in BEEF' unless tx
         raise 'Revoke failed: outputIndex out of range' if output_idx >= tx.outputs.length
 
+        # Overlay API boundary: outpoint uses display-order hex txid as per overlay convention
         txid = tx.txid_hex
         outpoint = "#{txid}.#{output_idx}"
 
         # Create a spending transaction; use unlocking_script_length so the wallet
         # produces a signable transaction that can then be signed and broadcast.
         create_result = @wallet.create_action(
-          {
-            description: 'Spend certificate revelation token',
-            input_beef: beef_bytes,
-            inputs: [
-              {
-                input_description: 'Revelation token',
-                outpoint: outpoint,
-                unlocking_script_length: BSV::Script::PushDropTemplate::Unlocker::ESTIMATED_LENGTH
-              }
-            ],
-            options: { randomize_outputs: false, no_send: true }
-          },
+          description: 'Spend certificate revelation token',
+          input_beef: beef_bytes,
+          inputs: [
+            {
+              input_description: 'Revelation token',
+              outpoint: outpoint,
+              unlocking_script_length: BSV::Script::PushDropTemplate::Unlocker::ESTIMATED_LENGTH
+            }
+          ],
+          options: { randomize_outputs: false, no_send: true },
           originator: @originator
         )
 
@@ -248,11 +245,9 @@ module BSV
         unlocking_script = unlocker.sign(partial_tx, spending_input_idx)
 
         sign_result = @wallet.sign_action(
-          {
-            reference: signable[:reference],
-            spends: { spending_input_idx => { unlocking_script: unlocking_script.to_hex } },
-            options: { no_send: true }
-          },
+          reference: signable[:reference],
+          spends: { spending_input_idx => { unlocking_script: unlocking_script.to_hex } },
+          options: { no_send: true },
           originator: @originator
         )
 
@@ -343,7 +338,7 @@ module BSV
       #
       # @return [Symbol] :mainnet or :testnet
       def wallet_network
-        result = @wallet.get_network({}, originator: @originator)
+        result = @wallet.get_network(originator: @originator)
         net_str = result[:network] || result['network'] || 'mainnet'
         net_str.to_sym
       end

data/lib/bsv/mcp/tools/broadcast_p2pkh.rb

@@ -91,8 +91,16 @@ module BSV
           private_key = BSV::Primitives::PrivateKey.from_wif(wif)
           sender_address = private_key.public_key.address(network: net_sym)
 
-          woc = BSV::Network::WhatsOnChain.new(network: net_sym)
-          all_utxos = woc.fetch_utxos(sender_address)
+          woc = BSV::Network::Providers::WhatsOnChain.default(network: net_sym)
+          utxo_result = woc.call(:get_utxos_all, sender_address)
+          return Helpers.error_response("UTXO fetch failed: #{utxo_result.message}") unless utxo_result.success?
+
+          all_utxos = utxo_result.data.map do |entry|
+            BSV::Network::UTXO.new(
+              tx_hash: entry[:tx_hash], tx_pos: entry[:tx_pos],
+              satoshis: entry[:satoshis], height: entry[:height]
+            )
+          end
 
           return Helpers.error_response('No UTXOs found for sender address — the address may have no funds') if all_utxos.empty?
 
@@ -104,11 +112,12 @@ module BSV
           tx = build_transaction(selected, satoshis, to_address, sender_address, private_key)
 
           arc = build_arc(net_sym, server_context)
-          broadcast_result = arc.broadcast(tx)
+          arc_result = arc.call(:broadcast, tx)
+          return Helpers.error_response("Broadcast failed: #{arc_result.message}") unless arc_result.success?
 
           result = {
-            txid: broadcast_result.txid,
-            tx_status: broadcast_result.tx_status,
+            txid: arc_result.data[:txid], # MCP tool boundary: display-order hex from ARC response
+            tx_status: arc_result.data[:tx_status],
             hex: tx.to_hex
           }
 
@@ -118,10 +127,6 @@ module BSV
           )
         rescue ArgumentError => e
           Helpers.error_response(e.message)
-        rescue BSV::Network::ChainProviderError => e
-          Helpers.error_response("UTXO fetch failed: #{e.message}")
-        rescue BSV::Network::BroadcastError => e
-          Helpers.error_response("Broadcast failed: #{e.message}")
         end
 
         # Select UTXOs greedily until the total meets or exceeds the target.
@@ -149,7 +154,7 @@ module BSV
           selected_utxos.each do |utxo|
             locking_script = p2pkh_lock_for(sender_address)
             input = BSV::Transaction::TransactionInput.new(
-              prev_tx_id: BSV::Transaction::TransactionInput.txid_from_hex(utxo.tx_hash),
+              prev_wtxid: BSV::Transaction::TransactionInput.wtxid_from_hex(utxo.tx_hash),
               prev_tx_out_index: utxo.tx_pos
             )
             input.source_satoshis = utxo.satoshis
@@ -196,13 +201,14 @@ module BSV
         end
         private_class_method :p2pkh_lock_for
 
-        # Build an ARC broadcaster using server config when available.
+        # Build an ARC protocol instance using server config when available.
         # @api private
         def self.build_arc(net_sym, server_context)
           testnet = net_sym == :testnet
           opts = {}
           opts[:api_key] = server_context[:arc_api_key] if server_context.is_a?(Hash) && server_context[:arc_api_key]
-          BSV::Network::ARC.default(testnet: testnet, **opts)
+          provider = BSV::Network::Providers::GorillaPool.default(testnet: testnet, **opts)
+          provider.protocol_for(:broadcast)
         end
         private_class_method :build_arc
       end

data/lib/bsv/mcp/tools/check_balance.rb

@@ -59,8 +59,22 @@ module BSV
           net_sym = Helpers.resolve_network_sym(network, server_context)
           address = resolve_address(address_or_wif, net_sym)
 
-          woc = BSV::Network::WhatsOnChain.new(network: net_sym)
-          utxos = woc.fetch_utxos(address)
+          provider = BSV::Network::Providers::WhatsOnChain.default(network: net_sym)
+          utxo_result = provider.call(:get_utxos_all, address)
+
+          unless utxo_result.success?
+            code = utxo_result.metadata[:status_code]
+            msg = utxo_result.message
+            msg = "#{msg} (HTTP #{code})" if code
+            return Helpers.error_response(msg)
+          end
+
+          utxos = utxo_result.data.map do |entry|
+            BSV::Network::UTXO.new(
+              tx_hash: entry[:tx_hash], tx_pos: entry[:tx_pos],
+              satoshis: entry[:satoshis], height: entry[:height]
+            )
+          end
 
           balance = utxos.sum(&:satoshis)
           result = {
@@ -77,8 +91,6 @@ module BSV
           )
         rescue ArgumentError => e
           Helpers.error_response(e.message)
-        rescue BSV::Network::ChainProviderError => e
-          Helpers.error_response("#{e.message} (HTTP #{e.status_code})")
         end
 
         # Resolve a WIF key or address string to a P2PKH address.