sibit 0.33.0 → 0.34.1

data/lib/sibit/sochain.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+require 'iri'
+require 'json'
+require 'loog'
+require 'uri'
+require_relative 'error'
+require_relative 'http'
+require_relative 'json'
+require_relative 'version'
+
+# SoChain API (formerly known as Block.io).
+#
+# Documentation: https://sochain.com/api
+#
+# Author:: Yegor Bugayenko (yegor256@gmail.com)
+# Copyright:: Copyright (c) 2019-2026 Yegor Bugayenko
+# License:: MIT
+class Sibit::Sochain
+  # Constructor.
+  def initialize(log: Loog::NULL, http: Sibit::Http.new, network: 'BTC')
+    @http = http
+    @log = log
+    @network = network
+  end
+
+  # Current price of BTC in USD (float returned).
+  def price(currency = 'USD')
+    data = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://sochain.com/api/v2/get_price').append(@network).append(currency)
+    )['data']
+    raise(Sibit::Error, "No price data returned for #{@network}/#{currency}") if data.nil?
+    prices = data['prices']
+    if prices.nil? || prices.empty?
+      raise(Sibit::Error, "No price quotes for #{@network}/#{currency}")
+    end
+    price = Float(prices[0]['price'])
+    @log.debug("The price of #{@network} is #{price} #{currency}")
+    price
+  end
+
+  # The height of the block, identified by hash.
+  def height(hash)
+    data = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://sochain.com/api/v2/block').append(@network).append(hash)
+    )['data']
+    raise(Sibit::Error, "The block #{hash} not found") if data.nil?
+    h = data['block_no']
+    raise(Sibit::Error, "The block #{hash} found but the height is absent") if h.nil?
+    @log.debug("The height of #{hash} is #{h}")
+    Integer(h)
+  end
+
+  # Get hash of the block after this one.
+  def next_of(hash)
+    data = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://sochain.com/api/v2/block').append(@network).append(hash)
+    )['data']
+    raise(Sibit::Error, "The block #{hash} not found") if data.nil?
+    nxt = data['next_blockhash']
+    nxt = nil if nxt == '0000000000000000000000000000000000000000000000000000000000000000'
+    @log.debug("In SoChain the block #{hash} is the latest, there is no next block") if nxt.nil?
+    @log.debug("The next block of #{hash} is #{nxt}") unless nxt.nil?
+    nxt
+  end
+
+  # Gets the balance of the address, in satoshi.
+  def balance(address)
+    data = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://sochain.com/api/v2/get_address_balance').append(@network).append(address)
+    )['data']
+    if data.nil?
+      @log.debug("The balance of #{address} is probably zero (not found)")
+      return 0
+    end
+    confirmed = data['confirmed_balance']
+    if confirmed.nil?
+      @log.debug("The balance of #{address} is probably zero (no confirmed_balance)")
+      return 0
+    end
+    b = Integer((Float(confirmed) * 100_000_000).round)
+    @log.debug("The balance of #{address} is #{b} satoshi")
+    b
+  end
+
+  # Get recommended fees, in satoshi per byte.
+  def fees
+    raise(Sibit::NotSupportedError, 'SoChain doesn\'t provide recommended fees')
+  end
+
+  # Gets the hash of the latest block.
+  def latest
+    data = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://sochain.com/api/v2/get_info').append(@network)
+    )['data']
+    raise(Sibit::Error, 'The latest block info not found') if data.nil?
+    hash = data['blockhash']
+    raise(Sibit::Error, 'The latest block hash is absent') if hash.nil?
+    @log.debug("The latest block hash is #{hash}")
+    hash
+  end
+
+  # Fetch all unspent outputs per address. The argument is an array
+  # of Bitcoin addresses.
+  def utxos(sources)
+    out = []
+    sources.each do |address|
+      data = Sibit::Json.new(http: @http, log: @log).get(
+        Iri.new('https://sochain.com/api/v2/get_tx_unspent').append(@network).append(address)
+      )['data']
+      raise(Sibit::Error, "The address #{address} unspent lookup returned no data") if data.nil?
+      txs = data['txs']
+      raise(Sibit::Error, "The address #{address} unspent lookup returned no txs") if txs.nil?
+      txs.each do |u|
+        out << {
+          value: Integer((Float(u['value']) * 100_000_000).round),
+          hash: u['txid'],
+          index: u['output_no'],
+          confirmations: u['confirmations'],
+          script: [u['script_hex']].pack('H*')
+        }
+      end
+    end
+    out
+  end
+
+  # Push this transaction (in hex format) to the network. SoChain expects a
+  # JSON payload with the +tx_hex+ field on POST /send_tx/{network}.
+  def push(hex)
+    uri = URI(Iri.new('https://sochain.com/api/v2/send_tx').append(@network).to_s)
+    res = @http.client(uri).post(
+      uri.path,
+      JSON.generate(tx_hex: hex),
+      {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json',
+        'Accept-Charset' => 'UTF-8',
+        'Accept-Encoding' => ''
+      }
+    )
+    unless res.code == '200'
+      raise(Sibit::Error, "Failed to push transaction to #{uri}: #{res.code}\n#{res.body}")
+    end
+    @log.debug("Transaction (#{hex.length} chars in hex) has been pushed to SoChain")
+  end
+
+  # This method should fetch a block and return it as a hash.
+  def block(hash)
+    data = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://sochain.com/api/v2/block').append(@network).append(hash)
+    )['data']
+    raise(Sibit::Error, "The block #{hash} not found") if data.nil?
+    nxt = data['next_blockhash']
+    nxt = nil if nxt == '0000000000000000000000000000000000000000000000000000000000000000'
+    {
+      provider: self.class.name,
+      hash: data['blockhash'],
+      orphan: data['is_orphan'] == true,
+      next: nxt,
+      previous: data['previous_blockhash'],
+      txns: (data['txs'] || []).map do |t|
+        unless t.is_a?(Hash)
+          raise(Sibit::NotSupportedError, "SoChain returned bare txid #{t} without outputs")
+        end
+        {
+          hash: t['txid'],
+          outputs: (t['outputs'] || []).map do |o|
+            {
+              address: o['address'],
+              value: Integer((Float(o['value']) * 100_000_000).round)
+            }
+          end
+        }
+      end
+    }
+  end
+end

