bsv-sdk 0.3.1 → 0.3.2

data/lib/bsv/script/script.rb

@@ -271,6 +271,36 @@ module BSV
         p2pkh_unlock(signature_der, pubkey_bytes)
       end
 
+      # Construct an OP_CAT locking script.
+      #
+      # The script concatenates two stack items and compares the result
+      # against the expected data. The spender must push two values whose
+      # concatenation equals +expected_data+.
+      #
+      # @param expected_data [String] binary string — the expected result of
+      #   concatenating the two unlocking values
+      # @return [Script]
+      def self.op_cat_lock(expected_data)
+        buf = [Opcodes::OP_CAT].pack('C')
+        buf << encode_push_data(expected_data.b)
+        buf << [Opcodes::OP_EQUAL].pack('C')
+        new(buf)
+      end
+
+      # Construct an OP_CAT unlocking script.
+      #
+      # Pushes two data items onto the stack. The locking script's OP_CAT
+      # will concatenate them and compare against the expected value.
+      #
+      # @param data1 [String] binary string — first item (pushed first, deeper on stack)
+      # @param data2 [String] binary string — second item (pushed second, top of stack)
+      # @return [Script]
+      def self.op_cat_unlock(data1, data2)
+        buf = encode_push_data(data1.b)
+        buf << encode_push_data(data2.b)
+        new(buf)
+      end
+
       # --- Serialisation ---
 
       # @return [String] a copy of the raw script bytes
@@ -420,6 +450,19 @@ module BSV
         end
       end
 
+      # Whether this is an OP_CAT puzzle script.
+      #
+      # Pattern: +OP_CAT <expected_data> OP_EQUAL+
+      #
+      # @return [Boolean]
+      def op_cat?
+        c = chunks
+        c.length == 3 &&
+          c[0].opcode == Opcodes::OP_CAT &&
+          c[1].data? &&
+          c[2].opcode == Opcodes::OP_EQUAL
+      end
+
       # Whether this is a bare multisig script.
       #
       # Pattern: +OP_M <pubkey1> ... <pubkeyN> OP_N OP_CHECKMULTISIG+
@@ -450,6 +493,7 @@ module BSV
         elsif multisig? then 'multisig'
         elsif pushdrop? then 'pushdrop'
         elsif rpuzzle? then 'rpuzzle'
+        elsif op_cat? then 'opcat'
         else 'nonstandard'
         end
       end
@@ -648,6 +692,11 @@ module BSV
 
             len = raw.getbyte(pos)
             pos += 1
+            if pos + len > raw.bytesize
+              raise ArgumentError,
+                    "truncated script: OP_PUSHDATA1 needs #{len} data bytes at offset #{pos}, got #{raw.bytesize - pos}"
+            end
+
             data = raw.byteslice(pos, len)
             pos += len
             result << Chunk.new(opcode: opcode, data: data)
@@ -656,6 +705,11 @@ module BSV
 
             len = raw.byteslice(pos, 2).unpack1('v')
             pos += 2
+            if pos + len > raw.bytesize
+              raise ArgumentError,
+                    "truncated script: OP_PUSHDATA2 needs #{len} data bytes at offset #{pos}, got #{raw.bytesize - pos}"
+            end
+
             data = raw.byteslice(pos, len)
             pos += len
             result << Chunk.new(opcode: opcode, data: data)
@@ -664,6 +718,11 @@ module BSV
 
             len = raw.byteslice(pos, 4).unpack1('V')
             pos += 4
+            if pos + len > raw.bytesize
+              raise ArgumentError,
+                    "truncated script: OP_PUSHDATA4 needs #{len} data bytes at offset #{pos}, got #{raw.bytesize - pos}"
+            end
+
             data = raw.byteslice(pos, len)
             pos += len
             result << Chunk.new(opcode: opcode, data: data)

