sibit 0.32.8 → 0.34.0

data/lib/sibit/cryptoapis.rb

@@ -27,7 +27,7 @@ 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.
@@ -43,29 +43,31 @@ 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 = Integer(
+      Float(
+        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']
+      ) * 100_000_000
+    )
     @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,13 +82,13 @@ 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
     )
@@ -122,21 +124,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: Float(o['amount'] || 0) * 100_000_000
+              }
+            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

@@ -43,16 +43,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,7 +61,7 @@ class Sibit::Json
     uri = URI(address.to_s)
     elapsed(@log) do
       res = @http.client(uri).post(
-        "#{uri.path}?#{uri.query}",
+        "#{uri.path.empty? ? '/' : uri.path}#{"?#{uri.query}" if uri.query}",
         "tx=#{CGI.escape(body)}",
         {
           'Accept' => 'text/plain',
@@ -72,9 +72,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

data/lib/sibit/sochain.rb

@@ -0,0 +1,177 @@
+# 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']
+      next if data.nil?
+      txs = data['txs']
+      next 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|
+        {
+          hash: t['txid'] || t,
+          outputs: ((t.is_a?(Hash) ? t['outputs'] : nil) || []).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'
 
@@ -105,7 +106,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 +121,25 @@ class Sibit
 
       private
 
+      def version
+        Base58.new(@address).decode[0, 2]
+      end
+
+      def hash160
+        [Base58.new(@address).decode[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*')
+        witness = Bech32.new(@address).witness
+        [0x00, (witness.length / 2)].pack('C*') + [witness].pack('H*')
       end
     end
 
@@ -140,12 +151,10 @@ class Sibit
 
     def sign_inputs
       @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
@@ -153,9 +162,9 @@ class Sibit
     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 +184,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)