tapyrus 0.2.6 → 0.2.10

data/lib/tapyrus/slip39/sss.rb

@@ -2,10 +2,8 @@ require 'securerandom'
 
 module Tapyrus
   module SLIP39
-
     # Shamir's Secret Sharing
     class SSS
-
       include Tapyrus::Util
       extend Tapyrus::Util
 
@@ -37,39 +35,56 @@ module Tapyrus
         raise ArgumentError, 'Groups is empty.' if groups.empty?
         raise ArgumentError, 'Group threshold must be greater than 0.' if group_threshold.nil? || group_threshold < 1
         raise ArgumentError, 'Master secret does not specified.' unless secret
-        raise ArgumentError, "The length of the master secret (#{secret.htb.bytesize} bytes) must be at least #{MIN_STRENGTH_BITS / 8} bytes." if (secret.htb.bytesize * 8) < MIN_STRENGTH_BITS
-        raise ArgumentError, 'The length of the master secret in bytes must be an even number.' unless secret.bytesize.even?
-        raise ArgumentError, 'The passphrase must contain only printable ASCII characters (code points 32-126).' unless passphrase.ascii_only?
-        raise ArgumentError, "The requested group threshold (#{group_threshold}) must not exceed the number of groups (#{groups.length})." if group_threshold > groups.length
+        if (secret.htb.bytesize * 8) < MIN_STRENGTH_BITS
+          raise ArgumentError,
+                "The length of the master secret (#{secret.htb.bytesize} bytes) must be at least #{MIN_STRENGTH_BITS / 8} bytes."
+        end
+        unless secret.bytesize.even?
+          raise ArgumentError, 'The length of the master secret in bytes must be an even number.'
+        end
+        unless passphrase.ascii_only?
+          raise ArgumentError, 'The passphrase must contain only printable ASCII characters (code points 32-126).'
+        end
+        if group_threshold > groups.length
+          raise ArgumentError,
+                "The requested group threshold (#{group_threshold}) must not exceed the number of groups (#{groups.length})."
+        end
         groups.each do |threshold, count|
           raise ArgumentError, 'Group threshold must be greater than 0.' if threshold.nil? || threshold < 1
-          raise ArgumentError, "The requested member threshold (#{threshold}) must not exceed the number of share (#{count})." if threshold > count
-          raise ArgumentError, "Creating multiple member shares with member threshold 1 is not allowed. Use 1-of-1 member sharing instead." if threshold == 1 && count > 1
+          if threshold > count
+            raise ArgumentError,
+                  "The requested member threshold (#{threshold}) must not exceed the number of share (#{count})."
+          end
+          if threshold == 1 && count > 1
+            raise ArgumentError,
+                  'Creating multiple member shares with member threshold 1 is not allowed. Use 1-of-1 member sharing instead.'
+          end
         end
 
-        id = SecureRandom.random_number(32767) # 32767 is max number for 15 bits.
+        id = SecureRandom.random_number(32_767) # 32767 is max number for 15 bits.
         ems = encrypt(secret, passphrase, exp, id)
 
         group_shares = split_secret(group_threshold, groups.length, ems)
 
-        shares = group_shares.map.with_index do |s, i|
-          group_index, group_share = s[0], s[1]
-          member_threshold, member_count = groups[i][0], groups[i][1]
-          shares = split_secret(member_threshold, member_count, group_share)
-          shares.map do |member_index, member_share|
-            share = Tapyrus::SLIP39::Share.new
-            share.id = id
-            share.iteration_exp = exp
-            share.group_index = group_index
-            share.group_threshold = group_threshold
-            share.group_count = groups.length
-            share.member_index = member_index
-            share.member_threshold = member_threshold
-            share.value = member_share
-            share.checksum = share.calculate_checksum
-            share
+        shares =
+          group_shares.map.with_index do |s, i|
+            group_index, group_share = s[0], s[1]
+            member_threshold, member_count = groups[i][0], groups[i][1]
+            shares = split_secret(member_threshold, member_count, group_share)
+            shares.map do |member_index, member_share|
+              share = Tapyrus::SLIP39::Share.new
+              share.id = id
+              share.iteration_exp = exp
+              share.group_index = group_index
+              share.group_threshold = group_threshold
+              share.group_count = groups.length
+              share.member_index = member_index
+              share.member_threshold = member_threshold
+              share.value = member_share
+              share.checksum = share.calculate_checksum
+              share
+            end
           end