data/lib/sibit/tx.rb

@@ -6,6 +6,7 @@
 require 'digest'
 require_relative 'base58'
 require_relative 'bech32'
+require_relative 'error'
 require_relative 'key'
 require_relative 'script'
 
@@ -37,12 +38,16 @@ class Sibit
     end
 
     def hash
-      Digest::SHA256.hexdigest(Digest::SHA256.digest(payload)).reverse.scan(/../).join
+      sign_inputs
+      Digest::SHA256.hexdigest(
+        Digest::SHA256.digest(serialize(witness: false))
+      ).scan(/../).reverse.join
     end
 
     def payload
+      return @payload if @payload
       sign_inputs
-      serialize
+      @payload = serialize
     end
 
     def hex
@@ -105,7 +110,9 @@ class Sibit
 
       def script
         return segwit_script if segwit?
-        p2pkh_script
+        return p2pkh_script if %w[00 6f].include?(version)
+        return p2sh_script if %w[05 c4].include?(version)
+        raise(Sibit::Error, "Address '#{@address}' has an unsupported version byte 0x#{version}")
       end
 
       def segwit?
@@ -118,17 +125,42 @@ class Sibit
 
       private
 
+      def decoded
+        return @decoded if @decoded
+        hex = Base58.new(@address).decode
+        unless hex.length == 50
+          raise(Sibit::Error, "Address '#{@address}' does not decode to 25 bytes")
+        end
+        unless hex[-8..] == Base58.new(hex[0..-9]).check
+          raise(Sibit::Error, "Address '#{@address}' fails its Base58 checksum")
+        end
+        @decoded = hex
+      end
+
+      def version
+        decoded[0, 2]
+      end
+
+      def hash160
+        [decoded[2, 40]].pack('H*')
+      end
+
       def p2pkh_script
