bsv-sdk 0.7.0 → 0.8.0

data/lib/bsv/wallet_interface/key_deriver.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-module BSV
-  module Wallet
-    # BRC-42/43 key derivation for the wallet interface.
-    #
-    # Derives child keys from a root private key using BKDS (BSV Key Derivation
-    # Scheme). Supports protocol IDs, key IDs, counterparties, and security
-    # levels as defined in BRC-43.
-    class KeyDeriver
-      ANYONE_BN = OpenSSL::BN.new(1)
-
-      attr_reader :root_key
-
-      # @param root_key [BSV::Primitives::PrivateKey, String] a private key or 'anyone'
-      def initialize(root_key)
-        @root_key = if root_key == 'anyone'
-                      BSV::Primitives::PrivateKey.new(ANYONE_BN)
-                    elsif root_key.is_a?(BSV::Primitives::PrivateKey)
-                      root_key
-                    else
-                      raise ArgumentError, "expected a BSV::Primitives::PrivateKey or 'anyone', got #{root_key.class}"
-                    end
-      end
-
-      # Returns the identity public key as a hex string.
-      # @return [String] 66-character compressed public key hex
-      def identity_key
-        @root_key.public_key.to_hex
-      end
-
-      # Derives a public key using BRC-42 key derivation.
-      #
-      # @param protocol_id [Array] [security_level, protocol_name]
-      # @param key_id [String] key identifier
-      # @param counterparty [String] public key hex, 'self', or 'anyone'
-      # @param for_self [Boolean] derive from own identity rather than counterparty's
-      # @return [BSV::Primitives::PublicKey]
-      def derive_public_key(protocol_id, key_id, counterparty, for_self: false)
-        Validators.validate_protocol_id!(protocol_id)
-        Validators.validate_key_id!(key_id)
-        invoice = compute_invoice_number(protocol_id, key_id)
-        counterparty_pub = resolve_counterparty(counterparty)
-
-        if for_self
-          @root_key.derive_child(counterparty_pub, invoice).public_key
-        else
-          counterparty_pub.derive_child(@root_key, invoice)
-        end
-      end
-
-      # Derives a private key using BRC-42 key derivation.
-      #
-      # @param protocol_id [Array] [security_level, protocol_name]
-      # @param key_id [String] key identifier
-      # @param counterparty [String] public key hex, 'self', or 'anyone'
-      # @return [BSV::Primitives::PrivateKey]
-      def derive_private_key(protocol_id, key_id, counterparty)
-        Validators.validate_protocol_id!(protocol_id)
-        Validators.validate_key_id!(key_id)
-        invoice = compute_invoice_number(protocol_id, key_id)
-        counterparty_pub = resolve_counterparty(counterparty)
-        @root_key.derive_child(counterparty_pub, invoice)
-      end
-
-      # Derives a symmetric key for encryption/HMAC operations.
-      #
-      # Uses ECDH between the derived private and public child keys to
-      # produce a shared secret, then uses the X-coordinate as the key.
-      #
-      # @param protocol_id [Array] [security_level, protocol_name]
-      # @param key_id [String] key identifier
-      # @param counterparty [String] public key hex, 'self', or 'anyone'
-      # @return [BSV::Primitives::SymmetricKey]
-      def derive_symmetric_key(protocol_id, key_id, counterparty)
-        Validators.validate_protocol_id!(protocol_id)
-        Validators.validate_key_id!(key_id)
-        invoice = compute_invoice_number(protocol_id, key_id)
-        counterparty_pub = resolve_counterparty(counterparty)
-
-        derived_private = @root_key.derive_child(counterparty_pub, invoice)
-        derived_public = counterparty_pub.derive_child(@root_key, invoice)
-
-        BSV::Primitives::SymmetricKey.from_ecdh(derived_private, derived_public)
-      end
-
-      # Reveals the ECDH shared secret between this wallet and a counterparty.
-      # Used for BRC-69 Method 1 (counterparty key linkage).
-      #
-      # @param counterparty [String] public key hex (not 'self')
-      # @return [String] compressed shared secret bytes
-      def reveal_counterparty_secret(counterparty)
-        raise InvalidParameterError.new('counterparty', 'not "self" for key linkage revelation') if counterparty == 'self'
-
-        counterparty_pub = resolve_counterparty(counterparty)
-        @root_key.derive_shared_secret(counterparty_pub).compressed
-      end
-
-      # Reveals the specific key offset for a particular derived key.
-      # Used for BRC-69 Method 2 (specific key linkage).
-      #
-      # @param counterparty [String] public key hex
-      # @param protocol_id [Array] [security_level, protocol_name]
-      # @param key_id [String] key identifier
-      # @return [String] HMAC-SHA256 bytes (the key offset)
-      def reveal_specific_secret(counterparty, protocol_id, key_id)
-        Validators.validate_protocol_id!(protocol_id)
-        Validators.validate_key_id!(key_id)
-        counterparty_pub = resolve_counterparty(counterparty)
-        shared = @root_key.derive_shared_secret(counterparty_pub)
-        invoice = compute_invoice_number(protocol_id, key_id)
-        BSV::Primitives::Digest.hmac_sha256(shared.compressed, invoice.encode('UTF-8'))
-      end
-
-      private
-
-      # Resolves a counterparty identifier to a PublicKey.
-      #
-      # @param counterparty [String] 'self', 'anyone', or a hex public key
-      # @return [BSV::Primitives::PublicKey]
-      def resolve_counterparty(counterparty)
-        case counterparty
-        when 'self'
-          @root_key.public_key
-        when 'anyone'
-          BSV::Primitives::PrivateKey.new(ANYONE_BN).public_key
-        else
-          Validators.validate_counterparty!(counterparty)
-          BSV::Primitives::PublicKey.from_hex(counterparty)
-        end
-      end
-
-      # Computes the invoice number from a protocol ID and key ID.
-      # Format: "#{security_level}-#{protocol_name}-#{key_id}"
-      #
-      # @param protocol_id [Array] [security_level, protocol_name]
-      # @param key_id [String]
-      # @return [String]
-      def compute_invoice_number(protocol_id, key_id)
-        "#{protocol_id[0]}-#{protocol_id[1]}-#{key_id}"
-      end
-    end
-  end
-end