-        end
         shares
       end
 
@@ -92,9 +107,15 @@ module Tapyrus
 
         shares.each do |share|
           raise ArgumentError, 'Invalid set of shares. All shares must have the same id.' unless id == share.id
-          raise ArgumentError, 'Invalid set of shares. All shares must have the same group threshold.' unless group_threshold == share.group_threshold
-          raise ArgumentError, 'Invalid set of shares. All shares must have the same group count.' unless group_count == share.group_count
-          raise ArgumentError, 'Invalid set of shares. All Shares must have the same iteration exponent.' unless exp == share.iteration_exp
+          unless group_threshold == share.group_threshold
+            raise ArgumentError, 'Invalid set of shares. All shares must have the same group threshold.'
+          end
+          unless group_count == share.group_count
+            raise ArgumentError, 'Invalid set of shares. All shares must have the same group count.'
+          end
+          unless exp == share.iteration_exp
+            raise ArgumentError, 'Invalid set of shares. All Shares must have the same iteration exponent.'
+          end
           groups[share.group_index] ||= []
           groups[share.group_index] << share
         end
@@ -102,20 +123,29 @@ module Tapyrus
         group_shares = {}
         groups.each do |group_index, shares|
           member_threshold = shares.first.member_threshold
-          raise ArgumentError, "Wrong number of mnemonics. Threshold is #{member_threshold}, but share count is #{shares.length}" if shares.length < member_threshold
+          if shares.length < member_threshold
+            raise ArgumentError,
+                  "Wrong number of mnemonics. Threshold is #{member_threshold}, but share count is #{shares.length}"
+          end
           if shares.length == 1 && member_threshold == 1
             group_shares[group_index] = shares.first.value
           else
             value_length = shares.first.value.length
             x_coordinates = []
             shares.each do |share|
-              raise ArgumentError, 'Invalid set of shares. All shares in a group must have the same member threshold.' unless member_threshold == share.member_threshold
-              raise ArgumentError, 'Invalid set of shares. All share values must have the same length.' unless value_length == share.value.length
+              unless member_threshold == share.member_threshold
+                raise ArgumentError, 'Invalid set of shares. All shares in a group must have the same member threshold.'
+              end
+              unless value_length == share.value.length
+                raise ArgumentError, 'Invalid set of shares. All share values must have the same length.'
+              end
               x_coordinates << share.member_index
             end
             x_coordinates.uniq!
-            raise ArgumentError, 'Invalid set of shares. Share indices must be unique.' unless x_coordinates.size == shares.size
-            interpolate_shares = shares.map{|s|[s.member_index, s.value]}
+            unless x_coordinates.size == shares.size
+              raise ArgumentError, 'Invalid set of shares. Share indices must be unique.'
+            end
+            interpolate_shares = shares.map { |s| [s.member_index, s.value] }
 
             secret = interpolate(interpolate_shares, SECRET_INDEX)
             digest_value = interpolate(interpolate_shares, DIGEST_INDEX).htb
@@ -129,9 +159,12 @@ module Tapyrus
 
         return decrypt(group_shares.values.first, passphrase, exp, id) if group_threshold == 1
 
-        raise ArgumentError, "Wrong number of mnemonics. Group threshold is #{group_threshold}, but share count is #{group_shares.length}" if group_shares.length < group_threshold
+        if group_shares.length < group_threshold
+          raise ArgumentError,
+                "Wrong number of mnemonics. Group threshold is #{group_threshold}, but share count is #{group_shares.length}"
+        end
 
-        interpolate_shares = group_shares.map{|k, v|[k, v]}
+        interpolate_shares = group_shares.map { |k, v| [k, v] }
         secret = interpolate(interpolate_shares, SECRET_INDEX)
         digest_value = interpolate(interpolate_shares, DIGEST_INDEX).htb
         digest, random_value = digest_value[0...DIGEST_LENGTH_BYTES].bth, digest_value[DIGEST_LENGTH_BYTES..-1].bth
@@ -148,17 +181,24 @@ module Tapyrus
       # @param [Integer] x the x coordinate of the result.
       # @return [String] f(x) value with hex format.
       def self.interpolate(shares, x)
