sibit 0.28.0 → 0.29.0

data/lib/sibit/bitcoin/tx.rb

@@ -8,205 +8,203 @@ require_relative 'base58'
 require_relative 'key'
 require_relative 'script'
 
-class Sibit
-  module Bitcoin
-    # Bitcoin Transaction structure.
-    #
-    # Author:: Yegor Bugayenko (yegor256@gmail.com)
-    # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
-    # License:: MIT
-    class Tx
-      SIGHASH_ALL = 0x01
-      VERSION = 1
-      SEQUENCE = 0xffffffff
-
-      attr_reader :inputs, :outputs
-
-      def initialize
-        @inputs = []
-        @outputs = []
-      end
+module Sibit::Bitcoin
+  # Bitcoin Transaction structure.
+  #
+  # Author:: Yegor Bugayenko (yegor256@gmail.com)
+  # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
+  # License:: MIT
+  class Tx
+    SIGHASH_ALL = 0x01
+    VERSION = 1
+    SEQUENCE = 0xffffffff
+
+    attr_reader :inputs, :outputs
+
+    def initialize
+      @inputs = []
+      @outputs = []
+    end
 
-      def add_input(hash:, index:, script:, key:)
-        @inputs << Input.new(hash, index, script, key)
-      end
+    def add_input(hash:, index:, script:, key:)
+      @inputs << Input.new(hash, index, script, key)
+    end
 
-      def add_output(value, address)
-        @outputs << Output.new(value, address)
-      end
+    def add_output(value, address)
+      @outputs << Output.new(value, address)
+    end
 
-      def hash
-        Digest::SHA256.hexdigest(Digest::SHA256.digest(payload)).reverse.scan(/../).join
-      end
+    def hash
+      Digest::SHA256.hexdigest(Digest::SHA256.digest(payload)).reverse.scan(/../).join
+    end
 
-      def payload
-        sign_inputs
-        serialize
-      end
+    def payload
+      sign_inputs
+      serialize
+    end
 
-      def hex
-        payload.unpack1('H*')
-      end
+    def hex
+      payload.unpack1('H*')
+    end
 
-      def in
-        @inputs
-      end
+    def in
+      @inputs
+    end
 
-      def out
-        @outputs
-      end
+    def out
+      @outputs
+    end
 
-      private
+    private
 
-      def sign_inputs
-        @inputs.each_with_index do |input, idx|
-          sighash = signature_hash(idx)
-          sig = sign(input.key, sighash)
-          pubkey = [input.key.pub].pack('H*')
-          input.script_sig = der_sig(sig) + pubkey_script(pubkey)
-        end
+    def sign_inputs
+      @inputs.each_with_index do |input, idx|
+        sighash = signature_hash(idx)
+        sig = sign(input.key, sighash)
+        pubkey = [input.key.pub].pack('H*')
+        input.script_sig = der_sig(sig) + pubkey_script(pubkey)
       end
+    end
 
-      def signature_hash(idx)
-        tx_copy = serialize_for_signing(idx)
-        hash_type = [SIGHASH_ALL].pack('V')
-        Digest::SHA256.digest(Digest::SHA256.digest(tx_copy + hash_type))
-      end
+    def signature_hash(idx)
+      tx_copy = serialize_for_signing(idx)
+      hash_type = [SIGHASH_ALL].pack('V')
+      Digest::SHA256.digest(Digest::SHA256.digest(tx_copy + hash_type))
+    end
 
