sibit 0.28.0 → 0.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7846df06f5fbb2cae2ee00122f75f640901fc2d2d5321d810ae0848ee56c01e2
-  data.tar.gz: 1ff75f919747d146c038c8cdfcc2cefbbd5dbf45136a5102691740ab7224dbd2
+  metadata.gz: ddde20b613a744a0618b9b91d4adfea42d945a13d778ecad2492b1a15afe3c0e
+  data.tar.gz: 7d83be599123ff738035fbf610d1ae6f763c5c36cec2a83a626658707cf37cda
 SHA512:
-  metadata.gz: 892d1c222af88708788f791a8508c7622f3e148190c7aa2cf4a8c6fbb3a47fdd2dd78ebd0190512fb11c0a512ac4d474153c2467bf54a4cb4f7afa260d732b1f
-  data.tar.gz: b9d78f193a4e81d5c9659528927c6526f6d2413f65303bd016b6fdd220c0afac25c0555f05ddeaf34ab5e0d9fd257ba8d0f5f70b31667eeb1ebc549cab232bc6
+  metadata.gz: 9811599df9ebb242927bcf50a8ed2b1e24adad74832b72748b1f1c113c9f30e89c0b9079f3a0898308963c55c59d0f899534d529d673f0120a718176402a4e10
+  data.tar.gz: 2f3821bb817a4fadbe8137ccce649d66ba388ae17f0a3b99f6293947e0d3ef084d2d0f1501fabcbec8d933b7127d655a1fae74bdb907019ae39e088d4bd6bf52

data/Gemfile.lock

@@ -72,6 +72,7 @@ GEM
       logger (~> 1.0)
     memoist3 (1.0.0)
     mini_mime (1.1.5)
+    mini_portile2 (2.8.9)
     minitest (6.0.1)
       prism (~> 1.5)
     minitest-reporters (1.7.1)
@@ -80,9 +81,8 @@ GEM
       minitest (>= 5.0)
       ruby-progressbar
     multi_test (1.1.0)
-    nokogiri (1.18.10-arm64-darwin)
-      racc (~> 1.4)
-    nokogiri (1.18.10-x86_64-linux-gnu)
+    nokogiri (1.18.10)
+      mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
     openssl (4.0.0)
     parallel (1.27.0)

data/README.md

