bsv-wallet 0.3.4 → 0.5.0

data/lib/bsv/wallet_interface/fee_estimator.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    # Estimates transaction fees before a {BSV::Transaction::Transaction} object exists.
+    #
+    # Wraps {BSV::Transaction::FeeModels::SatoshisPerKilobyte} to provide pre-construction
+    # fee estimation given only input and output counts. Once a real {Transaction} is
+    # available, delegates directly to the underlying SDK fee model via {#estimate_for_tx}.
+    #
+    # The default rate is 1 sat/kB — the current BSV network standard. The SDK's own
+    # {SatoshisPerKilobyte} defaults to 100 sat/kB; this class intentionally differs.
+    #
+    # @example Pre-construction estimate
+    #   estimator = BSV::Wallet::FeeEstimator.new
+    #   fee = estimator.estimate(p2pkh_inputs: 2, p2pkh_outputs: 3)
+    #   # => 1 (at 1 sat/kB, ceil(408/1000 * 1) = 1)
+    #
+    # @example Custom rate
+    #   estimator = BSV::Wallet::FeeEstimator.new(sats_per_kb: 50)
+    #   fee = estimator.estimate(p2pkh_inputs: 1, p2pkh_outputs: 1)
+    #   # => 10 (ceil(192/1000 * 50) = 10)
+    class FeeEstimator
+      # Estimated size in bytes of an unsigned P2PKH input.
+      # Matches {BSV::Transaction::Transaction::UNSIGNED_P2PKH_INPUT_SIZE}.
+      P2PKH_INPUT_SIZE = BSV::Transaction::Transaction::UNSIGNED_P2PKH_INPUT_SIZE
+
+      # Estimated size in bytes of a P2PKH output (8 satoshis + varint(25) + 25-byte script).
+      P2PKH_OUTPUT_SIZE = 34
+
+      # Fixed overhead in bytes for version (4) and lock_time (4).
+      FIXED_OVERHEAD = 8
+
+      # Approximate overhead including typical 1-byte varints for input/output
+      # counts. Retained for backward compatibility with code that referenced
+      # +FeeModel::OVERHEAD+.
+      OVERHEAD = 10
+
+      # @return [Integer] the satoshis-per-kilobyte rate used for estimation
+      attr_reader :sats_per_kb
+
+      # @param sats_per_kb [Integer] fee rate in satoshis per kilobyte (default: 1)
+      # @raise [ArgumentError] if sats_per_kb is zero or negative
+      def initialize(sats_per_kb: 1)
+        raise ArgumentError, 'sats_per_kb must be greater than zero' unless sats_per_kb.positive?
+
+        @sats_per_kb = sats_per_kb
+        @sdk_model = BSV::Transaction::FeeModels::SatoshisPerKilobyte.new(value: sats_per_kb)
+      end
+
+      # Estimate the fee for a transaction described by input and output counts.
+      #
+      # Computes the serialised byte size using standard P2PKH sizes and correct
+      # Bitcoin varint encoding for the input/output count fields, then applies
+      # the configured sat/kB rate. Returns at least 1 satoshi.
+      #
+      # @param p2pkh_inputs [Integer] number of P2PKH inputs
+      # @param p2pkh_outputs [Integer] number of P2PKH outputs
+      # @param extra_bytes [Integer] additional bytes to include (e.g. OP_RETURN data)
+      # @return [Integer] estimated fee in satoshis (minimum 1)
+      def estimate(p2pkh_inputs:, p2pkh_outputs:, extra_bytes: 0)
+        total_bytes = byte_size(p2pkh_inputs, p2pkh_outputs) + extra_bytes
+        fee = (total_bytes / 1000.0 * @sats_per_kb).ceil
+        [1, fee].max
+      end
+
+      # Compute the fee for a fully-constructed transaction.
+      #
+      # Delegates to the underlying {BSV::Transaction::FeeModels::SatoshisPerKilobyte}
+      # model, which uses {BSV::Transaction::Transaction#estimated_size} internally.
+      #
+      # @param tx [BSV::Transaction::Transaction] the transaction to compute the fee for
+      # @return [Integer] fee in satoshis
+      def estimate_for_tx(tx)
+        @sdk_model.compute_fee(tx)
+      end
+
+      # Alias for {#estimate_for_tx} — matches the SDK's +compute_fee+ naming.
+      alias compute estimate_for_tx
+
+      # Minimum viable change output value at the configured rate.
+      #
+      # An output is economically viable only if its value exceeds twice the cost of
+      # spending it. The cost to spend a single P2PKH input is estimated as the fee
+      # for a minimal 1-input / 1-output transaction.
+      #
+      # @return [Integer] minimum satoshis for a change output to be worth creating
+      def dust_floor
+        cost = (spend_one_p2pkh_bytes / 1000.0 * @sats_per_kb).ceil
+        [1, cost * 2].max
+      end
+
+      private
+
+      # Total byte size for a transaction with the given input/output counts.
+      def byte_size(input_count, output_count)
+        FIXED_OVERHEAD +
+          varint_size(input_count) +
+          (input_count * P2PKH_INPUT_SIZE) +
+          varint_size(output_count) +
+          (output_count * P2PKH_OUTPUT_SIZE)
+      end
+
+      # Byte size of a minimal single-input, single-output transaction.
+      # Used to compute the cost of spending one P2PKH UTXO.
+      def spend_one_p2pkh_bytes
+        byte_size(1, 1)
+      end
+
+      # Number of bytes required to encode +n+ as a Bitcoin varint.
+      def varint_size(n)
+        if n < 0xFD
+          1
+        elsif n <= 0xFFFF
+          3
+        elsif n <= 0xFFFF_FFFF
+          5
+        else
+          9
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet_interface/fee_model.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'fee_estimator'
+
+module BSV
+  module Wallet
+    # Backward-compatible alias for {FeeEstimator}.
+    #
+    # All fee estimation is consolidated in {FeeEstimator}, which provides
+    # both pre-construction estimation (+estimate+) and post-construction
+    # delegation (+compute+ / +estimate_for_tx+). This alias ensures
+    # existing code referencing +FeeModel+ continues to work.
+    #
+    # @example
+    #   model = BSV::Wallet::FeeModel.new(sats_per_kb: 50)
+    #   model.estimate(p2pkh_inputs: 2, p2pkh_outputs: 3)
+    #   model.compute(transaction)
+    #   model.dust_floor
+    FeeModel = FeeEstimator
+  end
+end