data/lib/bsv/wallet_interface/local_proof_store.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module BSV
-  module Wallet
-    # Default proof store — persists serialised merkle proofs via a
-    # {StorageAdapter}. Requires no external services.
-    #
-    # @example Using the default local proof store
-    #   store   = BSV::Wallet::MemoryStore.new
-    #   proofs  = BSV::Wallet::LocalProofStore.new(store)
-    #   proofs.store_proof(txid_hex, merkle_path)
-    #   proof   = proofs.resolve_proof(txid_hex)
-    class LocalProofStore
-      include ProofStore
-
-      # @param storage [StorageAdapter] the underlying persistence adapter
-      def initialize(storage)
-        @storage = storage
-      end
-
-      # Serialise and store a merkle proof.
-      #
-      # @param txid [String] hex transaction ID
-      # @param merkle_path [BSV::Transaction::MerklePath] the proof to store
-      # @return [void]
-      def store_proof(txid, merkle_path)
-        @storage.store_proof(txid, merkle_path.to_hex)
-      end
-
-      # Resolve and deserialise a merkle proof.
-      #
-      # @param txid [String] hex transaction ID
-      # @return [BSV::Transaction::MerklePath, nil] the proof, or nil if unknown
-      def resolve_proof(txid)
-        bump_hex = @storage.find_proof(txid)
-        return unless bump_hex
-
-        BSV::Transaction::MerklePath.from_hex(bump_hex)
-      end
-    end
-  end
-end