@@ -7,15 +7,13 @@
 [![rake](https://github.com/yegor256/sibit/actions/workflows/rake.yml/badge.svg)](https://github.com/yegor256/sibit/actions/workflows/rake.yml)
 [![PDD status](https://www.0pdd.com/svg?name=yegor256/sibit)](https://www.0pdd.com/p?name=yegor256/sibit)
 [![Gem Version](https://badge.fury.io/rb/sibit.svg)](https://badge.fury.io/rb/sibit)
-[![Maintainability](https://api.codeclimate.com/v1/badges/74c909f06d4afa0d8001/maintainability)](https://codeclimate.com/github/yegor256/sibit/maintainability)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/yegor256/takes/sibit/master/LICENSE.txt)
 [![Test Coverage](https://img.shields.io/codecov/c/github/yegor256/sibit.svg)](https://codecov.io/github/yegor256/sibit?branch=master)
 [![Hits-of-Code](https://hitsofcode.com/github/yegor256/sibit)](https://hitsofcode.com/view/github/yegor256/sibit)
 
-To understand how the Bitcoin protocol works,
-I recommend you watching this [short video] and
-then reading this blog post of mine:
-[_Sibit Demonstrates How Bitcoin Works_][blog].
+To understand how the Bitcoin protocol works, I recommend you watching
+  this [short video] and then reading this blog post of mine:
+  [_Sibit Demonstrates How Bitcoin Works_][blog].
 
 This is a simple Bitcoin client for use from the command line
   or from your Ruby app.
@@ -26,10 +24,10 @@ If you need something more complex, I would recommend using
   [bitcoin-ruby] for Ruby and [Electrum] as a GUI client.
 
 You may want to discuss this tool at [Bitcointalk]
-and give the thread a few merits.
+  and give the thread a few merits.
 
 This is a Ruby gem, install it first (if it doesn't work, there are
-some hints at the bottom of this page):
+  some hints at the bottom of this page):
 
 ```bash
 gem install sibit
@@ -82,18 +80,16 @@ Say, you are sending 0.5 BTC and the fee is 0.0001 BTC.
 Totally, you spend 0.5001.
 However, you can make Sibit deduct the fee from the payment amount.
 In this case you should provide a negative amount
-  of the fee or one of `-S`, `-M`, `-L`, `-XL`.
-You can also say `+S`, if you want the opposite, which is the default.
+  of the fee or one of `S-`, `M-`, `L-`, `XL-`.
+You can also say `S+`, if you want the opposite, which is the default.
 
 It is recommended to run it with `--dry --verbose` options first,
   to see what's going to be sent to the network.
 If everything looks correct, remove the `--dry` and run again,
   the transaction is pushed to the network.
 
-All operations are performed through the
-[Blockchain API].
-Transactions are pushed to the Bitcoin network via
-[this relay].
+All operations are performed through the [Blockchain API].
+Transactions are pushed to the Bitcoin network via [this relay].
 
 ## Ruby SDK
 
@@ -115,8 +111,8 @@ It should work.
 ## APIs
 
 The library works through one (or a few) public APIs for fetching
-Bitcoin data and pushing transactions to the network. At the moment we
-work with the following APIs:
+  Bitcoin data and pushing transactions to the network.
+At the moment we work with the following APIs:
 
 * [Blockchain.com] - `Sibit::Blockchain`
 * [BTC.com] - `Sibit::Btc`
@@ -125,8 +121,9 @@ work with the following APIs:
 * [Blockchair.com] - `Sibit::Blockchair`
 * [Cex.io] - `Sibit::Cex`
 
-The first one in this list is used by default. If you want to use a different
-one, you just specify it in the constructor of `Sibit` object:
+The first one in this list is used by default.
+If you want to use a different one,
+  you just specify it in the constructor of `Sibit` object:
 
 ```ruby
 require 'sibit'

data/bin/sibit

@@ -6,10 +6,6 @@
 
 $stdout.sync = true
 
-# see https://stackoverflow.com/a/6048451/187141
-require 'openssl'
-OpenSSL::SSL::VERIFY_PEER ||= OpenSSL::SSL::VERIFY_NONE
-
 require 'backtrace'
 require 'loog'
 require 'retriable_proxy'

data/lib/sibit/bestof.rb

@@ -12,96 +12,93 @@ require_relative 'error'
 # Author:: Yegor Bugayenko (yegor256@gmail.com)
 # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
 # License:: MIT
-class Sibit
-  # Best of API.
-  class BestOf
-    # Constructor.
-    def initialize(list, log: Loog::NULL, verbose: false)
-      @list = list
-      @log = log
-      @verbose = verbose
-    end
+class Sibit::BestOf
+  # Constructor.
+  def initialize(list, log: Loog::NULL, verbose: false)
+    @list = list
+    @log = log
+    @verbose = verbose
+  end
 
-    # Current price of BTC in USD (float returned).
-    def price(currency = 'USD')
-      best_of('price') do |api|
-        api.price(currency)
-      end
+  # Current price of BTC in USD (float returned).
+  def price(currency = 'USD')
+    best_of('price') do |api|
+      api.price(currency)
     end
+  end
 
-    # Gets the balance of the address, in satoshi.
-    def balance(address)
-      best_of('balance') do |api|
-        api.balance(address)
-      end
+  # Gets the balance of the address, in satoshi.
+  def balance(address)
+    best_of('balance') do |api|
+      api.balance(address)
     end
+  end
 
-    # Get the height of the block.
-    def height(hash)
-      best_of('height') do |api|
-        api.height(hash)
-      end
+  # Get the height of the block.
+  def height(hash)
+    best_of('height') do |api|
+      api.height(hash)
     end
+  end
 
-    # Get the hash of the next block.
-    def next_of(hash)
-      best_of('next_of') do |api|
-        api.next_of(hash)
-      end
+  # Get the hash of the next block.
+  def next_of(hash)
+    best_of('next_of') do |api|
+      api.next_of(hash)
     end
+  end
 
-    # Get recommended fees, in satoshi per byte. The method returns
-    # a hash: { S: 12, M: 45, L: 100, XL: 200 }
-    def fees
-      best_of('fees', &:fees)
-    end
+  # Get recommended fees, in satoshi per byte. The method returns
+  # a hash: { S: 12, M: 45, L: 100, XL: 200 }
+  def fees
+    best_of('fees', &:fees)
+  end
 
-    # Fetch all unspent outputs per address.
-    def utxos(keys)
-      best_of('utxos') do |api|
-        api.utxos(keys)
-      end
+  # Fetch all unspent outputs per address.
+  def utxos(keys)
+    best_of('utxos') do |api|
+      api.utxos(keys)
     end
+  end
 
-    # Latest block hash.
-    def latest
-      best_of('latest', &:latest)
-    end
+  # Latest block hash.
+  def latest
+    best_of('latest', &:latest)
+  end
 
-    # Push this transaction (in hex format) to the network.
-    def push(hex)
-      best_of('push') do |api|
-        api.push(hex)
-      end
+  # Push this transaction (in hex format) to the network.
+  def push(hex)
+    best_of('push') do |api|
+      api.push(hex)
     end
+  end
 
-    # This method should fetch a block and return as a hash.
-    def block(hash)
-      best_of('block') do |api|
-        api.block(hash)
-      end
+  # This method should fetch a block and return as a hash.
+  def block(hash)
+    best_of('block') do |api|
+      api.block(hash)
     end
+  end
 
-    private
+  private
 
-    def best_of(method)
-      return yield @list unless @list.is_a?(Array)
-      results = []
-      errors = []
-      @list.each do |api|
-        results << yield(api)
-      rescue Sibit::NotSupportedError
-        # Just ignore it
-      rescue Sibit::Error => e
-        errors << e
-        @log.info("The API #{api.class.name} failed at #{method}(): #{e.message}") if @verbose
-      end
-      if results.empty?
-        errors.each { |e| @log.info(Backtrace.new(e).to_s) }
-        raise Sibit::Error, "No APIs out of #{@list.length} managed to succeed at #{method}(): \
+  def best_of(method)
+    return yield @list unless @list.is_a?(Array)
+    results = []
+    errors = []
+    @list.each do |api|
+      results << yield(api)
+    rescue Sibit::NotSupportedError
+      # Just ignore it
+    rescue Sibit::Error => e
+      errors << e
+      @log.info("The API #{api.class.name} failed at #{method}(): #{e.message}") if @verbose
+    end
+    if results.empty?
+      errors.each { |e| @log.info(Backtrace.new(e).to_s) }
+      raise Sibit::Error, "No APIs out of #{@list.length} managed to succeed at #{method}(): \
 #{@list.map { |a| a.class.name }.join(', ')}"
-      end
-      results.group_by(&:to_s).values.max_by(&:size)[0]
     end
+    results.group_by(&:to_s).values.max_by(&:size)[0]
   end
 end

data/lib/sibit/bitcoin/base58.rb

@@ -5,46 +5,44 @@
 
 require 'digest'
 
-class Sibit
-  # Bitcoin primitives module.
-  #
-  # Pure Ruby implementation of Bitcoin functionality using OpenSSL 3.0+.
-  # Replaces the bitcoin-ruby dependency which is incompatible with OpenSSL 3.0.
-  module Bitcoin
-    MIN_TX_FEE = 10_000
+# Bitcoin primitives module.
+#
+# Pure Ruby implementation of Bitcoin functionality using OpenSSL 3.0+.
+# Replaces the bitcoin-ruby dependency which is incompatible with OpenSSL 3.0.
+module Sibit::Bitcoin
+  MIN_TX_FEE = 10_000
 
-    # Base58 encoding for Bitcoin addresses.
-    #
-    # Author:: Yegor Bugayenko (yegor256@gmail.com)
-    # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
-    # License:: MIT
-    module Base58
-      ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+  # Base58 encoding for Bitcoin addresses.
+  #
+  # Author:: Yegor Bugayenko (yegor256@gmail.com)
+  # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
+  # License:: MIT
+  module Base58
+    ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 
-      def self.encode(hex)
-        bytes = [hex].pack('H*')
-        leading = bytes.match(/^\x00*/)[0].length
-        num = hex.to_i(16)
-        result = ''
-        while num.positive?
-          num, remainder = num.divmod(58)
-          result = ALPHABET[remainder] + result
-        end
-        ('1' * leading) + result
+    def self.encode(hex)
+      bytes = [hex].pack('H*')
+      leading = bytes.match(/^\x00*/)[0].length
+      num = hex.to_i(16)
+      result = ''
+      while num.positive?
+        num, remainder = num.divmod(58)
+        result = ALPHABET[remainder] + result
       end
+      ('1' * leading) + result
+    end
 
-      def self.decode(str)
-        leading = str.match(/^1*/)[0].length
-        num = 0
-        str.each_char { |c| num = (num * 58) + ALPHABET.index(c) }
-        hex = num.zero? ? '' : num.to_s(16)
-        hex = "0#{hex}" if hex.length.odd?
-        ('00' * leading) + hex
-      end
+    def self.decode(str)
+      leading = str.match(/^1*/)[0].length
+      num = 0
+      str.each_char { |c| num = (num * 58) + ALPHABET.index(c) }
+      hex = num.zero? ? '' : num.to_s(16)
+      hex = "0#{hex}" if hex.length.odd?
+      ('00' * leading) + hex
+    end
 
-      def self.check(hex)
-        Digest::SHA256.hexdigest(Digest::SHA256.digest([hex].pack('H*')))[0...8]
-      end
+    def self.check(hex)
+      Digest::SHA256.hexdigest(Digest::SHA256.digest([hex].pack('H*')))[0...8]
     end
   end
 end

data/lib/sibit/bitcoin/key.rb

@@ -3,85 +3,83 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2025 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-require 'openssl'
 require 'digest'
+require 'openssl'
 require_relative 'base58'
 
-class Sibit
-  module Bitcoin
-    # Bitcoin ECDSA key using secp256k1 curve.
-    #
-    # Supports OpenSSL 3.0+ by constructing keys via DER encoding instead
-    # of using deprecated mutable key APIs.
-    #
-    # Author:: Yegor Bugayenko (yegor256@gmail.com)
-    # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
-    # License:: MIT
-    class Key
-      MIN_PRIV = 0x01
-      MAX_PRIV = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140
+module Sibit::Bitcoin
+  # Bitcoin ECDSA key using secp256k1 curve.
+  #
+  # Supports OpenSSL 3.0+ by constructing keys via DER encoding instead
+  # of using deprecated mutable key APIs.
+  #
+  # Author:: Yegor Bugayenko (yegor256@gmail.com)
+  # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
+  # License:: MIT
+  class Key
+    MIN_PRIV = 0x01
+    MAX_PRIV = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140
 
-      def self.generate
-        key = OpenSSL::PKey::EC.generate('secp256k1')
-        pvt = key.private_key.to_s(16).rjust(64, '0').downcase
-        new(pvt)
-      end
+    def self.generate
+      key = OpenSSL::PKey::EC.generate('secp256k1')
+      pvt = key.private_key.to_s(16).rjust(64, '0').downcase
+      new(pvt)
+    end
 
-      def initialize(privkey)
-        @privkey = privkey
-        @compressed = true
-        @key = build(privkey)
-      end
+    def initialize(privkey)
+      @privkey = privkey
+      @compressed = true
+      @key = build(privkey)
+    end
 
-      def priv
-        @privkey
-      end
+    def priv
+      @privkey
+    end
 
-      def pub
-        point = @key.public_key
-        point.to_octet_string(@compressed ? :compressed : :uncompressed).unpack1('H*')
-      end
+    def pub
+      point = @key.public_key
+      point.to_octet_string(@compressed ? :compressed : :uncompressed).unpack1('H*')
+    end
 
-      def addr
-        hash = hash160(pub)
-        versioned = "00#{hash}"
-        checksum = Base58.check(versioned)
-        Base58.encode(versioned + checksum)
-      end
+    def addr
+      hash = hash160(pub)
+      versioned = "00#{hash}"
+      checksum = Base58.check(versioned)
+      Base58.encode(versioned + checksum)
+    end
 
-      def sign(data)
-        @key.sign('SHA256', data)
-      end
+    def sign(data)
+      @key.sign('SHA256', data)
+    end
 
-      def verify(data, sig)
-        @key.verify('SHA256', sig, data)
-      rescue OpenSSL::PKey::PKeyError
-        false
-      end
+    def verify(data, sig)
+      @key.verify('SHA256', sig, data)
+    rescue OpenSSL::PKey::PKeyError
+      false
+    end
 
-      private
+    private
 
-      def build(privkey)
-        value = privkey.to_i(16)
-        raise 'private key is not on curve' unless value.between?(MIN_PRIV, MAX_PRIV)
-        group = OpenSSL::PKey::EC::Group.new('secp256k1')
-        bn = OpenSSL::BN.new(privkey, 16)
-        pubkey = group.generator.mul(bn)
-        asn1 = OpenSSL::ASN1::Sequence(
-          [
-            OpenSSL::ASN1::Integer.new(1),
-            OpenSSL::ASN1::OctetString(bn.to_s(2)),
-            OpenSSL::ASN1::ObjectId('secp256k1', 0, :EXPLICIT),
-            OpenSSL::ASN1::BitString(pubkey.to_octet_string(:uncompressed), 1, :EXPLICIT)
-          ]
-        )
-        OpenSSL::PKey::EC.new(asn1.to_der)
-      end
+    def build(privkey)
+      value = privkey.to_i(16)
+      raise 'private key is not on curve' unless value.between?(MIN_PRIV, MAX_PRIV)
+      group = OpenSSL::PKey::EC::Group.new('secp256k1')
+      bn = OpenSSL::BN.new(privkey, 16)
+      pubkey = group.generator.mul(bn)
+      asn1 = OpenSSL::ASN1::Sequence(
+        [
+          OpenSSL::ASN1::Integer.new(1),
+          OpenSSL::ASN1::OctetString(bn.to_s(2)),
+          OpenSSL::ASN1::ObjectId('secp256k1', 0, :EXPLICIT),
+          OpenSSL::ASN1::BitString(pubkey.to_octet_string(:uncompressed), 1, :EXPLICIT)
+        ]
+      )
+      OpenSSL::PKey::EC.new(asn1.to_der)
+    end
 
-      def hash160(hex)
-        bytes = [hex].pack('H*')
-        Digest::RMD160.hexdigest(Digest::SHA256.digest(bytes))
-      end
+    def hash160(hex)
+      bytes = [hex].pack('H*')
+      Digest::RMD160.hexdigest(Digest::SHA256.digest(bytes))
     end
   end
 end

data/lib/sibit/bitcoin/script.rb

@@ -6,53 +6,51 @@
 require 'digest'
 require_relative 'base58'
 
-class Sibit
-  module Bitcoin
-    # Bitcoin Script parser.
-    #
-    # Parses standard P2PKH scripts to extract addresses.
-    #
-    # Author:: Yegor Bugayenko (yegor256@gmail.com)
-    # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
-    # License:: MIT
-    class Script
-      OP_DUP = 0x76
-      OP_HASH160 = 0xa9
-      OP_EQUALVERIFY = 0x88
-      OP_CHECKSIG = 0xac
-
-      def initialize(hex)
-        @bytes = [hex].pack('H*').bytes
-      end
-
-      def address
-        return p2pkh_address if p2pkh?
-        nil
-      end
-
-      def p2pkh?
-        @bytes.length == 25 &&
-          @bytes[0] == OP_DUP &&
-          @bytes[1] == OP_HASH160 &&
-          @bytes[2] == 20 &&
-          @bytes[23] == OP_EQUALVERIFY &&
-          @bytes[24] == OP_CHECKSIG
-      end
-
-      def hash160
-        return nil unless p2pkh?
-        @bytes[3, 20].pack('C*').unpack1('H*')
-      end
-
-      private
-
-      def p2pkh_address
-        h = hash160
-        return nil unless h
-        versioned = "00#{h}"
-        checksum = Base58.check(versioned)
-        Base58.encode(versioned + checksum)
-      end
+module Sibit::Bitcoin
+  # Bitcoin Script parser.
+  #
+  # Parses standard P2PKH scripts to extract addresses.
+  #
+  # Author:: Yegor Bugayenko (yegor256@gmail.com)
+  # Copyright:: Copyright (c) 2019-2025 Yegor Bugayenko
+  # License:: MIT
+  class Script
+    OP_DUP = 0x76
+    OP_HASH160 = 0xa9
+    OP_EQUALVERIFY = 0x88
+    OP_CHECKSIG = 0xac
+
+    def initialize(hex)
+      @bytes = [hex].pack('H*').bytes
+    end
+
+    def address
+      return p2pkh_address if p2pkh?
+      nil
+    end
+
+    def p2pkh?
+      @bytes.length == 25 &&
+        @bytes[0] == OP_DUP &&
+        @bytes[1] == OP_HASH160 &&
+        @bytes[2] == 20 &&
+        @bytes[23] == OP_EQUALVERIFY &&
+        @bytes[24] == OP_CHECKSIG
+    end
+
+    def hash160
+      return nil unless p2pkh?
+      @bytes[3, 20].pack('C*').unpack1('H*')
+    end
+
+    private
+
+    def p2pkh_address
+      h = hash160
+      return nil unless h
+      versioned = "00#{h}"
+      checksum = Base58.check(versioned)
+      Base58.encode(versioned + checksum)
     end
   end
 end