-        decoded = Base58.new(@address).decode
-        hash = decoded[2..41]
-        [0x76, 0xa9, 0x14].pack('C*') + [hash].pack('H*') + [0x88, 0xac].pack('C*')
+        [0x76, 0xa9, 0x14].pack('C*') + hash160 + [0x88, 0xac].pack('C*')
+      end
+
+      def p2sh_script
+        [0xa9, 0x14].pack('C*') + hash160 + [0x87].pack('C*')
       end
 
       def segwit_script
         bech = Bech32.new(@address)
-        witness = bech.witness
-        len = witness.length / 2
-        [0x00, len].pack('C*') + [witness].pack('H*')
+        program = bech.witness
+        [opcode(bech.version), program.length / 2].pack('C*') + [program].pack('H*')
+      end
+
+      def opcode(version)
+        version.zero? ? 0x00 : 0x50 + version
       end
     end
 
@@ -139,23 +171,23 @@ class Sibit
     end
 
     def sign_inputs
+      return if @signed
       @inputs.each_with_index do |input, idx|
-        sighash = input.segwit? ? segwit_sighash(idx) : legacy_sighash(idx)
-        sig = sign(input.key, sighash)
+        sig = sign(input.key, (input.segwit? ? segwit_sighash(idx) : legacy_sighash(idx)))
         pubkey = [input.key.pub].pack('H*')
         if input.segwit?
-          witness_sig = sig + [SIGHASH_ALL].pack('C')
-          input.witness = [witness_sig.bytes, pubkey.bytes]
+          input.witness = [(sig + [SIGHASH_ALL].pack('C')).bytes, pubkey.bytes]
         else
           input.script_sig = der_sig(sig) + pubkey_script(pubkey)
         end
       end
+      @signed = true
     end
 
     def legacy_sighash(idx)
-      tx_copy = serialize_for_signing(idx)
-      hash_type = [SIGHASH_ALL].pack('V')
-      Digest::SHA256.digest(Digest::SHA256.digest(tx_copy + hash_type))
+      Digest::SHA256.digest(
+        Digest::SHA256.digest(serialize_for_signing(idx) + [SIGHASH_ALL].pack('V'))
+      )
     end
 
     def segwit_sighash(idx)
@@ -175,48 +207,55 @@ class Sibit
     end
 
     def hash_prevouts
-      data = @inputs.map { |i| [i.hash].pack('H*').reverse + [i.index].pack('V') }.join
-      Digest::SHA256.digest(Digest::SHA256.digest(data))
+      Digest::SHA256.digest(
+        Digest::SHA256.digest(
+          @inputs.map do |i|
+            [i.hash].pack('H*').reverse + [i.index].pack('V')
+          end.join
+        )
+      )
     end
 
     def hash_sequence
-      data = @inputs.map { [SEQUENCE].pack('V') }.join
-      Digest::SHA256.digest(Digest::SHA256.digest(data))
+      Digest::SHA256.digest(Digest::SHA256.digest(@inputs.map { [SEQUENCE].pack('V') }.join))
     end
 
     def hash_outputs
-      data = @outputs.map { |o| [o.value].pack('Q<') + varint(o.script.length) + o.script }.join
-      Digest::SHA256.digest(Digest::SHA256.digest(data))
+      Digest::SHA256.digest(
+        Digest::SHA256.digest(
+          @outputs.map do |o|
+            [o.value].pack('Q<') + varint(o.script.length) + o.script
+          end.join
+        )
+      )
     end
 
     def script_code(input)
