sibit 0.33.0 → 0.34.1

data/lib/sibit/btc.rb

@@ -28,22 +28,18 @@ class Sibit::Btc
 
   # Current price of BTC in USD (float returned).
   def price(_currency = 'USD')
-    raise Sibit::NotSupportedError, 'Btc.com API doesn\'t provide prices'
+    raise(Sibit::NotSupportedError, 'Btc.com API doesn\'t provide prices')
   end
 
   # Gets the balance of the address, in satoshi.
   def balance(address)
-    uri = Iri.new('https://chain.api.btc.com/v3/address').append(address).append('unspent')
-    json = Sibit::Json.new(http: @http, log: @log).get(uri)
+    json = Sibit::Json.new(http: @http, log: @log).get(Iri.new('https://chain.api.btc.com/v3/address').append(address).append('unspent'))
     if json['err_no'] == 1
       @log.debug("The balance of #{address} is zero (not found)")
       return 0
     end
     data = json['data']
-    if data.nil?
-      @log.debug("The balance of #{address} is probably zero (not found)")
-      return 0
-    end
+    raise(Sibit::Error, "The address #{address} not found") if data.nil?
     txns = data['list']
     if txns.nil?
       @log.debug("The balance of #{address} is probably zero (not found)")
@@ -56,11 +52,10 @@ class Sibit::Btc
 
   # Get hash of the block after this one, or NIL if it's the last one in Blockchain.
   def next_of(hash)
-    head = Sibit::Json.new(http: @http, log: @log).get(
+    data = Sibit::Json.new(http: @http, log: @log).get(
       Iri.new('https://chain.api.btc.com/v3/block').append(hash)
-    )
-    data = head['data']
-    raise Sibit::Error, "The block #{hash} not found" if data.nil?
+    )['data']
+    raise(Sibit::Error, "The block #{hash} not found") if data.nil?
     nxt = data['next_block_hash']
     nxt = nil if nxt == '0000000000000000000000000000000000000000000000000000000000000000'
     @log.debug("In BTC.com the block #{hash} is the latest, there is no next block") if nxt.nil?
@@ -70,28 +65,25 @@ class Sibit::Btc
 
   # The height of the block.
   def height(hash)
-    json = Sibit::Json.new(http: @http, log: @log).get(
+    data = Sibit::Json.new(http: @http, log: @log).get(
       Iri.new('https://chain.api.btc.com/v3/block').append(hash)
-    )
-    data = json['data']
-    raise Sibit::Error, "The block #{hash} not found" if data.nil?
+    )['data']
+    raise(Sibit::Error, "The block #{hash} not found") if data.nil?
     h = data['height']
-    raise Sibit::Error, "The block #{hash} found but the height is absent" if h.nil?
+    raise(Sibit::Error, "The block #{hash} found but the height is absent") if h.nil?
     @log.debug("The height of #{hash} is #{h}")
     h
   end
 
   # Get recommended fees, in satoshi per byte.
   def fees
-    raise Sibit::NotSupportedError, 'Btc.com doesn\'t provide recommended fees'
+    raise(Sibit::NotSupportedError, 'Btc.com doesn\'t provide recommended fees')
   end
 
   # Gets the hash of the latest block.
   def latest
-    uri = Iri.new('https://chain.api.btc.com/v3/block/latest')
-    json = Sibit::Json.new(http: @http, log: @log).get(uri)
-    data = json['data']
-    raise Sibit::Error, 'The latest block not found' if data.nil?
+    data = Sibit::Json.new(http: @http, log: @log).get(Iri.new('https://chain.api.btc.com/v3/block/latest'))['data']
+    raise(Sibit::Error, 'The latest block not found') if data.nil?
     hash = data['hash']
     @log.debug("The hash of the latest block is #{hash}")
     hash
@@ -99,46 +91,44 @@ class Sibit::Btc
 
   # Fetch all unspent outputs per address.
   def utxos(sources)