-      def sign(key, hash)
-        der = key.sign(hash)
-        repack(der)
-      end
+    def sign(key, hash)
+      der = key.sign(hash)
+      repack(der)
+    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
-        order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
-        s = order - s if s > order / 2
-        OpenSSL::ASN1::Sequence.new(
-          [OpenSSL::ASN1::Integer.new(r), OpenSSL::ASN1::Integer.new(s)]
-        ).to_der
-      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
+      order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+      s = order - s if s > order / 2
+      OpenSSL::ASN1::Sequence.new(
+        [OpenSSL::ASN1::Integer.new(r), 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
-      end
+    def low_s?(der)
+      seq = OpenSSL::ASN1.decode(der)
+      s = seq.value[1].value.to_i
+      order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+      s <= order / 2
+    end
 
-      def der_sig(sig)
-        data = sig + [SIGHASH_ALL].pack('C')
-        [data.length].pack('C') + data
-      end
+    def der_sig(sig)
+      data = sig + [SIGHASH_ALL].pack('C')
+      [data.length].pack('C') + data
+    end
 
-      def pubkey_script(pubkey)
-        [pubkey.length].pack('C') + pubkey
-      end
+    def pubkey_script(pubkey)
+      [pubkey.length].pack('C') + pubkey
+    end
 
-      def serialize
-        result = [VERSION].pack('V')
-        result += varint(@inputs.length)
-        @inputs.each do |input|
-          result += [input.hash].pack('H*').reverse
-          result += [input.index].pack('V')
-          result += varint(input.script_sig.length)
-          result += input.script_sig
-          result += [SEQUENCE].pack('V')
-        end
-        result += varint(@outputs.length)
-        @outputs.each do |output|
-          result += [output.value].pack('Q<')
-          script = output.script
-          result += varint(script.length)
-          result += script
-        end
-        result += [0].pack('V')
-        result
-      end
+    def serialize
+      result = [VERSION].pack('V')
+      result += varint(@inputs.length)
+      @inputs.each do |input|
+        result += [input.hash].pack('H*').reverse
+        result += [input.index].pack('V')
+        result += varint(input.script_sig.length)
+        result += input.script_sig
+        result += [SEQUENCE].pack('V')
+      end
+      result += varint(@outputs.length)
+      @outputs.each do |output|
+        result += [output.value].pack('Q<')
+        script = output.script
+        result += varint(script.length)
+        result += script
+      end
+      result += [0].pack('V')
+      result
+    end
 
-      def serialize_for_signing(idx)
-        result = [VERSION].pack('V')
-        result += varint(@inputs.length)
-        @inputs.each_with_index do |input, i|
-          result += [input.hash].pack('H*').reverse
-          result += [input.index].pack('V')
-          if i == idx
-            script = [input.prev_script].pack('H*')
-            result += varint(script.length)
-            result += script
-          else
-            result += varint(0)
-          end
-          result += [SEQUENCE].pack('V')
-        end
-        result += varint(@outputs.length)
-        @outputs.each do |output|
-          result += [output.value].pack('Q<')
-          script = output.script
+    def serialize_for_signing(idx)
+      result = [VERSION].pack('V')
+      result += varint(@inputs.length)
+      @inputs.each_with_index do |input, i|
+        result += [input.hash].pack('H*').reverse
+        result += [input.index].pack('V')
+        if i == idx
+          script = [input.prev_script].pack('H*')
           result += varint(script.length)
           result += script
+        else
+          result += varint(0)
         end
-        result += [0].pack('V')
-        result
+        result += [SEQUENCE].pack('V')
       end
-
-      def varint(num)
-        return [num].pack('C') if num < 0xfd
-        return [0xfd, num].pack('Cv') if num <= 0xffff
-        return [0xfe, num].pack('CV') if num <= 0xffffffff
-        [0xff, num].pack('CQ<')
+      result += varint(@outputs.length)
+      @outputs.each do |output|
+        result += [output.value].pack('Q<')
+        script = output.script
+        result += varint(script.length)
+        result += script
       end
+      result += [0].pack('V')
+      result
     end
 
-    # Transaction input.
-    class Input
-      attr_reader :hash, :index, :prev_script, :key
-      attr_accessor :script_sig
+    def varint(num)
+      return [num].pack('C') if num < 0xfd
+      return [0xfd, num].pack('Cv') if num <= 0xffff
+      return [0xfe, num].pack('CV') if num <= 0xffffffff
+      [0xff, num].pack('CQ<')
+    end
+  end
 
-      def initialize(hash, index, script, key)
-        @hash = hash
-        @index = index
-        @prev_script = script
-        @key = key
-        @script_sig = ''
-      end
+  # Transaction input.
+  class Input
+    attr_reader :hash, :index, :prev_script, :key
+    attr_accessor :script_sig
+
+    def initialize(hash, index, script, key)
+      @hash = hash
+      @index = index
+      @prev_script = script
+      @key = key
+      @script_sig = ''
+    end
 
-      def prev_out
-        [@hash].pack('H*')
-      end
+    def prev_out
+      [@hash].pack('H*')
+    end
 
-      def prev_out_index
-        @index
-      end
+    def prev_out_index
+      @index
     end
+  end
 
-    # Transaction output.
-    class Output
-      attr_reader :value
+  # Transaction output.
+  class Output
+    attr_reader :value
 
-      def initialize(value, address)
-        @value = value
-        @address = address
-      end
+    def initialize(value, address)
+      @value = value
+      @address = address
+    end
 
-      def script
-        hash160 = address_to_hash160(@address)
-        [0x76, 0xa9, 0x14].pack('C*') + [hash160].pack('H*') + [0x88, 0xac].pack('C*')
-      end
+    def script
+      hash160 = address_to_hash160(@address)
+      [0x76, 0xa9, 0x14].pack('C*') + [hash160].pack('H*') + [0x88, 0xac].pack('C*')
+    end
 
-      def script_hex
-        script.unpack1('H*')
-      end
+    def script_hex
+      script.unpack1('H*')
+    end
 
-      private
+    private
 
-      def address_to_hash160(addr)
-        decoded = Base58.decode(addr)
-        decoded[2..41]
-      end
+    def address_to_hash160(addr)
+      decoded = Base58.decode(addr)
+      decoded[2..41]
     end
   end
 end

data/lib/sibit/bitcoin/txbuilder.rb

@@ -3,8 +3,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2025 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-require_relative 'tx'
 require_relative 'key'
+require_relative 'tx'
 
 class Sibit
   module Bitcoin

data/lib/sibit/bitcoinchain.rb

@@ -5,10 +5,10 @@
 
 require 'iri'
 require 'json'
+require 'loog'
 require 'uri'
 require_relative 'error'
 require_relative 'http'
-require 'loog'
 require_relative 'json'
 require_relative 'version'
 
@@ -17,110 +17,107 @@ require_relative 'version'
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
 # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
 # License:: MIT
-class Sibit
-  # Btc.com API.
-  class Bitcoinchain
-    # Constructor.
-    def initialize(log: Loog::NULL, http: Sibit::Http.new, dry: false)
-      @http = http
-      @log = log
-      @dry = dry
-    end
+class Sibit::Bitcoinchain
+  # Constructor.
+  def initialize(log: Loog::NULL, http: Sibit::Http.new, dry: false)
+    @http = http
+    @log = log
+    @dry = dry
+  end
 
-    # Current price of BTC in USD (float returned).
-    def price(_currency = 'USD')
-      raise Sibit::NotSupportedError, 'Bitcoinchain API doesn\'t provide BTC price'
-    end
+  # Current price of BTC in USD (float returned).
+  def price(_currency = 'USD')
+    raise Sibit::NotSupportedError, 'Bitcoinchain API doesn\'t provide BTC price'
+  end
 
-    # The height of the block.
-    def height(_hash)
-      raise Sibit::NotSupportedError, 'Bitcoinchain API doesn\'t provide height()'
-    end
+  # The height of the block.
+  def height(_hash)
+    raise Sibit::NotSupportedError, 'Bitcoinchain API doesn\'t provide height()'
+  end
 
-    # Get hash of the block after this one.
-    def next_of(hash)
-      block = Sibit::Json.new(http: @http, log: @log).get(
-        Iri.new('https://api-r.bitcoinchain.com/v1/block').append(hash)
-      )[0]
-      raise Sibit::Error, "Block #{hash} not found" if block.nil?
-      nxt = block['next_block']
-      nxt = nil if nxt == '0000000000000000000000000000000000000000000000000000000000000000'
-      @log.info("The block #{hash} is the latest, there is no next block") if nxt.nil?
-      @log.info("The next block of #{hash} is #{nxt}") unless nxt.nil?
-      nxt
-    end
+  # Get hash of the block after this one.
+  def next_of(hash)
+    block = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://api-r.bitcoinchain.com/v1/block').append(hash)
+    )[0]
+    raise Sibit::Error, "Block #{hash} not found" if block.nil?
+    nxt = block['next_block']
+    nxt = nil if nxt == '0000000000000000000000000000000000000000000000000000000000000000'
+    @log.info("The block #{hash} is the latest, there is no next block") if nxt.nil?
+    @log.info("The next block of #{hash} is #{nxt}") unless nxt.nil?
+    nxt
+  end
 
-    # Gets the balance of the address, in satoshi.
-    def balance(address)
-      json = Sibit::Json.new(http: @http, log: @log).get(
-        Iri.new('https://api-r.bitcoinchain.com/v1/address').append(address),
-        accept: [200, 409]
-      )[0]
-      b = json['balance']
-      if b.nil?
-        @log.info("The balance of #{address} is not visible")
-        return 0
-      end
-      b *= 100_000_000
-      b = b.to_i
-      @log.info("The balance of #{address} is #{b} satoshi (#{json['transactions']} txns)")
-      b
+  # Gets the balance of the address, in satoshi.
+  def balance(address)
+    json = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://api-r.bitcoinchain.com/v1/address').append(address),
+      accept: [200, 409]
+    )[0]
+    b = json['balance']
+    if b.nil?
+      @log.info("The balance of #{address} is not visible")
+      return 0
     end