data/lib/bsv/transaction/fee_models/live_policy.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module BSV
+  module Transaction
+    module FeeModels
+      # Dynamic fee model that fetches the live mining fee rate from an ARC
+      # policy endpoint.
+      #
+      # The fetched rate is cached for a configurable TTL (default 5 minutes)
+      # so repeated calls to {#compute_fee} do not repeatedly query the API.
+      # If a fetch fails, the model falls back to a configurable default rate.
+      #
+      # @example
+      #   model = BSV::Transaction::FeeModels::LivePolicy.new(
+      #     arc_url: 'https://arc.gorillapool.io',
+      #     fallback_rate: 50
+      #   )
+      #   fee = model.compute_fee(transaction)
+      class LivePolicy < FeeModel
+        DEFAULT_CACHE_TTL = 300 # 5 minutes in seconds
+
+        # @return [String] the ARC base URL
+        attr_reader :arc_url
+
+        # @return [Integer] fallback sat/kB when fetch fails
+        attr_reader :fallback_rate
+
+        # @return [Integer] cache TTL in seconds
+        attr_reader :cache_ttl
+
+        # @param arc_url [String] ARC base URL (e.g. 'https://arc.gorillapool.io')
+        # @param fallback_rate [Integer] sat/kB to use when fetch fails (default: 50)
+        # @param cache_ttl [Integer] seconds to cache a fetched rate (default: 300)
+        # @param api_key [String, nil] optional Bearer token for ARC authentication
+        # @param http_client [#request, nil] injectable HTTP client for testing
+        def initialize(arc_url:, fallback_rate: 50, cache_ttl: DEFAULT_CACHE_TTL, api_key: nil, http_client: nil)
+          super()
+          @arc_url = arc_url.chomp('/')
+          @fallback_rate = fallback_rate
+          @cache_ttl = cache_ttl
+          @api_key = api_key
+          @http_client = http_client
+          @cached_rate = nil
+          @cached_at = nil
+          @mutex = Mutex.new
+        end
+
+        # Compute the fee for a transaction using the latest ARC rate.
+        #
+        # @param transaction [Transaction] the transaction to compute the fee for
+        # @return [Integer] the fee in satoshis
+        def compute_fee(transaction)
+          rate = current_rate
+          size = transaction.estimated_size
+          (size / 1000.0 * rate).ceil
+        end
+
+        # Return the current sat/kB rate, fetching from ARC if the cache
+        # has expired.
+        #
+        # @return [Integer] satoshis per kilobyte
+        def current_rate
+          @mutex.synchronize do
+            return @cached_rate if cache_valid?
+
+            rate = fetch_rate
+            if rate
+              @cached_rate = rate
+              @cached_at = Time.now
+              rate
+            elsif @cached_rate
+              @cached_rate
+            else
+              @fallback_rate
+            end
+          end
+        end
+
+        private
+
+        def cache_valid?
+          @cached_rate && @cached_at && (Time.now - @cached_at) < @cache_ttl
+        end
+
+        def fetch_rate
+          uri = URI("#{@arc_url}/v1/policy")
+          request = Net::HTTP::Get.new(uri)
+          request['Accept'] = 'application/json'
+          request['Authorization'] = "Bearer #{@api_key}" if @api_key
+
+          response = execute(uri, request)
+          return unless (200..299).cover?(response.code.to_i)
+
+          payload = JSON.parse(response.body)
+          # Some endpoints wrap the policy in a 'data' key
+          payload = payload['data'] if payload.is_a?(Hash) && payload.key?('data') && payload['data'].is_a?(Hash)
+
+          extract_rate(payload)
+        rescue StandardError
+          nil
+        end
+
+        def extract_rate(payload)
+          policy = payload.is_a?(Hash) ? payload['policy'] : nil
+          return unless policy.is_a?(Hash)
+
+          # Primary: policy.fees.miningFee { satoshis: x, bytes: y }
+          fees = policy['fees']
+          mining_fee = fees.is_a?(Hash) ? fees['miningFee'] : nil
+          mining_fee ||= policy['miningFee']
+
+          if mining_fee.is_a?(Hash)
+            satoshis = mining_fee['satoshis']
+            bytes = mining_fee['bytes']
+            return [1, (satoshis.to_f / bytes * 1000).round].max if satoshis.is_a?(Numeric) && bytes.is_a?(Numeric) && bytes.positive?
+          end
+
+          # Fallback: direct sat/kB keys
+          %w[satPerKb sat_per_kb satoshisPerKb].each do |key|
+            value = policy[key]
+            return [1, value.round].max if value.is_a?(Numeric) && value.positive?
+          end
+
+          nil
+        end
+
+        def execute(uri, request)
+          if @http_client
+            @http_client.request(uri, request)
+          else
+            Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+              http.request(request)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bsv/transaction/fee_models.rb