-    txns = []
+    results = []
     sources.each do |hash|
-      json = Sibit::Json.new(http: @http, log: @log).get(
+      data = Sibit::Json.new(http: @http, log: @log).get(
         Iri.new('https://chain.api.btc.com/v3/address').append(hash).append('unspent')
-      )
-      data = json['data']
-      raise Sibit::Error, "The address #{hash} not found" if data.nil?
-      txns = data['list']
-      next if txns.nil?
-      txns.each do |u|
-        outs = Sibit::Json.new(http: @http, log: @log).get(
+      )['data']
+      raise(Sibit::Error, "The address #{hash} not found") if data.nil?
+      list = data['list']
+      next if list.nil?
+      list.each do |u|
+        index = u['tx_output_n']
+        raise(Sibit::Error, "The unspent output of #{hash} has no tx_output_n") if index.nil?
+        out = Sibit::Json.new(http: @http, log: @log).get(
           Iri.new('https://chain.api.btc.com/v3/tx').append(u['tx_hash']).add(verbose: 3)
-        )['data']['outputs']
-        outs.each_with_index do |o, i|
-          next unless o['addresses'].include?(hash)
-          txns << {
-            value: o['value'],
-            hash: u['tx_hash'],
-            index: i,
-            confirmations: u['confirmations'],
-            script: [o['script_hex']].pack('H*')
-          }
-        end
+        )['data']['outputs'][index]
+        raise(Sibit::Error, "The output #{index} of #{u['tx_hash']} is absent") if out.nil?
+        results << {
+          value: u['value'],
+          hash: u['tx_hash'],
+          index: index,
+          confirmations: u['confirmations'],
+          script: [out['script_hex']].pack('H*')
+        }
       end
     end
-    txns
+    results
   end
 
   # Push this transaction (in hex format) to the network.
   def push(_hex)
-    raise Sibit::NotSupportedError, 'Btc.com doesn\'t provide payment gateway'
+    raise(Sibit::NotSupportedError, 'Btc.com doesn\'t provide payment gateway')
   end
 
   # This method should fetch a Blockchain block and return as a hash.
   def block(hash)
-    head = Sibit::Json.new(http: @http, log: @log).get(
+    data = Sibit::Json.new(http: @http, log: @log).get(
       Iri.new('https://chain.api.btc.com/v3/block').append(hash)
-    )
-    data = head['data']
-    raise Sibit::Error, "The block #{hash} not found" if data.nil?
+    )['data']
+    raise(Sibit::Error, "The block #{hash} not found") if data.nil?
     nxt = data['next_block_hash']
     nxt = nil if nxt == '0000000000000000000000000000000000000000000000000000000000000000'
     {
@@ -162,20 +152,21 @@ class Sibit::Btc
         Iri.new('https://chain.api.btc.com/v3/block')
           .append(hash).append('tx').add(page: page, pagesize: psize)
       )['data']
-      raise Sibit::Error, "The block #{hash} has no data at page #{page}" if data.nil?
+      raise(Sibit::Error, "The block #{hash} has no data at page #{page}") if data.nil?
       list = data['list']
-      raise Sibit::Error, "The list is empty for block #{hash} at page #{page}" if list.nil?
-      txns = list.map do |t|
-        {
-          hash: t['hash'],
-          outputs: t['outputs'].reject { |o| o['spent_by_tx'] }.map do |o|
-            {
-              address: o['addresses'][0],
-              value: o['value']
-            }
-          end
-        }
-      end
+      raise(Sibit::Error, "The list is empty for block #{hash} at page #{page}") if list.nil?
+      txns =
+        list.map do |t|
+          {
+            hash: t['hash'],
+            outputs: t['outputs'].reject { |o| o['spent_by_tx'] }.map do |o|
+              {
+                address: o['addresses'][0],
+                value: o['value']
+              }
+            end
+          }
+        end
       all += txns
       page += 1
       break if txns.length < psize