data/lib/bsv/wallet_interface/memory_store.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-module BSV
-  module Wallet
-    # In-memory storage adapter for testing.
-    #
-    # Stores actions, outputs, and certificates in plain Ruby arrays.
-    # Not thread-safe; intended for test use only.
-    class MemoryStore
-      include StorageAdapter
-
-      def initialize
-        @actions = []
-        @outputs = []
-        @certificates = []
-        @proofs = {}
-        @transactions = {}
-      end
-
-      def store_action(action_data)
-        @actions << action_data
-        action_data
-      end
-
-      def find_actions(query)
-        apply_pagination(filter_actions(query), query)
-      end
-
-      def count_actions(query)
-        filter_actions(query).length
-      end
-
-      def store_output(output_data)
-        @outputs << output_data
-        output_data
-      end
-
-      def find_outputs(query)
-        apply_pagination(filter_outputs(query), query)
-      end
-
-      def count_outputs(query)
-        filter_outputs(query).length
-      end
-
-      def delete_output(outpoint)
-        idx = @outputs.index { |o| o[:outpoint] == outpoint }
-        return false unless idx
-
-        @outputs.delete_at(idx)
-        true
-      end
-
-      def store_certificate(cert_data)
-        @certificates << cert_data
-        cert_data
-      end
-
-      def find_certificates(query)
-        apply_pagination(filter_certificates(query), query)
-      end
-
-      def count_certificates(query)
-        filter_certificates(query).length
-      end
-
-      def store_proof(txid, bump_hex)
-        @proofs[txid] = bump_hex
-      end
-
-      def find_proof(txid)
-        @proofs[txid]
-      end
-
-      def store_transaction(txid, tx_hex)
-        @transactions[txid] = tx_hex
-      end
-
-      def find_transaction(txid)
-        @transactions[txid]
-      end
-
-      def delete_certificate(type:, serial_number:, certifier:)
-        idx = @certificates.index do |c|
-          c[:type] == type && c[:serial_number] == serial_number && c[:certifier] == certifier
-        end
-        return false unless idx
-
-        @certificates.delete_at(idx)
-        true
-      end
-
-      private
-
-      def filter_actions(query)
-        results = @actions
-        return results unless query[:labels]
-
-        mode = query[:label_query_mode] || 'any'
-        results.select do |a|
-          action_labels = a[:labels] || []
-          if mode == 'all'
-            (query[:labels] - action_labels).empty?
-          else
-            (query[:labels] & action_labels).any?
-          end
-        end
-      end
-
-      def filter_outputs(query)
-        results = @outputs
-        results = results.select { |o| o[:outpoint] == query[:outpoint] } if query[:outpoint]
-        results = results.select { |o| o[:basket] == query[:basket] } if query[:basket]
-        if query[:tags]
-          mode = query[:tag_query_mode] || 'any'
-          results = results.select do |o|
-            output_tags = o[:tags] || []
-            if mode == 'all'
-              (query[:tags] - output_tags).empty?
-            else
-              (query[:tags] & output_tags).any?
-            end
-          end
-        end
-        query[:include_spent] ? results : results.reject { |o| o[:spendable] == false }
-      end
-
-      def filter_certificates(query)
-        results = @certificates
-        results = results.select { |c| query[:certifiers].include?(c[:certifier]) } if query[:certifiers]
-        results = results.select { |c| query[:types].include?(c[:type]) } if query[:types]
-        results = results.select { |c| c[:subject] == query[:subject] } if query[:subject]
-        if query[:attributes]
-          results = results.select do |c|
-            fields = c[:fields] || {}
-            query[:attributes].all? { |k, v| fields[k] == v || fields[k.to_sym] == v }
-          end
-        end
-        results
-      end
-
-      def apply_pagination(results, query)
-        offset = query[:offset] || 0
-        limit = query[:limit] || 10
-        results[offset, limit] || []
-      end
-    end
-  end
-end

data/lib/bsv/wallet_interface/null_chain_provider.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module BSV
-  module Wallet
-    # Default chain provider that raises for all blockchain queries.
-    #
-    # Used when a WalletClient is constructed without a chain provider,
-    # allowing the wallet to function for transaction and crypto operations
-    # without requiring a blockchain connection.
-    class NullChainProvider
-      include ChainProvider
-
-      def get_height
-        raise UnsupportedActionError, 'get_height (no chain provider configured)'
-      end
-
-      def get_header(_height)
-        raise UnsupportedActionError, 'get_header_for_height (no chain provider configured)'
-      end
-    end
-  end
-end

data/lib/bsv/wallet_interface/proof_store.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module BSV
-  module Wallet
-    # Duck-typed interface for merkle proof persistence.
-    #
-    # Include this module in proof store implementations and override all
-    # methods. The default implementations raise NotImplementedError.
-    #
-    # Two implementations ship with the SDK:
-    # - {LocalProofStore} — persists proofs via a {StorageAdapter} (default)
-    # - Future: ChaintracksProofStore — resolves proofs from an external service
-    module ProofStore
-      # Store a merkle proof for a transaction.
-      #
-      # @param _txid [String] hex transaction ID
-      # @param _merkle_path [BSV::Transaction::MerklePath] the proof to store
-      # @return [void]
-      def store_proof(_txid, _merkle_path)
-        raise NotImplementedError, "#{self.class}#store_proof not implemented"
-      end
-
-      # Resolve a merkle proof for a transaction.
-      #
-      # @param _txid [String] hex transaction ID
-      # @return [BSV::Transaction::MerklePath, nil] the proof, or nil if unknown
-      def resolve_proof(_txid)
-        raise NotImplementedError, "#{self.class}#resolve_proof not implemented"
-      end
-    end
-  end
-end