@@ -5,6 +5,7 @@ module BSV
     # Namespace for fee model implementations.
     module FeeModels
       autoload :SatoshisPerKilobyte, 'bsv/transaction/fee_models/satoshis_per_kilobyte'
+      autoload :LivePolicy,          'bsv/transaction/fee_models/live_policy'
     end
   end
 end

data/lib/bsv/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BSV
-  VERSION = '0.3.1'
+  VERSION = '0.3.2'
 end

data/lib/bsv/wallet_interface/version.rb

@@ -2,6 +2,6 @@
 
 module BSV
   module WalletInterface
-    VERSION = '0.1.1'
+    VERSION = '0.1.2'
   end
 end

data/lib/bsv/wallet_interface/wallet_client.rb

@@ -2,6 +2,9 @@
 
 require 'securerandom'
 require 'base64'
+require 'net/http'
+require 'json'
+require 'uri'
 
 module BSV
   module Wallet
@@ -36,11 +39,13 @@ module BSV
       # @param storage [StorageAdapter] persistence adapter (default: MemoryStore)
       # @param network [String] 'mainnet' (default) or 'testnet'
       # @param chain_provider [ChainProvider] blockchain data provider (default: NullChainProvider)
-      def initialize(key, storage: MemoryStore.new, network: 'mainnet', chain_provider: NullChainProvider.new)
+      # @param http_client [#request, nil] injectable HTTP client for certificate issuance
+      def initialize(key, storage: MemoryStore.new, network: 'mainnet', chain_provider: NullChainProvider.new, http_client: nil)
         super(key)
         @storage = storage
         @network = network
         @chain_provider = chain_provider
+        @http_client = http_client
         @pending = {}
       end
 
@@ -254,18 +259,11 @@ module BSV
       def acquire_certificate(args, _originator: nil)
         validate_acquire_certificate!(args)
 
-        raise UnsupportedActionError, 'acquire_certificate with issuance protocol' if args[:acquisition_protocol] == 'issuance'
-
-        cert = {
-          type: args[:type],
-          subject: @key_deriver.identity_key,
-          serial_number: args[:serial_number],
-          certifier: args[:certifier],
-          revocation_outpoint: args[:revocation_outpoint],
-          signature: args[:signature],
-          fields: args[:fields],
-          keyring: args[:keyring_for_subject]
-        }
+        cert = if args[:acquisition_protocol] == 'issuance'
+                 acquire_via_issuance(args)
+               else
+                 acquire_via_direct(args)
+               end
 
         @storage.store_certificate(cert)
         cert_without_keyring(cert)
@@ -721,12 +719,69 @@ module BSV
         protocol = args[:acquisition_protocol]
         raise InvalidParameterError.new('acquisition_protocol', '"direct" or "issuance"') unless %w[direct issuance].include?(protocol)
 
-        return unless protocol == 'direct'
+        if protocol == 'direct'
+          raise InvalidParameterError.new('serial_number', 'present for direct acquisition') unless args[:serial_number]
+          raise InvalidParameterError.new('revocation_outpoint', 'present for direct acquisition') unless args[:revocation_outpoint]
+          raise InvalidParameterError.new('signature', 'present for direct acquisition') unless args[:signature]
+          raise InvalidParameterError.new('keyring_for_subject', 'a Hash for direct acquisition') unless args[:keyring_for_subject].is_a?(Hash)
+        elsif protocol == 'issuance'
+          raise InvalidParameterError.new('certifier_url', 'present for issuance acquisition') unless args[:certifier_url].is_a?(String)
+        end
+      end
 