data/lib/sibit/cex.rb

@@ -25,51 +25,52 @@ class Sibit::Cex
 
   # Current price of BTC in USD (float returned).
   def price(currency = 'USD')
-    json = Sibit::Json.new(http: @http, log: @log).get(
-      Iri.new('https://cex.io/api/last_price/BTC').append(currency)
+    p = Float(
+      Sibit::Json.new(http: @http, log: @log).get(
+        Iri.new('https://cex.io/api/last_price/BTC').append(currency)
+      )['lprice']
     )
-    p = json['lprice'].to_f
     @log.debug("The price of BTC is #{p} #{currency}")
     p
   end
 
   # Get hash of the block after this one.
   def next_of(_hash)
-    raise Sibit::NotSupportedError, 'Cex.io API doesn\'t provide next_of()'
+    raise(Sibit::NotSupportedError, 'Cex.io API doesn\'t provide next_of()')
   end
 
   # Gets the balance of the address, in satoshi.
   def balance(_address)
-    raise Sibit::NotSupportedError, 'Cex.io doesn\'t implement balance()'
+    raise(Sibit::NotSupportedError, 'Cex.io doesn\'t implement balance()')
   end
 
   # The height of the block.
   def height(_hash)
-    raise Sibit::NotSupportedError, 'Cex.io doesn\'t implement height()'
+    raise(Sibit::NotSupportedError, 'Cex.io doesn\'t implement height()')
   end
 
   # Get recommended fees, in satoshi per byte.
   def fees
-    raise Sibit::NotSupportedError, 'Cex.io doesn\'t implement fees()'
+    raise(Sibit::NotSupportedError, 'Cex.io doesn\'t implement fees()')
   end
 
   # Gets the hash of the latest block.
   def latest
-    raise Sibit::NotSupportedError, 'Cex.io doesn\'t implement latest()'
+    raise(Sibit::NotSupportedError, 'Cex.io doesn\'t implement latest()')
   end
 
   # Fetch all unspent outputs per address.
   def utxos(_sources)
-    raise Sibit::NotSupportedError, 'Cex.io doesn\'t implement utxos()'
+    raise(Sibit::NotSupportedError, 'Cex.io doesn\'t implement utxos()')
   end
 
   # Push this transaction (in hex format) to the network.
   def push(_hex)
-    raise Sibit::NotSupportedError, 'Cex.io doesn\'t implement push()'
+    raise(Sibit::NotSupportedError, 'Cex.io doesn\'t implement push()')
   end
 
   # This method should fetch a Blockchain block and return as a hash.
   def block(_hash)
-    raise Sibit::NotSupportedError, 'Cex.io doesn\'t implement block()'
+    raise(Sibit::NotSupportedError, 'Cex.io doesn\'t implement block()')
   end
 end

data/lib/sibit/coins.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+require 'bigdecimal'
+require_relative 'error'
+
+# Sibit main class.
+class Sibit
+  # An amount of bitcoins, convertible to an exact number of satoshi.
+  #
+  # It parses the amount through +BigDecimal+ instead of a binary +Float+,
+  # so decimal values like 0.29 map to exactly 29,000,000 satoshi. An amount
+  # with sub-satoshi precision is rejected instead of being truncated.
+  #
+  # Author:: Yegor Bugayenko (yegor256@gmail.com)
+  # Copyright:: Copyright (c) 2019-2026 Yegor Bugayenko
+  # License:: MIT
+  class Coins
+    def initialize(btc)
+      @btc = btc
+    end
+
+    def satoshi
+      sat = BigDecimal(@btc.to_s) * 100_000_000
+      unless sat.frac.zero?
+        raise(Sibit::Error, "The amount #{@btc.inspect} is finer than one satoshi")
+      end
+      Integer(sat)
+    rescue ArgumentError, TypeError
+      raise(Sibit::Error, "The amount #{@btc.inspect} is not a valid number of bitcoins")
+    end
+  end
+end

data/lib/sibit/cryptoapis.rb

@@ -7,6 +7,7 @@ require 'iri'
 require 'json'
 require 'loog'
 require 'uri'
+require_relative 'coins'
 require_relative 'error'
 require_relative 'http'
 require_relative 'json'
@@ -27,15 +28,18 @@ class Sibit::Cryptoapis
 
   # Current price of BTC in USD (float returned).
   def price(_currency = 'USD')
-    raise Sibit::NotSupportedError, 'Cryptoapis doesn\'t provide BTC price'
+    raise(Sibit::NotSupportedError, 'Cryptoapis doesn\'t provide BTC price')
   end
 
   # Get hash of the block after this one.
   def next_of(hash)
-    nxt = Sibit::Json.new(http: @http, log: @log).get(
+    head = Sibit::Json.new(http: @http, log: @log).get(
       Iri.new('https://api.cryptoapis.io/v1/bc/btc/mainnet/blocks').append(hash),
       headers: headers
-    )['payload']['hash']
+    )['payload']
+    raise(Sibit::Error, "The block #{hash} not found") if head.nil?
+    nxt = head['nextblockhash']
+    nxt = nil if nxt == '0000000000000000000000000000000000000000000000000000000000000000'
     @log.debug("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
@@ -43,29 +47,29 @@ class Sibit::Cryptoapis
 
   # The height of the block.
   def height(hash)
-    json = Sibit::Json.new(http: @http, log: @log).get(
+    h = Sibit::Json.new(http: @http, log: @log).get(
       Iri.new('https://api.cryptoapis.io/v1/bc/btc/mainnet/blocks').append(hash),
       headers: headers
-    )['payload']
-    h = json['height']
+    )['payload']['height']
     @log.debug("The height of #{hash} is #{h}")
     h
   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.cryptoapis.io/v1/bc/btc/mainnet/address').append(address),
-      headers: headers
-    )['payload']
-    b = (json['balance'].to_f * 100_000_000).to_i
+    b = Sibit::Coins.new(
+      Sibit::Json.new(http: @http, log: @log).get(
+        Iri.new('https://api.cryptoapis.io/v1/bc/btc/mainnet/address').append(address),
+        headers: headers
+      )['payload']['balance']
+    ).satoshi
     @log.debug("The balance of #{address} is #{b} satoshi")
     b
   end
 
   # Get recommended fees, in satoshi per byte.
   def fees
-    raise Sibit::NotSupportedError, 'Cryptoapis doesn\'t provide recommended fees'
+    raise(Sibit::NotSupportedError, 'Cryptoapis doesn\'t provide recommended fees')
   end
 
   # Gets the hash of the latest block.
@@ -80,15 +84,15 @@ class Sibit::Cryptoapis
 
   # Fetch all unspent outputs per address.
   def utxos(_sources)
-    raise Sibit::NotSupportedError, 'Not implemented yet'
+    raise(Sibit::NotSupportedError, 'Not implemented yet')
   end
 
   # Push this transaction (in hex format) to the network.
   def push(hex)
     Sibit::Json.new(http: @http, log: @log).post(
-      Iri.new('https://api.cryptoapis.io/v1/bc/btc/testnet/txs/send'),
+      Iri.new('https://api.cryptoapis.io/v1/bc/btc/mainnet/txs/send'),
       JSON.pretty_generate(hex: hex),
-      headers: headers
+      headers: headers.merge('Content-Type' => 'application/json')
     )
   end
 
@@ -122,21 +126,22 @@ class Sibit::Cryptoapis
     limit = 200
     all = []
     loop do
-      txns = Sibit::Json.new(http: @http, log: @log).get(
-        Iri.new('https://api.cryptoapis.io/v1/bc/btc/mainnet/txs/block/')
-          .append(hash).add(index: index, limit: limit),
-        headers: headers
-      )['payload'].map do |t|
-        {
-          hash: t['hash'],
-          outputs: t['txouts'].map do |o|
-            {
-              address: o['addresses'][0],
-              value: o['amount'].to_f * 100_000_000
-            }
-          end
-        }
-      end
+      txns =
+        Sibit::Json.new(http: @http, log: @log).get(
+          Iri.new('https://api.cryptoapis.io/v1/bc/btc/mainnet/txs/block/')
+            .append(hash).add(index: index, limit: limit),
+          headers: headers
+        )['payload'].map do |t|
+          {
+            hash: t['hash'],
+            outputs: t['txouts'].map do |o|
+              {
+                address: o['addresses'][0],
+                value: Sibit::Coins.new(o['amount'] || 0).satoshi
+              }
+            end
+          }
+        end
       all += txns
       index += txns.length
       break if txns.length < limit

data/lib/sibit/firstof.rb

@@ -83,18 +83,18 @@ class Sibit::FirstOf
   private
 
   def first_of(method)
-    return yield @list unless @list.is_a?(Array)
+    return yield(@list) unless @list.is_a?(Array)
     errors = []
     done = false
     result = nil
     @list.each do |api|
       @log.debug("Calling #{api.class.name}##{method}()...")
       begin
-        result = yield api
+        result = yield(api)
         done = true
         break
       rescue Sibit::NotSupportedError
-        # Just ignore it
+        nil
       rescue Sibit::Error => e
         errors << e
         @log.debug("The API #{api.class.name} failed at #{method}(): #{e.message}") if @verbose
@@ -102,8 +102,11 @@ class Sibit::FirstOf
     end
     unless done
       errors.each { |e| @log.debug(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(', ')}"
+      raise(
+        Sibit::Error,
+        "No APIs out of #{@list.length} managed to succeed at #{method}(): " \
+        "#{@list.map { |a| a.class.name }.join(', ')}"
+      )
     end
     result
   end

data/lib/sibit/httpproxy.rb

@@ -22,7 +22,7 @@ class Sibit
     attr_reader :host
 
     def client(uri)
-      http = Net::HTTP.new(uri.host, uri.port, @host, @port.to_i, @user, @password)
+      http = Net::HTTP.new(uri.host, uri.port, @host, Integer(@port, 10), @user, @password)
       http.use_ssl = true
       http.read_timeout = 240
       http

data/lib/sibit/json.rb

@@ -3,7 +3,6 @@
 # SPDX-FileCopyrightText: Copyright (c) 2019-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-require 'cgi'
 require 'elapsed'
 require 'json'
 require 'loog'
@@ -43,16 +42,16 @@ class Sibit::Json
           'Accept-Encoding' => ''
         }.merge(headers)
       )
