bsv-wallet-postgres 0.5.0 → 0.100.0

data/lib/bsv/wallet/postgres/broadcast_queue.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      # Broadcast lifecycle manager backed by the broadcasts table.
+      #
+      # Owns network communication for transaction broadcasts. Uses
+      # Services for push/fetch operations and delegates column updates
+      # to Broadcast#write!.
+      class BroadcastQueue
+        include BSV::Wallet::Interface::BroadcastQueue
+
+        def initialize(db: nil, services: nil)
+          @db = db || BSV::Wallet::Postgres.db
+          @services = services
+        end
+
+        def submit(action_id:, raw_tx:, immediate: false)
+          BSV.logger&.debug { "[BroadcastQueue] submit: action_id=#{action_id} immediate=#{immediate}" }
+          broadcast = Broadcast.create(action_id: action_id)
+
+          if immediate && @services
+            @services.push!(broadcast)
+          end
+
+          broadcast_to_hash(broadcast.reload)
+        end
+
+        def process_pending(limit: 100)
+          stale = Broadcast
+            .where { broadcast_at < Time.now - Broadcast::FETCH_STALENESS }
+            .where(Sequel.|({ tx_status: nil }, Sequel.~(tx_status: Broadcast::TERMINAL_STATUSES)))
+            .limit(limit)
+            .all
+
+          stale.filter_map do |broadcast|
+            next unless broadcast.action&.wtxid && @services
+
+            result = @services.fetch!(broadcast)
+            next unless result.http_success?
+
+            broadcast_to_hash(broadcast.reload)
+          end
+        end
+
+        def handle_event(event)
+          BSV::Primitives::Hex.validate_wtxid!(event[:wtxid], name: 'handle_event wtxid')
+          BSV.logger&.debug { "[BroadcastQueue] handle_event: dtxid=#{event[:wtxid].reverse.unpack1('H*')} status=#{event[:tx_status]}" }
+          action = Action.first(wtxid: Sequel.blob(event[:wtxid]))
+          return unless action
+
+          broadcast = Broadcast.first(action_id: action.id)
+          broadcast ||= Broadcast.create(action_id: action.id)
+
+          broadcast.update(
+            tx_status:     event[:tx_status],
+            arc_status:    event[:status],
+            block_hash:    event[:block_hash] ? Sequel.blob(event[:block_hash]) : nil,
+            block_height:  event[:block_height],
+            merkle_path:   event[:merkle_path] ? Sequel.blob(event[:merkle_path]) : nil,
+            extra_info:    event[:extra_info],
+            competing_txs: event[:competing_txs] ? Sequel.pg_array(event[:competing_txs]) : nil
+          )
+
+          {
+            action_id:    action.id,
+            tx_status:    broadcast.tx_status,
+            block_hash:   broadcast.block_hash,
+            block_height: broadcast.block_height,
+            merkle_path:  broadcast.merkle_path
+          }
+        end
+
+        def status(action_id:)
+          broadcast = Broadcast.first(action_id: action_id)
+          return unless broadcast
+
+          broadcast_to_hash(broadcast)
+        end
+
+        private
+
+        def broadcast_to_hash(record)
+          {
+            action_id:    record.action_id,
+            tx_status:    record.tx_status,
+            arc_status:   record.arc_status,
+            broadcast_at: record.broadcast_at,
+            block_hash:   record.block_hash,
+            block_height: record.block_height,
+            merkle_path:  record.merkle_path
+          }
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/certificate.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      class Certificate < Sequel::Model
+        plugin :timestamps, update_on_create: true
+
+        one_to_many :certificate_fields, class: 'BSV::Wallet::Postgres::CertificateField'
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/certificate_field.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      class CertificateField < Sequel::Model
+        plugin :timestamps, update_on_create: true
+
+        many_to_one :certificate, class: 'BSV::Wallet::Postgres::Certificate'
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/display_txid.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      # Convenience method for models with a wtxid column.
+      # Converts wire-order binary wtxid to display-order hex — the
+      # human-readable format used by block explorers and external APIs.
+      #
+      # Include on any Sequel::Model whose table has a wtxid bytea column.
+      module DisplayTxid
+        # Display-order hex transaction ID (reversed from wire-order wtxid).
+        #
+        # @return [String, nil] 64-character hex string, or nil if wtxid is nil
+        def dtxid
+          return unless wtxid
+
+          BSV::Primitives::Hex.validate_wtxid!(wtxid, name: "#{self.class.name}#dtxid")
+          wtxid.reverse.unpack1('H*')
+        end
+        alias dtxid_hex dtxid
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/input.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      class Input < Sequel::Model
+        plugin :timestamps, update_on_create: true
+
+        many_to_one :action, class: 'BSV::Wallet::Postgres::Action'
+        many_to_one :output, class: 'BSV::Wallet::Postgres::Output'
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/label.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      class Label < Sequel::Model
+        plugin :timestamps, update_on_create: true
+
+        many_to_many :actions, class: 'BSV::Wallet::Postgres::Action',
+                               join_table: :action_labels,
+                               left_key: :label_id, right_key: :action_id
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/output.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      class Output < Sequel::Model
+        # No timestamps plugin — outputs are immutable.
+        # created_at is set by the database default.
+
+        many_to_one  :action, class: 'BSV::Wallet::Postgres::Action'
+        one_to_one   :spendable_entry, class: 'BSV::Wallet::Postgres::Spendable', key: :output_id
+        one_to_one   :detail, class: 'BSV::Wallet::Postgres::OutputDetail', key: :output_id
+        one_to_one   :input, class: 'BSV::Wallet::Postgres::Input', key: :output_id
+        one_to_one   :output_basket, class: 'BSV::Wallet::Postgres::OutputBasket', key: :output_id
+        many_to_many :tags, class: 'BSV::Wallet::Postgres::Tag',
+                            join_table: :output_tags,
+                            left_key: :output_id, right_key: :tag_id
+
+        dataset_module do
+          # The UTXO set: outputs in the spendable table and not claimed by any input.
+          def spendable
+            spendable_ds = BSV::Wallet::Postgres::Spendable.dataset
+              .where(output_id: Sequel[:outputs][:id]).select(1)
+            input_ds = BSV::Wallet::Postgres::Input.dataset
+              .where(output_id: Sequel[:outputs][:id]).select(1)
+
+            where(spendable_ds.exists).exclude(input_ds.exists)
+          end
+
+          # Filter outputs belonging to a named basket.
+          # 'default' is implicit — outputs with no output_baskets row.
+          def in_basket(name)
+            if name == 'default'
+              basket_ds = BSV::Wallet::Postgres::OutputBasket.dataset
+                .where(Sequel[:output_baskets][:output_id] => Sequel[:outputs][:id])
+                .select(1)
+              exclude(basket_ds.exists)
+            else
+              basket_ds = BSV::Wallet::Postgres::OutputBasket.dataset
+                .join(:baskets, id: :basket_id)
+                .where(Sequel[:output_baskets][:output_id] => Sequel[:outputs][:id])
+                .where(Sequel[:baskets][:name] => name)
+                .select(1)
+              where(basket_ds.exists)
+            end
+          end
+
+          # Filter outputs with at least the given satoshi value.
+          def min_satoshis(value)
+            where { satoshis >= value }
+          end
+        end
+
+        def spendable?
+          !spendable_entry.nil? && input.nil?
+        end
+
+        def basket
+          output_basket&.basket
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/output_basket.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      class OutputBasket < Sequel::Model
+        plugin :timestamps, update_on_create: true
+
+        many_to_one :output, class: 'BSV::Wallet::Postgres::Output'
+        many_to_one :basket, class: 'BSV::Wallet::Postgres::Basket'
+        many_to_one :action, class: 'BSV::Wallet::Postgres::Action'
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/output_detail.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      class OutputDetail < Sequel::Model
+        many_to_one :output, class: 'BSV::Wallet::Postgres::Output'
+        many_to_one :action, class: 'BSV::Wallet::Postgres::Action'
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/output_tag.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      class OutputTag < Sequel::Model
+        plugin :timestamps, update_on_create: true
+
+        many_to_one :output, class: 'BSV::Wallet::Postgres::Output'
+        many_to_one :tag, class: 'BSV::Wallet::Postgres::Tag'
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/proof_store.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      # Merkle proof manager backed by tx_proofs table.
+      class ProofStore
+        include BSV::Wallet::Interface::ProofStore
+
+        def initialize(db: nil)
+          @db = db || BSV::Wallet::Postgres.db
+        end
+
+        def save_proof(wtxid:, proof:)
+          BSV::Primitives::Hex.validate_wtxid!(wtxid, name: 'save_proof wtxid')
+          BSV.logger&.debug { "[ProofStore] save_proof: dtxid=#{wtxid.reverse.unpack1('H*')} height=#{proof[:height]}" }
+
+          block_id = find_or_create_block(proof) if proof[:height]
+
+          existing = TxProof.first(wtxid: Sequel.blob(wtxid))
+          cols = proof_columns(proof).merge(block_id ? { block_id: block_id } : {})
+          if existing
+            existing.update(cols)
+            existing.id
+          else
+            TxProof.create({ wtxid: wtxid }.merge(cols)).id
+          end
+        end
+
+        def find_proof(wtxid:)
+          BSV::Primitives::Hex.validate_wtxid!(wtxid, name: 'find_proof wtxid')
+          record = TxProof.first(wtxid: Sequel.blob(wtxid))
+          return unless record
+
+          proof_to_hash(record)
+        end
+
+        def proof_exists?(wtxid:)
+          BSV::Primitives::Hex.validate_wtxid!(wtxid, name: 'proof_exists? wtxid')
+          TxProof.where(wtxid: Sequel.blob(wtxid)).any?
+        end
+
+        private
+
+        def proof_columns(proof)
+          cols = {}
+          cols[:block_index] = proof[:block_index] if proof.key?(:block_index)
+          cols[:merkle_path] = proof[:merkle_path] ? Sequel.blob(proof[:merkle_path]) : nil if proof.key?(:merkle_path)
+          cols[:raw_tx]      = proof[:raw_tx]      ? Sequel.blob(proof[:raw_tx]) : nil      if proof.key?(:raw_tx)
+          cols
+        end
+
+        def proof_to_hash(record)
+          block = record.block
+          {
+            id:           record.id,
+            wtxid:        record.wtxid,
+            block_id:     record.block_id,
+            height:       block&.height,
+            block_index:  record.block_index,
+            merkle_path:  record.merkle_path,
+            raw_tx:       record.raw_tx,
+            block_hash:   block&.block_hash,
+            merkle_root:  block&.merkle_root
+          }
+        end
+
+        # Returns block ID if a block can be found or created, nil otherwise.
+        # Derives merkle_root from merkle_path when not provided explicitly.
+        # Returns nil only when neither merkle_root nor merkle_path is available.
+        def find_or_create_block(proof)
+          height = proof[:height]
+          return unless height
+
+          existing = Block.first(height: height)
+          return existing.id if existing
+
+          merkle_root = proof[:merkle_root] || derive_merkle_root(proof[:merkle_path])
+          return unless merkle_root
+
+          Block.create(
+            height:      height,
+            merkle_root: merkle_root,
+            block_hash:  proof[:block_hash]
+          ).id
+        rescue Sequel::UniqueConstraintViolation
+          Block.first!(height: height).id
+        end
+
+        def derive_merkle_root(merkle_path_binary)
+          return unless merkle_path_binary
+
+          paths = BSV::Transaction::MerklePath.from_binary(merkle_path_binary)
+          mp = paths.is_a?(Array) ? paths.first : paths
+          mp&.compute_root
+        rescue StandardError
+          nil
+        end
+
+        def decode_hex(hex)
+          return unless hex
+          return hex if hex.encoding == Encoding::BINARY
+
+          [hex].pack('H*')
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/setting.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      class Setting < Sequel::Model
+        plugin :timestamps, update_on_create: true
+
+        # Retrieve a setting value by key.
+        #
+        # @param key [String]
+        # @return [String, nil]
+        def self.get(key)
+          first(key: key)&.value
+        end
+
+        # Set a setting value (upsert).
+        #
+        # @param key [String]
+        # @param value [String]
+        def self.set(key, value)
+          record = first(key: key)
+          if record
+            record.update(value: value)
+          else
+            create(key: key, value: value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/postgres/spendable.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Postgres
+      class Spendable < Sequel::Model(:spendable)
+        many_to_one :output, class: 'BSV::Wallet::Postgres::Output'
+        many_to_one :action, class: 'BSV::Wallet::Postgres::Action'
+      end
+    end
+  end
+end