-        raise InvalidParameterError.new('serial_number', 'present for direct acquisition') unless args[:serial_number]
-        raise InvalidParameterError.new('revocation_outpoint', 'present for direct acquisition') unless args[:revocation_outpoint]
-        raise InvalidParameterError.new('signature', 'present for direct acquisition') unless args[:signature]
-        raise InvalidParameterError.new('keyring_for_subject', 'a Hash for direct acquisition') unless args[:keyring_for_subject].is_a?(Hash)
+      def acquire_via_direct(args)
+        {
+          type: args[:type],
+          subject: @key_deriver.identity_key,
+          serial_number: args[:serial_number],
+          certifier: args[:certifier],
+          revocation_outpoint: args[:revocation_outpoint],
+          signature: args[:signature],
+          fields: args[:fields],
+          keyring: args[:keyring_for_subject]
+        }
+      end
+
+      def acquire_via_issuance(args)
+        uri = URI(args[:certifier_url])
+        request = Net::HTTP::Post.new(uri)
+        request['Content-Type'] = 'application/json'
+        request.body = JSON.generate({
+                                       type: args[:type],
+                                       subject: @key_deriver.identity_key,
+                                       certifier: args[:certifier],
+                                       fields: args[:fields]
+                                     })
+
+        response = execute_http(uri, request)
+        code = response.code.to_i
+
+        raise WalletError, "Certificate issuance failed: HTTP #{code}" unless (200..299).cover?(code)
+
+        body = JSON.parse(response.body)
+
+        {
+          type: body['type'] || args[:type],
+          subject: @key_deriver.identity_key,
+          serial_number: body['serialNumber'],
+          certifier: args[:certifier],
+          revocation_outpoint: body['revocationOutpoint'],
+          signature: body['signature'],
+          fields: body['fields'] || args[:fields],
+          keyring: body['keyringForSubject']
+        }
+      rescue JSON::ParserError
+        raise WalletError, 'Certificate issuance failed: invalid JSON response'
+      end
+
+      def execute_http(uri, request)
+        if @http_client
+          @http_client.request(uri, request)
+        else
+          Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+            http.request(request)
+          end
+        end
       end
 
       def find_stored_certificate(cert_arg)