-      unless accept.include?(res.code.to_i)
-        raise Sibit::Error, "Failed to retrieve #{uri} (#{res.code}): #{res.body}"
+      unless accept.include?(Integer(res.code, 10))
+        raise(Sibit::Error, "Failed to retrieve #{uri} (#{res.code}): #{res.body}")
       end
       ret =
         begin
           JSON.parse(res.body)
         rescue JSON::ParserError => e
-          raise Sibit::Error, "Can't parse JSON: #{e.message}"
+          raise(Sibit::Error, "Can't parse JSON: #{e.message}")
         end
-      throw :"GET #{uri}: #{res.code}/#{length(res.body.length)}"
+      throw(:"GET #{uri}: #{res.code}/#{length(res.body.length)}")
     end
     ret
   end
@@ -61,8 +60,8 @@ class Sibit::Json
     uri = URI(address.to_s)
     elapsed(@log) do
       res = @http.client(uri).post(
-        "#{uri.path}?#{uri.query}",
-        "tx=#{CGI.escape(body)}",
+        "#{uri.path.empty? ? '/' : uri.path}#{"?#{uri.query}" if uri.query}",
+        body,
         {
           'Accept' => 'text/plain',
           'User-Agent' => user_agent,
@@ -72,9 +71,9 @@ class Sibit::Json
         }.merge(headers)
       )
       unless res.code == '200'