-        s = shares.find{|s|s[0] == x}
+        s = shares.find { |s| s[0] == x }
         return s[1] if s
 
-        log_prod = shares.sum{|s|LOG_TABLE[s[0] ^ x]}
+        log_prod = shares.sum { |s| LOG_TABLE[s[0] ^ x] }
 
         result = ('00' * shares.first[1].length).htb
         shares.each do |share|
-          log_basis_eval = (log_prod - LOG_TABLE[share[0] ^ x] - shares.sum{|s|LOG_TABLE[share[0] ^ s[0]]}) % 255
-          result = share[1].htb.bytes.each.map.with_index do |v, i|
-            (result[i].bti ^ (v == 0 ? 0 : (EXP_TABLE[(LOG_TABLE[v] + log_basis_eval) % 255]))).itb
-          end.join
+          log_basis_eval = (log_prod - LOG_TABLE[share[0] ^ x] - shares.sum { |s| LOG_TABLE[share[0] ^ s[0]] }) % 255
+          result =
+            share[1]
+              .htb
+              .bytes
+              .each
+              .map
+              .with_index do |v, i|
+                (result[i].bti ^ (v == 0 ? 0 : (EXP_TABLE[(LOG_TABLE[v] + log_basis_eval) % 255]))).itb
+              end
+              .join
         end
         result.bth
       end
@@ -172,10 +212,14 @@ module Tapyrus
         l, r = ems[0...(ems.length / 2)].htb, ems[(ems.length / 2)..-1].htb
         salt = get_salt(id)
         e = (Tapyrus::SLIP39::BASE_ITERATION_COUNT << exp) / Tapyrus::SLIP39::ROUND_COUNT
-        Tapyrus::SLIP39::ROUND_COUNT.times.to_a.reverse.each do |i|
-          f = OpenSSL::PKCS5.pbkdf2_hmac((i.itb + passphrase), salt + r, e, r.bytesize, 'sha256')
-          l, r = padding_zero(r, r.bytesize), padding_zero((l.bti ^ f.bti).itb, r.bytesize)
-        end
+        Tapyrus::SLIP39::ROUND_COUNT
+          .times
+          .to_a
+          .reverse
+          .each do |i|
+            f = OpenSSL::PKCS5.pbkdf2_hmac((i.itb + passphrase), salt + r, e, r.bytesize, 'sha256')
+            l, r = padding_zero(r, r.bytesize), padding_zero((l.bti ^ f.bti).itb, r.bytesize)
+          end
         (r + l).bth
       end
 
@@ -190,10 +234,13 @@ module Tapyrus
         l, r = s[0...(s.bytesize / 2)], s[(s.bytesize / 2)..-1]
         salt = get_salt(id)
         e = (Tapyrus::SLIP39::BASE_ITERATION_COUNT << exp) / Tapyrus::SLIP39::ROUND_COUNT
-        Tapyrus::SLIP39::ROUND_COUNT.times.to_a.each do |i|
-          f = OpenSSL::PKCS5.pbkdf2_hmac((i.itb + passphrase), salt + r, e, r.bytesize, 'sha256')
-          l, r = padding_zero(r, r.bytesize), padding_zero((l.bti ^ f.bti).itb, r.bytesize)
-        end
+        Tapyrus::SLIP39::ROUND_COUNT
+          .times
+          .to_a
+          .each do |i|
+            f = OpenSSL::PKCS5.pbkdf2_hmac((i.itb + passphrase), salt + r, e, r.bytesize, 'sha256')
+            l, r = padding_zero(r, r.bytesize), padding_zero((l.bti ^ f.bti).itb, r.bytesize)
+          end
         (r + l).bth
       end
 
@@ -220,26 +267,29 @@ module Tapyrus
       # @return [Array[Integer, String]] the array of split secret.
       def self.split_secret(threshold, count, secret)
         raise ArgumentError, "The requested threshold (#{threshold}) must be a positive integer." if threshold < 1
-        raise ArgumentError, "The requested threshold (#{threshold}) must not exceed the number of shares (#{count})." if threshold > count
-        raise ArgumentError, "The requested number of shares (#{count}) must not exceed #{MAX_SHARE_COUNT}." if count > MAX_SHARE_COUNT
+        if threshold > count
+          raise ArgumentError, "The requested threshold (#{threshold}) must not exceed the number of shares (#{count})."
+        end
+        if count > MAX_SHARE_COUNT
+          raise ArgumentError, "The requested number of shares (#{count}) must not exceed #{MAX_SHARE_COUNT}."
+        end
 