data/lib/bsv/wallet_interface/wire/reader.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Wire
+      # Consumes a binary byte string using BRC-100 wire protocol decoding conventions.
+      #
+      # All multi-byte integers use little-endian order unless stated otherwise.
+      # VarInts follow Bitcoin encoding; the 9-byte MaxUint64 sentinel decodes as -1.
+      class Reader
+        # The 64-bit sentinel value that encodes -1 in a signed VarInt.
+        MAX_UINT64 = 0xFFFF_FFFF_FFFF_FFFF
+
+        def initialize(data)
+          @data = data.b
+          @offset = 0
+        end
+
+        # Current read position (bytes consumed so far).
+        attr_reader :offset
+
+        # Reads a single unsigned byte (0–255).
+        #
+        # @return [Integer]
+        def read_byte
+          require_bytes(1)
+          byte = @data.getbyte(@offset)
+          @offset += 1
+          byte
+        end
+
+        # Reads a signed 8-bit integer (-128–127).
+        #
+        # @return [Integer]
+        def read_int8
+          require_bytes(1)
+          val = @data.byteslice(@offset, 1).unpack1('c')
+          @offset += 1
+          val
+        end
+
+        # Reads an unsigned Bitcoin VarInt.
+        #
+        # @return [Integer]
+        def read_varint
+          require_bytes(1)
+          first = @data.getbyte(@offset)
+
+          case first
+          when 0..0xFC
+            @offset += 1
+            first
+          when 0xFD
+            require_bytes(3)
+            val = @data.byteslice(@offset + 1, 2).unpack1('v')
+            @offset += 3
+            val
+          when 0xFE
+            require_bytes(5)
+            val = @data.byteslice(@offset + 1, 4).unpack1('V')
+            @offset += 5
+            val
+          else # 0xFF
+            require_bytes(9)
+            val = @data.byteslice(@offset + 1, 8).unpack1('Q<')
+            @offset += 9
+            val
+          end
+        end
+
+        # Reads a signed VarInt, returning -1 for the MaxUint64 sentinel.
+        #
+        # @return [Integer] non-negative value or -1
+        def read_signed_varint
+          val = read_varint
+          val == MAX_UINT64 ? -1 : val
+        end
+
+        # Reads exactly n raw bytes.
+        #
+        # @param n [Integer]
+        # @return [String] binary string
+        def read_bytes(n)
+          require_bytes(n)
+          slice = @data.byteslice(@offset, n)
+          @offset += n
+          slice
+        end
+
+        # Reads all remaining bytes from the current offset.
+        #
+        # @return [String] binary string
+        def read_remaining
+          slice = @data.byteslice(@offset, @data.bytesize - @offset) || ''.b
+          @offset = @data.bytesize
+          slice
+        end
+
+        # Reads a VarInt-prefixed byte array.
+        #
+        # @return [String] binary string
+        def read_byte_array
+          len = read_varint
+          read_bytes(len)
+        end
+
+        # Reads an optional VarInt-prefixed byte array; returns nil for the -1 sentinel.
+        #
+        # @return [String, nil]
+        def read_optional_byte_array
+          len = read_signed_varint
+          return nil if len == -1
+
+          read_bytes(len)
+        end
+
+        # Reads a VarInt-prefixed UTF-8 string.
+        #
+        # @return [String]
+        def read_utf8_string
+          len = read_varint
+          read_bytes(len).force_encoding('UTF-8')
+        end
+
+        # Reads an optional VarInt-prefixed UTF-8 string; returns nil for the -1 sentinel.
+        #
+        # @return [String, nil]
+        def read_optional_utf8_string
+          len = read_signed_varint
+          return nil if len == -1
+
+          read_bytes(len).force_encoding('UTF-8')
+        end
+
+        # Reads a signed Int8 optional boolean: 1=true, 0=false, -1=nil.
+        #
+        # @return [Boolean, nil]
+        def read_optional_bool
+          val = read_int8
+          return nil if val == -1
+
+          val == 1
+        end
+
+        # Reads an outpoint: 32 bytes (txid hex in display order) + VarInt index.
+        #
+        # @return [Array(String, Integer)] [txid_hex, index]
+        def read_outpoint
+          txid_bytes = read_bytes(32)
+          txid_hex = txid_bytes.unpack1('H*')
+          index = read_varint
+          [txid_hex, index]
+        end
+
+        # Reads a counterparty value using the first-byte dispatch scheme.
+        #
+        # @return [String, nil] 'self', 'anyone', nil, or 66-char hex pubkey
+        def read_counterparty
+          flag = read_byte
+          case flag
+          when 11
+            'self'
+          when 12
+            'anyone'
+          when 0
+            nil
+          else
+            # First byte is part of the 33-byte compressed pubkey; read 32 more
+            remaining = read_bytes(32)
+            ([flag].pack('C') + remaining).unpack1('H*')
+          end
+        end
+
+        # Reads a protocol ID: UInt8 security level + VarInt-prefixed UTF-8 name.
+        #
+        # @return [Array(Integer, String)] [level, name]
+        def read_protocol_id
+          level = read_byte
+          name = read_utf8_string
+          [level, name]
+        end
+
+        # Reads an optional string array: VarInt count + strings, or nil for the -1 sentinel.
+        #
+        # @return [Array<String>, nil]
+        def read_string_array
+          count = read_signed_varint
+          return nil if count == -1
+
+          count.times.map { read_utf8_string }
+        end
+
+        # Reads an optional string→string map: VarInt count + key/value pairs, or nil.
+        #
+        # @return [Hash, nil]
+        def read_map
+          count = read_signed_varint
+          return nil if count == -1
+
+          count.times.each_with_object({}) do |_, hash|
+            key = read_utf8_string
+            val = read_utf8_string
+            hash[key] = val
+          end
+        end
+
+        # Reads privileged parameters: optional bool + Int8-length reason string.
+        #
+        # @return [Array(Boolean|nil, String|nil)] [privileged, privileged_reason]
+        def read_privileged
+          privileged = read_optional_bool
+          reason_len = read_int8
+          privileged_reason = if reason_len == -1
+                                nil
+                              elsif reason_len.negative?
+                                raise ArgumentError, "invalid privileged_reason length: #{reason_len}"
+                              else
+                                read_bytes(reason_len).force_encoding('UTF-8')
+                              end
+          [privileged, privileged_reason]
+        end
+
+        private
+
+        def require_bytes(n)
+          raise ArgumentError, "negative byte count: #{n}" if n.negative?
+
+          remaining = @data.bytesize - @offset
+          return if remaining >= n
+
+          raise ArgumentError,
+                "truncated wire data: need #{n} bytes at offset #{@offset}, " \
+                "got #{remaining}"
+        end
+      end
+    end
+  end
+end