-        raise Sibit::Error, "Failed to post tx to #{uri}: #{res.code}\n#{res.body}"
+        raise(Sibit::Error, "Failed to post tx to #{uri}: #{res.code}\n#{res.body}")
       end
-      throw :"POST #{uri}: #{res.code}"
+      throw(:"POST #{uri}: #{res.code}")
     end
   end
 

data/lib/sibit/key.rb

@@ -32,13 +32,14 @@ class Sibit
     def self.generate(network: :mainnet)
       key = OpenSSL::PKey::EC.generate('secp256k1')
       pvt = key.private_key
-      raise 'Invalid private key: zero' if pvt.zero?
-      raise 'Invalid private key: out of range' if pvt >= SECP256K1_N
-      raise 'Invalid public key: not on curve' unless key.public_key.on_curve?
+      raise(Sibit::Error, 'Invalid private key: zero') if pvt.zero?
+      raise(Sibit::Error, 'Invalid private key: out of range') if pvt >= SECP256K1_N
+      raise(Sibit::Error, 'Invalid public key: not on curve') unless key.public_key.on_curve?
       hex = key.private_key.to_s(16).rjust(64, '0').downcase
-      raise 'Invalid private key encoding' unless hex.match?(/\A[0-9a-f]{64}\z/)
-      trip = OpenSSL::BN.new(hex, 16)
-      raise 'Private key serialization is lossy' unless trip == pvt
+      raise(Sibit::Error, 'Invalid private key encoding') unless hex.match?(/\A[0-9a-f]{64}\z/)
+      unless OpenSSL::BN.new(hex, 16) == pvt
+        raise(Sibit::Error, 'Private key serialization is lossy')
+      end
       new(hex, network: network)
     end
 