data/lib/bsv/wallet_interface/file_store.rb

@@ -60,6 +60,18 @@ module BSV
         result
       end
 
+      def update_output_state(outpoint, new_state, pending_reference: nil, no_send: nil)
+        result = super
+        save_outputs
+        result
+      end
+
+      def lock_utxos(outpoints, reference:, no_send: false)
+        locked = super
+        save_outputs unless locked.empty?
+        locked
+      end
+
       def store_certificate(cert_data)
         result = super
         save_certificates
@@ -82,6 +94,11 @@ module BSV
         save_transactions
       end
 
+      def store_setting(key, value)
+        super
+        save_settings
+      end
+
       private
 
       def proofs_path
@@ -99,7 +116,7 @@ module BSV
                        'Other users may be able to access wallet data.')
         end
 
-        [actions_path, outputs_path, certificates_path, proofs_path, transactions_path].each do |path|
+        [actions_path, outputs_path, certificates_path, proofs_path, transactions_path, settings_path].each do |path|
           next unless File.exist?(path)
 
           file_mode = File.stat(path).mode & 0o777
@@ -114,6 +131,10 @@ module BSV
         File.join(@dir, 'actions.json')
       end
 
+      def settings_path
+        File.join(@dir, 'settings.json')
+      end
+
       def outputs_path
         File.join(@dir, 'outputs.json')
       end
@@ -128,6 +149,7 @@ module BSV
         @certificates = load_file(certificates_path)
         @proofs = load_proofs_file
         @transactions = load_transactions_file
+        @settings = load_settings_file
       end
 
       def load_file(path)
@@ -186,6 +208,22 @@ module BSV
         {}
       end
 
+      def save_settings
+        json = JSON.pretty_generate(stringify_keys_deep(@settings))
+        tmp = "#{settings_path}.tmp"
+        File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o600) { |f| f.write(json) }
+        File.rename(tmp, settings_path)
+      end
+
+      def load_settings_file
+        return {} unless File.exist?(settings_path)
+
+        data = JSON.parse(File.read(settings_path))
+        data.is_a?(Hash) ? data : {}
+      rescue JSON::ParserError
+        {}
+      end
+
       def write_file(path, data)
         json = JSON.pretty_generate(stringify_keys_deep(data))
         tmp = "#{path}.tmp"