+    b *= 100_000_000
+    b = b.to_i
+    @log.info("The balance of #{address} is #{b} satoshi (#{json['transactions']} txns)")
+    b
+  end
 
-    # Get recommended fees, in satoshi per byte.
-    def fees
-      raise Sibit::NotSupportedError, 'Not implemented yet'
-    end
+  # Get recommended fees, in satoshi per byte.
+  def fees
+    raise Sibit::NotSupportedError, 'Not implemented yet'
+  end
 
-    # Gets the hash of the latest block.
-    def latest
-      hash = Sibit::Json.new(http: @http, log: @log).get(
-        Iri.new('https://api-r.bitcoinchain.com/v1/status')
-      )['hash']
-      @log.info("The latest block hash is #{hash}")
-      hash
-    end
+  # Gets the hash of the latest block.
+  def latest
+    hash = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://api-r.bitcoinchain.com/v1/status')
+    )['hash']
+    @log.info("The latest block hash is #{hash}")
+    hash
+  end
 
-    # Fetch all unspent outputs per address.
-    def utxos(_sources)
-      raise Sibit::NotSupportedError, 'Not implemented yet'
-    end
+  # Fetch all unspent outputs per address.
+  def utxos(_sources)
+    raise Sibit::NotSupportedError, 'Not implemented yet'
+  end
 