-        return count.times.map{|i|[i, secret]} if threshold == 1 # if the threshold is 1, digest of the share is not used.
+        return count.times.map { |i| [i, secret] } if threshold == 1 # if the threshold is 1, digest of the share is not used.
 
         random_share_count = threshold - 2
 
-        shares = random_share_count.times.map{|i|[i, SecureRandom.hex(secret.htb.bytesize)]}
+        shares = random_share_count.times.map { |i| [i, SecureRandom.hex(secret.htb.bytesize)] }
         random_part = SecureRandom.hex(secret.htb.bytesize - DIGEST_LENGTH_BYTES)
         digest = create_digest(secret, random_part)
 
         base_shares = shares + [[DIGEST_INDEX, digest + random_part], [SECRET_INDEX, secret]]
 
-        (random_share_count...count).each { |i| shares << [i, interpolate(base_shares, i)]}
+        (random_share_count...count).each { |i| shares << [i, interpolate(base_shares, i)] }
 
         shares
       end
 
       private_class_method :split_secret, :get_salt, :interpolate, :encrypt, :decrypt, :create_digest
-
     end
   end
-end
+end

data/lib/tapyrus/slip39.rb

@@ -1,6 +1,5 @@
 module Tapyrus
   module SLIP39
-
     WORDS = File.readlines("#{__dir__}/slip39/wordlist/english.txt").map(&:strip)
 
     module_function
@@ -15,37 +14,53 @@ module Tapyrus
 
     # The length of the radix in bits.
     RADIX_BITS = 10
+
     # The number of words in the wordlist.
-    RADIX = 2 ** RADIX_BITS
+    RADIX = 2**RADIX_BITS
+
     # The length of the random identifier in bits.
     ID_LENGTH_BITS = 15
+
     # The length of the iteration exponent in bits.
     ITERATION_EXP_LENGTH_BITS = 5
+
     # The length of the random identifier and iteration exponent in words.
     ID_EXP_LENGTH_WORDS = bits_to_words(ID_LENGTH_BITS + ITERATION_EXP_LENGTH_BITS)
+
     # The maximum number of shares that can be created.
     MAX_SHARE_COUNT = 16
+
     # The length of the RS1024 checksum in words.
     CHECKSUM_LENGTH_WORDS = 3
+
     # The length of the digest of the shared secret in bytes.
     DIGEST_LENGTH_BYTES = 4
+
     # The customization string used in the RS1024 checksum and in the PBKDF2 salt.
     CUSTOMIZATION_STRING = 'shamir'.bytes
+
     # The length of the mnemonic in words without the share value.
     METADATA_LENGTH_WORDS = ID_EXP_LENGTH_WORDS + 2 + CHECKSUM_LENGTH_WORDS
+
     # The minimum allowed entropy of the master secret.
     MIN_STRENGTH_BITS = 128
+
     # The minimum allowed length of the mnemonic in words.
     MIN_MNEMONIC_LENGTH_WORDS = METADATA_LENGTH_WORDS + bits_to_words(MIN_STRENGTH_BITS)
+
     # The minimum number of iterations to use in PBKDF2.
-    BASE_ITERATION_COUNT = 10000
+    BASE_ITERATION_COUNT = 10_000
+
     # The number of rounds to use in the Feistel cipher.
     ROUND_COUNT = 4
+
     # The index of the share containing the shared secret.
     SECRET_INDEX = 255
+
     # The index of the share containing the digest of the shared secret.
     DIGEST_INDEX = 254
 
+    # prettier-ignore
     EXP_TABLE = [
         1, 3, 5, 15, 17, 51, 85, 255, 26, 46, 114, 150, 161, 248, 19,
         53, 95, 225, 56, 72, 216, 115, 149, 164, 247, 2, 6, 10, 30, 34,
@@ -66,6 +81,7 @@ module Tapyrus
         57, 75, 221, 124, 132, 151, 162, 253, 28, 36, 108, 180, 199, 82, 246
     ]
 