data/lib/bsv/wallet_interface/memory_store.rb

@@ -2,10 +2,16 @@
 
 module BSV
   module Wallet
-    # In-memory storage adapter for testing.
+    # In-memory storage adapter for testing and single-process use.
     #
     # Stores actions, outputs, and certificates in plain Ruby arrays.
-    # Not thread-safe; intended for test use only.
+    #
+    # Thread safety: a +Mutex+ serialises all state-mutating operations so that
+    # concurrent threads cannot select and mark the same UTXO as pending.
+    # This makes MemoryStore safe within a single Ruby process.
+    #
+    # NOTE: FileStore is NOT process-safe — concurrent processes share no
+    # in-memory lock and may read stale state from disk.
     class MemoryStore
       include StorageAdapter
 
@@ -15,6 +21,8 @@ module BSV
         @certificates = []
         @proofs = {}
         @transactions = {}
+        @settings = {}
+        @mutex = Mutex.new
       end
 
       def store_action(action_data)
@@ -51,6 +59,129 @@ module BSV
         true
       end
 
+      # Transitions the state of an existing output.
+      #
+      # When +new_state+ is +:pending+, a +:pending_since+ (ISO 8601 UTC) and
+      # +:pending_reference+ are attached to the output so stale locks can be
+      # detected via {#release_stale_pending!}.
+      #
+      # Pass +no_send: true+ to mark the lock as belonging to a +no_send+
+      # transaction; these locks are exempt from automatic stale recovery and
+      # must be released explicitly via +abort_action+.
+      #
+      # When transitioning away from +:pending+, all pending metadata is cleared.
+      #
+      # This method is wrapped in a mutex to prevent concurrent transitions on
+      # the same output from two threads.
+      #
+      # @param outpoint [String] the outpoint identifier
+      # @param new_state [Symbol] +:spendable+, +:pending+, or +:spent+
+      # @param pending_reference [String, nil] caller-supplied label for the lock
+      # @param no_send [Boolean, nil] true if the lock is for a no_send transaction
+      # @raise [BSV::Wallet::WalletError] if the outpoint is not found
+      def update_output_state(outpoint, new_state, pending_reference: nil, no_send: nil)
+        @mutex.synchronize do
+          output = @outputs.find { |o| o[:outpoint] == outpoint }
+          raise WalletError, "Output not found: #{outpoint}" unless output
+
+          output[:state] = new_state
+
+          if new_state == :pending
+            output[:pending_since]     = Time.now.utc.iso8601
+            output[:pending_reference] = pending_reference
+            no_send ? output[:no_send] = true : output.delete(:no_send)
+          else
+            output.delete(:pending_since)
+            output.delete(:pending_reference)
+            output.delete(:no_send)
+          end
+
+          output
+        end
+      end
+
+      # Atomically locks the specified outpoints as +:pending+.
+      #
+      # Holds the mutex for the entire operation so no other thread can
+      # read or transition these outputs between the check and the lock.
+      #
+      # @param outpoints [Array<String>] outpoint identifiers to lock
+      # @param reference [String] caller-supplied pending reference
+      # @param no_send [Boolean] true if this is a no_send lock
+      # @return [Array<String>] outpoints successfully locked
+      def lock_utxos(outpoints, reference:, no_send: false)
+        now = Time.now.utc.iso8601
+        locked = []
+
+        @mutex.synchronize do
+          outpoints.each do |op|
+            output = @outputs.find { |o| o[:outpoint] == op }
+            next unless output && effective_state(output) == :spendable
+
+            output[:state] = :pending
+            output[:pending_since] = now
+            output[:pending_reference] = reference
+            no_send ? output[:no_send] = true : output.delete(:no_send)
+            locked << op
+          end
+        end
+
+        locked
+      end
+
+      # Returns only outputs whose effective state is +:spendable+.
+      #
+      # Legacy outputs that carry no +:state+ key are treated as spendable
+      # when +spendable:+ is not explicitly +false+.
+      #
+      # This method is wrapped in the same mutex as {#update_output_state} so
+      # that a thread cannot select a UTXO that another thread is simultaneously
+      # marking as pending.
+      #
+      # @param basket [String, nil] restrict to this basket when provided
+      # @param min_satoshis [Integer, nil] exclude outputs below this value
+      # @param sort_order [Symbol] +:asc+ or +:desc+ (default +:desc+, largest first)
+      # @return [Array<Hash>]
+      def find_spendable_outputs(basket: nil, min_satoshis: nil, sort_order: :desc)
+        @mutex.synchronize do
+          results = @outputs.select { |o| effective_state(o) == :spendable }
+          results = results.select { |o| o[:basket] == basket } if basket
+          results = results.select { |o| (o[:satoshis] || 0) >= min_satoshis } if min_satoshis
+          results.sort_by { |o| sort_order == :asc ? (o[:satoshis] || 0) : -(o[:satoshis] || 0) }
+        end
+      end
+
+      # Releases pending locks that have been held longer than +timeout+ seconds.
+      #
+      # Each output in +:pending+ state whose +:pending_since+ timestamp is older
+      # than +timeout+ seconds is reverted to +:spendable+ and its pending
+      # metadata is cleared.
+      #
+      # @param timeout [Integer] lock age in seconds before it is considered stale (default 300)
+      # @return [Integer] number of outputs released
+      def release_stale_pending!(timeout: 300)
+        cutoff = Time.now.utc - timeout
+        released = 0
+
+        @mutex.synchronize do
+          @outputs.each do |output|
+            next unless effective_state(output) == :pending
+            next if output[:no_send]
+            next unless output[:pending_since]
+
+            locked_at = Time.parse(output[:pending_since])
+            next unless locked_at < cutoff
+
+            output[:state] = :spendable
+            output.delete(:pending_since)
+            output.delete(:pending_reference)
+            released += 1
+          end
+        end
+
+        released
+      end
+
       def store_certificate(cert_data)
         @certificates << cert_data
         cert_data