-      hash160 = input.prev_script[4..]
-      code = [0x76, 0xa9, 0x14].pack('C*') + [hash160].pack('H*') + [0x88, 0xac].pack('C*')
+      code = [
+        0x76, 0xa9,
+        0x14
+      ].pack('C*') + [input.prev_script[4..]].pack('H*') + [0x88, 0xac].pack('C*')
       varint(code.length) + code
     end
 
     def sign(key, hash)
-      der = key.sign(hash)
-      repack(der)
+      repack(key.sign(hash))
     end
 
     def repack(der)
       return der if low_s?(der)
       seq = OpenSSL::ASN1.decode(der)
-      r = seq.value[0].value.to_i
-      s = seq.value[1].value.to_i
+      s = Integer(seq.value[1].value)
       order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
       s = order - s if s > order / 2
       OpenSSL::ASN1::Sequence.new(
-        [OpenSSL::ASN1::Integer.new(r), OpenSSL::ASN1::Integer.new(s)]
+        [OpenSSL::ASN1::Integer.new(Integer(seq.value[0].value)), OpenSSL::ASN1::Integer.new(s)]
       ).to_der
     end
 
     def low_s?(der)
-      seq = OpenSSL::ASN1.decode(der)
-      s = seq.value[1].value.to_i
-      order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
-      s <= order / 2
+      Integer(OpenSSL::ASN1.decode(der).value[1].value) <=
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 / 2
     end
 
     def der_sig(sig)
@@ -228,9 +267,9 @@ class Sibit
       [pubkey.length].pack('C') + pubkey
     end
 
-    def serialize
+    def serialize(witness: witness?)
       result = [VERSION].pack('V')
-      result += [0x00, 0x01].pack('CC') if witness?
+      result += [0x00, 0x01].pack('CC') if witness
       result += varint(@inputs.length)
       @inputs.each do |input|
         result += [input.hash].pack('H*').reverse
@@ -246,7 +285,7 @@ class Sibit
         result += varint(script.length)
         result += script
       end
-      result += serialize_witness if witness?
+      result += serialize_witness if witness
       result += [0].pack('V')
       result
     end

data/lib/sibit/txbuilder.rb

@@ -3,6 +3,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
+require_relative 'error'
 require_relative 'key'
 require_relative 'tx'
 
@@ -17,6 +18,8 @@ class Sibit
   # Copyright:: Copyright (c) 2019-2026 Yegor Bugayenko
   # License:: MIT
   class TxBuilder
+    DUST = 546
+
     def initialize
       @inputs = []
       @outputs = []
@@ -24,7 +27,7 @@ class Sibit
 
     def input
       inp = Input.new
-      yield inp
+      yield(inp)
       @inputs << inp
     end
 
@@ -43,10 +46,19 @@ class Sibit
           value: inp.amount
         )
       end
-      total_out = @outputs.sum { |o| o[:value] }
+      total = @outputs.sum { |o| o[:value] }
       @outputs.each { |o| txn.add_output(o[:value], o[:address]) }
       if leave_fee
-        change = input_value - total_out - extra_fee
+        change = input_value - total - extra_fee
+        if change.negative?
+          raise(
+            Sibit::Error,
+            "The inputs of #{input_value} cannot cover outputs of #{total} plus fee of #{extra_fee}"
+          )
+        end
+        if change.positive? && change < DUST
+          raise(Sibit::Error, "The change of #{change} is below the dust limit of #{DUST}")
+        end
         txn.add_output(change, change_address) if change.positive?
       end
       Built.new(txn, @inputs, @outputs)

data/lib/sibit/version.rb

@@ -8,6 +8,5 @@
 # Copyright:: Copyright (c) 2019-2026 Yegor Bugayenko
 # License:: MIT
 class Sibit
-  # Current version of the library.
-  VERSION = '0.33.0' unless defined?(VERSION)
+  VERSION = '0.34.1' unless defined?(VERSION)
 end