@@ -55,42 +56,38 @@ class Sibit
     end
 
     def pub
-      point = @key.public_key
-      point.to_octet_string(@compressed ? :compressed : :uncompressed).unpack1('H*')
+      @key.public_key.to_octet_string(@compressed ? :compressed : :uncompressed).unpack1('H*')
     end
 
     def bech32
       hrp = { mainnet: 'bc', testnet: 'tb', regtest: 'bcrt' }[@network]
       hex = pub
-      raise Error, 'Invalid public key: not on curve' unless @key.public_key.on_curve?
-      raise Error, 'Invalid public key format' unless hex.match?(/\A0[23][0-9a-f]{64}\z/)
+      raise(Error, 'Invalid public key: not on curve') unless @key.public_key.on_curve?
+      raise(Error, 'Invalid public key format') unless hex.match?(/\A0[23][0-9a-f]{64}\z/)
       addr = Bech32.encode(hrp, 0, hash160(hex))
-      expected = /\A#{hrp}1q[a-z0-9]{38,58}\z/
-      raise Error, "Invalid bech32 address: #{addr}" unless addr.match?(expected)
+      unless addr.match?(/\A#{hrp}1q[a-z0-9]{38,58}\z/)
+        raise(Error, "Invalid bech32 address: #{addr}")
+      end
       addr
     end
 
     def base58
       hex = pub
-      raise Error, 'Invalid public key: not on curve' unless @key.public_key.on_curve?
-      raise Error, 'Invalid public key format' unless hex.match?(/\A0[23][0-9a-f]{64}\z/)
-      hash = hash160(hex)
-      prefix = @network == :mainnet ? '00' : '6f'
-      versioned = "#{prefix}#{hash}"
-      checksum = Base58.new(versioned).check
-      addr = Base58.new(versioned + checksum).encode
+      raise(Error, 'Invalid public key: not on curve') unless @key.public_key.on_curve?
+      raise(Error, 'Invalid public key format') unless hex.match?(/\A0[23][0-9a-f]{64}\z/)
+      versioned = "#{@network == :mainnet ? '00' : '6f'}#{hash160(hex)}"
+      addr = Base58.new(versioned + Base58.new(versioned).check).encode
       mainnet = /\A1[1-9A-HJ-NP-Za-km-z]{25,34}\z/
       testnet = /\A[mn][1-9A-HJ-NP-Za-km-z]{25,34}\z/
       unless addr.match?(@network == :mainnet ? mainnet : testnet)
-        raise Error,
-              "Invalid base58 address: #{addr}"
+        raise(Error, "Invalid base58 address: #{addr}")
       end
       addr
     end
 
     def sign(data)
       sig = @key.dsa_sign_asn1(data)
-      raise Error, 'Signature verification failed' unless verify(data, sig)
+      raise(Error, 'Signature verification failed') unless verify(data, sig)
       sig
     end
 
@@ -103,25 +100,29 @@ class Sibit
     private
 
     def build(privkey)
-      value = privkey.to_i(16)
-      raise Error, 'Private key is not on curve' unless value.between?(MIN_PRIV, MAX_PRIV)
-      group = OpenSSL::PKey::EC::Group.new('secp256k1')
+      raise(Error, 'Private key is not on curve') unless privkey.to_i(16).between?(
+        MIN_PRIV,
+        MAX_PRIV
+      )
       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(
+        OpenSSL::ASN1::Sequence(
+          [
+            OpenSSL::ASN1::Integer.new(1),
+            OpenSSL::ASN1::OctetString(bn.to_s(2)),
+            OpenSSL::ASN1::ObjectId('secp256k1', 0, :EXPLICIT),
+            OpenSSL::ASN1::BitString(
+              OpenSSL::PKey::EC::Group.new('secp256k1').generator.mul(bn)
+                .to_octet_string(:uncompressed),
+              1, :EXPLICIT
+            )
+          ]
+        ).to_der
       )
-      OpenSSL::PKey::EC.new(asn1.to_der)
     end
 
     def hash160(hex)
-      bytes = [hex].pack('H*')
-      Digest::RMD160.hexdigest(Digest::SHA256.digest(bytes))
+      Digest::RMD160.hexdigest(Digest::SHA256.digest([hex].pack('H*')))
     end
 
     def decode(key)
@@ -130,12 +131,9 @@ class Sibit
         return key.downcase
       end
       raw = Base58.new(key).decode
-      payload = raw[0..-9]
-      checksum = raw[-8..]
-      expected = Base58.new(payload).check
-      raise Error, 'Invalid WIF checksum' unless checksum == expected
+      raise(Error, 'Invalid WIF checksum') unless raw[-8..] == Base58.new(raw[0..-9]).check
       version = raw[0, 2]
-      raise Error, "Invalid WIF version: #{version}" unless %w[80 ef].include?(version)
+      raise(Error, "Invalid WIF version: #{version}") unless %w[80 ef].include?(version)
       detected = version == '80' ? :mainnet : :testnet
       @network = @override || detected
       body = raw[2..-9]

data/lib/sibit/script.rb

@@ -59,17 +59,14 @@ class Sibit
     def p2pkh_address(network)
       h = hash160
       return nil unless h
-      prefix = network == :mainnet ? '00' : '6f'
-      versioned = "#{prefix}#{h}"
-      checksum = Base58.new(versioned).check
-      Base58.new(versioned + checksum).encode
+      versioned = "#{network == :mainnet ? '00' : '6f'}#{h}"
+      Base58.new(versioned + Base58.new(versioned).check).encode
     end
 
     def p2wpkh_address(network)
       h = hash160
       return nil unless h
-      hrp = { mainnet: 'bc', testnet: 'tb', regtest: 'bcrt' }[network]
-      Bech32.encode(hrp, 0, h)
+      Bech32.encode({ mainnet: 'bc', testnet: 'tb', regtest: 'bcrt' }[network], 0, h)
     end
   end
 end