-    # Push this transaction (in hex format) to the network.
-    def push(_hex)
-      raise Sibit::NotSupportedError, 'Not implemented yet'
-    end
+  # Push this transaction (in hex format) to the network.
+  def push(_hex)
+    raise Sibit::NotSupportedError, 'Not implemented yet'
+  end
 
-    # This method should fetch a Blockchain block and return as a hash. Raises
-    # an exception if the block is not found.
-    def block(hash)
-      head = Sibit::Json.new(http: @http, log: @log).get(
-        Iri.new('https://api-r.bitcoinchain.com/v1/block').append(hash)
-      )[0]
-      raise Sibit::Error, "The block #{hash} is not found" if head.nil?
-      txs = Sibit::Json.new(http: @http, log: @log).get(
-        Iri.new('https://api-r.bitcoinchain.com/v1/block/txs').append(hash)
-      )
-      nxt = head['next_block']
-      nxt = nil if nxt == '0000000000000000000000000000000000000000000000000000000000000000'
-      {
-        provider: self.class.name,
-        hash: head['hash'],
-        orphan: !head['is_main'],
-        next: nxt,
-        previous: head['prev_block'],
-        txns: txs[0]['txs'].map do |t|
-          {
-            hash: t['self_hash'],
-            outputs: t['outputs'].map do |o|
-              {
-                address: o['receiver'],
-                value: o['value'] * 100_000_000
-              }
-            end
-          }
-        end
-      }
-    end
+  # This method should fetch a Blockchain block and return as a hash. Raises
+  # an exception if the block is not found.
+  def block(hash)
+    head = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://api-r.bitcoinchain.com/v1/block').append(hash)
+    )[0]
+    raise Sibit::Error, "The block #{hash} is not found" if head.nil?
+    txs = Sibit::Json.new(http: @http, log: @log).get(
+      Iri.new('https://api-r.bitcoinchain.com/v1/block/txs').append(hash)
+    )
+    nxt = head['next_block']
+    nxt = nil if nxt == '0000000000000000000000000000000000000000000000000000000000000000'
+    {
+      provider: self.class.name,
+      hash: head['hash'],
+      orphan: !head['is_main'],
+      next: nxt,
+      previous: head['prev_block'],
+      txns: txs[0]['txs'].map do |t|
+        {
+          hash: t['self_hash'],
+          outputs: t['outputs'].map do |o|
+            {
+              address: o['receiver'],
+              value: o['value'] * 100_000_000
+            }
+          end
+        }
+      end
+    }
   end
 end