@@ -90,6 +221,22 @@ module BSV
         true
       end
 
+      # Persists a named wallet setting.
+      #
+      # @param key [String] the setting name
+      # @param value [Object] the setting value (must be JSON-serialisable)
+      def store_setting(key, value)
+        @settings[key] = value
+      end
+
+      # Retrieves a named wallet setting.
+      #
+      # @param key [String] the setting name
+      # @return [Object, nil] the stored value, or nil if not found
+      def find_setting(key)
+        @settings[key]
+      end
+
       private
 
       def filter_actions(query)
@@ -122,7 +269,23 @@ module BSV
             end
           end
         end
-        query[:include_spent] ? results : results.reject { |o| o[:spendable] == false }
+        query[:include_spent] ? results : results.select { |o| effective_state(o) == :spendable }
+      end
+
+      # Resolves the effective state of an output from either the new +:state+
+      # field or the legacy +:spendable+ boolean, giving +:state+ precedence.
+      #
+      # The +:state+ value may be a Symbol or a String (the latter arises after
+      # a JSON round-trip in FileStore); both are normalised to a Symbol here.
+      #
+      # Legacy mapping:
+      #   - +spendable: false+           → +:spent+
+      #   - +spendable: true+ (or absent) → +:spendable+
+      def effective_state(output)
+        state = output[:state]
+        return state.to_sym if state
+
+        output[:spendable] == false ? :spent : :spendable
       end
 
       def filter_certificates(query)

data/lib/bsv/wallet_interface/null_chain_provider.rb

@@ -15,7 +15,15 @@ module BSV
       end
 
       def get_header(_height)
-        raise UnsupportedActionError, 'get_header_for_height (no chain provider configured)'
+        raise UnsupportedActionError, 'get_header (no chain provider configured)'
+      end
+
+      def get_utxos(_address)
+        raise UnsupportedActionError, 'get_utxos (no chain provider configured)'
+      end
+
+      def get_transaction(_txid)
+        raise UnsupportedActionError, 'get_transaction (no chain provider configured)'
       end
     end
   end

data/lib/bsv/wallet_interface/proto_wallet.rb

@@ -141,7 +141,7 @@ module BSV
       # @param originator [String, nil] FQDN of the originating application
       # @return [Hash] { signature: Array<Integer> } DER-encoded signature as byte array
       def create_signature(args, originator: nil)
-        counterparty = args[:counterparty] || 'self'
+        counterparty = args[:counterparty] || 'anyone'
         priv_key = @key_deriver.derive_private_key(args[:protocol_id], args[:key_id], counterparty)
 
         hash = if args[:hash_to_directly_sign]

data/lib/bsv/wallet_interface/storage_adapter.rb