+    # prettier-ignore
     LOG_TABLE = [
         0, 0, 25, 1, 50, 2, 26, 198, 75, 199, 27, 104, 51, 238, 223, 3,
         100, 4, 224, 14, 52, 141, 129, 239, 76, 113, 8, 200, 248, 105, 28,
@@ -88,6 +104,5 @@ module Tapyrus
 
     autoload :SSS, 'tapyrus/slip39/sss'
     autoload :Share, 'tapyrus/slip39/share'
-
   end
-end
+end

data/lib/tapyrus/store/chain_entry.rb

@@ -1,6 +1,5 @@
 module Tapyrus
   module Store
-
     # wrap a block header object with extra data.
     class ChainEntry
       include Tapyrus::HexConverter
@@ -60,9 +59,6 @@ module Tapyrus
         height_value = height_value.htb.reverse
         Tapyrus.pack_var_int(height_value.bytesize) + height_value + header.to_payload
       end
-
     end
-
   end
-
 end

data/lib/tapyrus/store/db/level_db.rb

@@ -3,9 +3,7 @@ require 'leveldb-native'
 module Tapyrus
   module Store
     module DB
-
       class LevelDB
-
         attr_reader :db
         attr_reader :logger
 
@@ -62,9 +60,11 @@ module Tapyrus
         # @param [Tapyrus::Store::ChainEntry]
         def save_entry(entry)
           db.batch do
-            db.put(entry.key ,entry.to_payload)
+            db.put(entry.key, entry.to_payload)
             db.put(height_key(entry.height), entry.block_hash)
-            add_agg_pubkey(entry.height == 0 ? 0 : entry.height + 1, entry.header.x_field) if entry.header.upgrade_agg_pubkey?
+            if entry.header.upgrade_agg_pubkey?
+              add_agg_pubkey(entry.height == 0 ? 0 : entry.height + 1, entry.header.x_field)
+            end
             connect_entry(entry)
           end
         end
@@ -134,9 +134,7 @@ module Tapyrus
             unless tip_block.block_hash == entry.prev_hash
               raise "entry(#{entry.block_hash}) does not reference current best block hash(#{tip_block.block_hash})"
             end
-            unless tip_block.height + 1 == entry.height
-              raise "block height is small than current best block."
-            end
+            raise 'block height is small than current best block.' unless tip_block.height + 1 == entry.height
           end
           db.put(KEY_PREFIX[:best], entry.block_hash)
           db.put(KEY_PREFIX[:next] + entry.prev_hash, entry.block_hash)
@@ -148,9 +146,7 @@ module Tapyrus
           index = db.get(KEY_PREFIX[:latest_agg_pubkey])
           index&.to_i(16)
         end
-
       end
-
     end
   end
 end

data/lib/tapyrus/store/db.rb

@@ -1,9 +1,7 @@
 module Tapyrus
   module Store
-
     module DB
       autoload :LevelDB, 'tapyrus/store/db/level_db'
     end
-
   end
 end

data/lib/tapyrus/store/spv_chain.rb

@@ -1,18 +1,15 @@
 module Tapyrus
-
   module Store
-
     KEY_PREFIX = {
-        entry: 'e',             # key: block hash, value: Tapyrus::Store::ChainEntry payload
-        height: 'h',            # key: block height, value: block hash.
-        best: 'B',              # value: best block hash.
-        next: 'n',              # key: block hash, value: A hash of the next block of the specified hash
-        agg_pubkey: 'a',        # key: index, value: Activated block height | aggregated public key.
-        latest_agg_pubkey: 'g'  # value: latest agg pubkey index.
+      entry: 'e', # key: block hash, value: Tapyrus::Store::ChainEntry payload
+      height: 'h', # key: block height, value: block hash.
+      best: 'B', # value: best block hash.
+      next: 'n', # key: block hash, value: A hash of the next block of the specified hash
+      agg_pubkey: 'a', # key: index, value: Activated block height | aggregated public key.
+      latest_agg_pubkey: 'g' # value: latest agg pubkey index.
     }
 
     class SPVChain
-
       attr_reader :db
       attr_reader :logger
 
@@ -53,7 +50,9 @@ module Tapyrus
         logger.info("append header #{header.block_id}")
         best_block = latest_block
         current_height = best_block.height
-        raise "this header is invalid. #{header.block_hash}" unless header.valid?(db.agg_pubkey_with_height(current_height + 1))
+        unless header.valid?(db.agg_pubkey_with_height(current_height + 1))
+          raise "this header is invalid. #{header.block_hash}"
+        end
         if best_block.block_hash == header.prev_hash
           entry = Tapyrus::Store::ChainEntry.new(header, current_height + 1)
           db.save_entry(entry)
@@ -107,13 +106,8 @@ module Tapyrus
       # if database is empty, put genesis block.
       # @param [Tapyrus::Block] genesis genesis block
       def initialize_block(genesis)
-        unless latest_block
-          db.save_entry(ChainEntry.new(genesis.header, 0))
-        end
+        db.save_entry(ChainEntry.new(genesis.header, 0)) unless latest_block
       end
-
     end
-
   end
-
-end
+end

data/lib/tapyrus/store.rb

@@ -1,9 +1,7 @@
 module Tapyrus
   module Store
-
     autoload :DB, 'tapyrus/store/db'
     autoload :SPVChain, 'tapyrus/store/spv_chain'
     autoload :ChainEntry, 'tapyrus/store/chain_entry'
-
   end
-end
+end

data/lib/tapyrus/tx.rb

@@ -2,7 +2,6 @@
 # https://github.com/lian/bitcoin-ruby/blob/master/COPYING
 
 module Tapyrus
-
   # Transaction class
   class Tx
     include Tapyrus::HexConverter
@@ -10,7 +9,7 @@ module Tapyrus
     MAX_STANDARD_VERSION = 2
 
     # The maximum weight for transactions we're willing to relay/mine
-    MAX_STANDARD_TX_WEIGHT = 400000
+    MAX_STANDARD_TX_WEIGHT = 400_000
 
     attr_accessor :features
     attr_reader :inputs
@@ -34,14 +33,10 @@ module Tapyrus
 
       in_count = Tapyrus.unpack_var_int_from_io(buf)
 
-      in_count.times do
-        tx.inputs << TxIn.parse_from_payload(buf)
-      end
+      in_count.times { tx.inputs << TxIn.parse_from_payload(buf) }
 
       out_count = Tapyrus.unpack_var_int_from_io(buf)
-      out_count.times do
-        tx.outputs << TxOut.parse_from_payload(buf)
-      end
+      out_count.times { tx.outputs << TxOut.parse_from_payload(buf) }
 
       tx.lock_time = buf.read(4).unpack('V').first
 
@@ -58,7 +53,7 @@ module Tapyrus
 
     def txid
       buf = [features].pack('V')
-      buf << Tapyrus.pack_var_int(inputs.length) << inputs.map{|i|i.to_payload(use_malfix: true)}.join
+      buf << Tapyrus.pack_var_int(inputs.length) << inputs.map { |i| i.to_payload(use_malfix: true) }.join
       buf << Tapyrus.pack_var_int(outputs.length) << outputs.map(&:to_payload).join
       buf << [lock_time].pack('V')
       Tapyrus.double_sha256(buf).reverse.bth
@@ -95,6 +90,7 @@ module Tapyrus
       outputs.each do |o|
         return false unless o.script_pubkey.standard?
         data_count += 1 if o.script_pubkey.op_return?
+
         # TODO add non P2SH multisig relay(permitbaremultisig)
         return false if o.dust?
       end
@@ -114,8 +110,14 @@ module Tapyrus
     # @param [Integer] amount tapyrus amount locked in input. required for witness input only.
     # @param [Integer] skip_separator_index If output_script is P2WSH and output_script contains any OP_CODESEPARATOR,
     # the script code needs  is the witnessScript but removing everything up to and including the last executed OP_CODESEPARATOR before the signature checking opcode being executed.
-    def sighash_for_input(input_index, output_script, hash_type: SIGHASH_TYPE[:all],
-                          sig_version: :base, amount: nil, skip_separator_index: 0)
+    def sighash_for_input(
+      input_index,
+      output_script,
+      hash_type: SIGHASH_TYPE[:all],
+      sig_version: :base,
+      amount: nil,
+      skip_separator_index: 0
+    )
       raise ArgumentError, 'input_index must be specified.' unless input_index
       raise ArgumentError, 'does not exist input corresponding to input_index.' if input_index >= inputs.size
       raise ArgumentError, 'script_pubkey must be specified.' unless output_script
@@ -129,16 +131,19 @@ module Tapyrus
     # @param [Integer] amount the amount of tapyrus, require for witness program only.
     # @param [Array] flags the flags used when execute script interpreter.
     def verify_input_sig(input_index, script_pubkey, amount: nil, flags: STANDARD_SCRIPT_VERIFY_FLAGS)
-      if script_pubkey.p2sh?
-        flags << SCRIPT_VERIFY_P2SH
-      end
+      flags << SCRIPT_VERIFY_P2SH if script_pubkey.p2sh?
       verify_input_sig_for_legacy(input_index, script_pubkey, flags)
     end
 
     def to_h
       {
-          txid: txid, hash: tx_hash, features: features, size: size, locktime: lock_time,
-          vin: inputs.map(&:to_h), vout: outputs.map.with_index{|tx_out, index| tx_out.to_h.merge({n: index})}
+        txid: txid,
+        hash: tx_hash,
+        features: features,
+        size: size,
+        locktime: lock_time,
+        vin: inputs.map(&:to_h),
+        vout: outputs.map.with_index { |tx_out, index| tx_out.to_h.merge({ n: index }) }
       }
     end
 
@@ -154,43 +159,48 @@ module Tapyrus
 
     # generate sighash with legacy format
     def sighash_for_legacy(index, script_code, hash_type)
-      ins = inputs.map.with_index do |i, idx|
-        if idx == index
-          i.to_payload(script_code.delete_opcode(Tapyrus::Opcodes::OP_CODESEPARATOR))
-        else
-          case hash_type & 0x1f
+      ins =
+        inputs.map.with_index do |i, idx|
+          if idx == index
+            i.to_payload(script_code.delete_opcode(Tapyrus::Opcodes::OP_CODESEPARATOR))
+          else
+            case hash_type & 0x1f
             when SIGHASH_TYPE[:none], SIGHASH_TYPE[:single]
               i.to_payload(Tapyrus::Script.new, 0)
             else
               i.to_payload(Tapyrus::Script.new)
+            end
           end
         end
-      end
 
       outs = outputs.map(&:to_payload)
       out_size = Tapyrus.pack_var_int(outputs.size)
 
       case hash_type & 0x1f
-        when SIGHASH_TYPE[:none]
-          outs = ''
-          out_size = Tapyrus.pack_var_int(0)
-        when SIGHASH_TYPE[:single]
-          return "\x01".ljust(32, "\x00") if index >= outputs.size
-          outs = outputs[0...(index + 1)].map.with_index { |o, idx| (idx == index) ? o.to_payload : o.to_empty_payload }.join
-          out_size = Tapyrus.pack_var_int(index + 1)
+      when SIGHASH_TYPE[:none]
+        outs = ''
+        out_size = Tapyrus.pack_var_int(0)
+      when SIGHASH_TYPE[:single]
+        return "\x01".ljust(32, "\x00") if index >= outputs.size
+        outs =
+          outputs[0...(index + 1)].map.with_index { |o, idx| (idx == index) ? o.to_payload : o.to_empty_payload }.join
+        out_size = Tapyrus.pack_var_int(index + 1)
       end
 
-      if hash_type & SIGHASH_TYPE[:anyonecanpay] != 0
-        ins = [ins[index]]
-      end
+      ins = [ins[index]] if hash_type & SIGHASH_TYPE[:anyonecanpay] != 0
 
-      buf = [[features].pack('V'), Tapyrus.pack_var_int(ins.size),
-          ins, out_size, outs, [lock_time, hash_type].pack('VV')].join
+      buf = [
+        [features].pack('V'),
+        Tapyrus.pack_var_int(ins.size),
+        ins,
+        out_size,
+        outs,
+        [lock_time, hash_type].pack('VV')
+      ].join
 
       Tapyrus.double_sha256(buf)
     end
 
-
     # verify input signature for legacy tx.
     def verify_input_sig_for_legacy(input_index, script_pubkey, flags)
       script_sig = inputs[input_index].script_sig
@@ -199,7 +209,5 @@ module Tapyrus
 
       interpreter.verify_script(script_sig, script_pubkey)
     end
-
   end
-
 end