@@ -66,6 +66,85 @@ module BSV
       def find_transaction(_txid)
         raise NotImplementedError, "#{self.class}#find_transaction not implemented"
       end
+
+      # Transitions the state of an existing output.
+      #
+      # When +new_state+ is +:pending+, pass a +pending_reference:+ string to
+      # associate the lock with a specific action. The adapter should record a
+      # timestamp (ISO 8601 UTC) alongside the reference so stale locks can be
+      # detected and released by {#release_stale_pending!}.
+      #
+      # When transitioning away from +:pending+, the adapter must clear any
+      # stored +:pending_since+ and +:pending_reference+ metadata.
+      #
+      # @param _outpoint [String] the outpoint identifier (e.g. "txid.vout")
+      # @param _new_state [Symbol] one of +:spendable+, +:pending+, +:spent+
+      # @param _pending_reference [String, nil] caller-supplied label for a pending lock
+      # @param _no_send [Boolean, nil] true if the lock belongs to a no_send transaction;
+      #   these locks are exempt from automatic stale recovery via {#release_stale_pending!}
+      # @raise [NotImplementedError]
+      def update_output_state(_outpoint, _new_state, pending_reference: nil, no_send: nil)
+        raise NotImplementedError, "#{self.class}#update_output_state not implemented"
+      end
+
+      # Atomically finds outputs by outpoint and marks them as +:pending+.
+      #
+      # This prevents TOCTOU races where two threads select the same UTXO
+      # between +find_spendable_outputs+ and +update_output_state+.
+      # Only outputs still in +:spendable+ state are locked; any that have
+      # already transitioned are skipped.
+      #
+      # @param outpoints [Array<String>] outpoint identifiers to lock
+      # @param reference [String] caller-supplied pending reference
+      # @param no_send [Boolean] true if this is a no_send lock
+      # @return [Array<String>] outpoints that were successfully locked
+      def lock_utxos(outpoints, reference:, no_send: false)
+        raise NotImplementedError, "#{self.class}#lock_utxos not implemented"
+      end
+
+      # Returns only outputs whose effective state is +:spendable+.
+      #
+      # @param basket [String, nil] restrict to this basket when provided
+      # @param min_satoshis [Integer, nil] exclude outputs below this value
+      # @param sort_order [Symbol] +:asc+ or +:desc+ (default +:desc+, largest first)
+      # @return [Array<Hash>]
+      # @raise [NotImplementedError]
+      def find_spendable_outputs(basket: nil, min_satoshis: nil, sort_order: :desc)
+        raise NotImplementedError, "#{self.class}#find_spendable_outputs not implemented"
+      end
+
+      # Releases pending locks that have been held longer than +timeout+ seconds.
+      #
+      # Each output in +:pending+ state whose +:pending_since+ timestamp is older
+      # than +timeout+ seconds is reverted to +:spendable+ and its pending
+      # metadata is cleared.
+      #
+      # This is a no-op for adapters that do not support pending metadata.
+      #
+      # @param timeout [Integer] lock age in seconds before it is considered stale
+      # @return [Integer] number of outputs released
+      # @raise [NotImplementedError]
+      def release_stale_pending!(timeout: 300)
+        raise NotImplementedError, "#{self.class}#release_stale_pending! not implemented"
+      end
+
+      # Persists a named wallet setting.
+      #
+      # @param _key [String] the setting name
+      # @param _value [Object] the setting value (must be JSON-serialisable)
+      # @raise [NotImplementedError]
+      def store_setting(_key, _value)
+        raise NotImplementedError, "#{self.class}#store_setting not implemented"
+      end
+
+      # Retrieves a named wallet setting.
+      #
+      # @param _key [String] the setting name
+      # @return [Object, nil] the stored value, or nil if not found
+      # @raise [NotImplementedError]
+      def find_setting(_key)
+        raise NotImplementedError, "#{self.class}#find_setting not implemented"
+      end
     end
   end
 end

data/lib/bsv/wallet_interface/validators.rb

@@ -3,6 +3,23 @@
 module BSV
   module Wallet
     module Validators
+      # Reserved protocol name prefixes (BRC-44 and BRC-98).
+      # Names beginning with any of these strings are disallowed.
+      RESERVED_PROTOCOL_PREFIXES = ['admin', 'p '].freeze
+
+      # Suffix that is disallowed on protocol names.
+      RESERVED_PROTOCOL_SUFFIX = ' protocol'
+
+      # Reserved basket name prefixes.
+      # Basket names beginning with any of these strings are disallowed.
+      RESERVED_BASKET_PREFIXES = ['admin', 'p '].freeze
+
+      # Suffix that is disallowed on basket names.
+      RESERVED_BASKET_SUFFIX = ' basket'
+
+      # Basket name that is globally reserved and cannot be used.
+      RESERVED_BASKET_NAME = 'default'
+
       module_function
 
       # BRC-100 protocol ID rules:
@@ -14,6 +31,10 @@ module BSV
       # - must not end with ' protocol'
       # - must not start with 'admin' (BRC-44)
       # - must not start with 'p ' (BRC-98 reserved)
+      #
+      # The name is normalised (stripped and downcased) before validation so
+      # that ' MyProtocol ' and 'myprotocol' are treated identically and do not
+      # silently fork to different key-derivation paths (F8.7).
       def validate_protocol_id!(protocol_id)
         unless protocol_id.is_a?(Array) && protocol_id.length == 2
           raise InvalidParameterError.new('protocol_id',
@@ -24,13 +45,19 @@ module BSV
         raise InvalidParameterError.new('protocol_id security level', '0, 1, or 2') unless [0, 1, 2].include?(level)
         raise InvalidParameterError.new('protocol_id name', 'a String') unless name.is_a?(String)
 
+        name = name.strip.downcase
+
         max_length = name.start_with?('specific linkage revelation') ? 430 : 400
         raise InvalidParameterError.new('protocol_id name', "between 5 and #{max_length} characters") if name.length < 5 || name.length > max_length
         raise InvalidParameterError.new('protocol_id name', 'lowercase letters, numbers, and spaces only') unless name.match?(/\A[a-z0-9 ]+\z/)
         raise InvalidParameterError.new('protocol_id name', 'free of consecutive spaces') if name.include?('  ')
-        raise InvalidParameterError.new('protocol_id name', 'not ending with " protocol"') if name.end_with?(' protocol')
-        raise InvalidParameterError.new('protocol_id name', 'not starting with "admin"') if name.start_with?('admin')
-        raise InvalidParameterError.new('protocol_id name', 'not starting with "p "') if name.start_with?('p ')
+        if name.end_with?(RESERVED_PROTOCOL_SUFFIX)
+          raise InvalidParameterError.new('protocol_id name', "not ending with \"#{RESERVED_PROTOCOL_SUFFIX}\"")
+        end
+
+        RESERVED_PROTOCOL_PREFIXES.each do |prefix|
+          raise InvalidParameterError.new('protocol_id name', "not starting with \"#{prefix}\"") if name.start_with?(prefix)
+        end
       end
 
       # Key ID: 1-800 bytes
@@ -67,10 +94,12 @@ module BSV
         raise InvalidParameterError.new('basket', 'between 5 and 300 characters') if basket.length < 5 || basket.length > 300
         raise InvalidParameterError.new('basket', 'lowercase letters, numbers, and spaces only') unless basket.match?(/\A[a-z0-9 ]+\z/)
         raise InvalidParameterError.new('basket', 'free of consecutive spaces') if basket.include?('  ')
-        raise InvalidParameterError.new('basket', 'not ending with " basket"') if basket.end_with?(' basket')
-        raise InvalidParameterError.new('basket', 'not starting with "admin"') if basket.start_with?('admin')
-        raise InvalidParameterError.new('basket', 'not equal to "default"') if basket == 'default'
-        raise InvalidParameterError.new('basket', 'not starting with "p "') if basket.start_with?('p ')
+        raise InvalidParameterError.new('basket', "not ending with \"#{RESERVED_BASKET_SUFFIX}\"") if basket.end_with?(RESERVED_BASKET_SUFFIX)
+
+        RESERVED_BASKET_PREFIXES.each do |prefix|
+          raise InvalidParameterError.new('basket', "not starting with \"#{prefix}\"") if basket.start_with?(prefix)
+        end
+        raise InvalidParameterError.new('basket', "not equal to \"#{RESERVED_BASKET_NAME}\"") if basket == RESERVED_BASKET_NAME
       end
 
       # Label: 1-300 characters

data/lib/bsv/wallet_interface/version.rb

@@ -2,6 +2,6 @@
 
 module BSV
   module WalletInterface
-    VERSION = '0.3.4'
+    VERSION = '0.5.0'
   end
 end