tapyrus 0.2.7 → 0.2.12

data/lib/tapyrus/script/tx_checker.rb

@@ -1,6 +1,5 @@
 module Tapyrus
   class TxChecker
-
     attr_reader :tx
     attr_reader :input_index
     attr_reader :amount
@@ -22,8 +21,8 @@ module Tapyrus
       script_sig = script_sig.htb
       hash_type = script_sig[-1].unpack('C').first
       sig = script_sig[0..-2]
-      sighash = tx.sighash_for_input(input_index, script_code, hash_type: hash_type,
-                                     amount: amount, sig_version: sig_version)
+      sighash =
+        tx.sighash_for_input(input_index, script_code, hash_type: hash_type, amount: amount, sig_version: sig_version)
       verify_sig(sig.bth, pubkey, sighash)
     end
 
@@ -33,7 +32,8 @@ module Tapyrus
     # @param [String] digest a message digest with binary format to be verified.
     # @return [Boolean] if check is passed return true, otherwise false.
     def verify_sig(sig, pubkey, digest, allow_hybrid: false)
-      key_type = pubkey.start_with?('02') || pubkey.start_with?('03') ? Key::TYPES[:compressed] : Key::TYPES[:uncompressed]
+      key_type =
+        pubkey.start_with?('02') || pubkey.start_with?('03') ? Key::TYPES[:compressed] : Key::TYPES[:uncompressed]
       sig = sig.htb
       algo = sig.bytesize == 64 ? :schnorr : :ecdsa
       begin
@@ -49,8 +49,10 @@ module Tapyrus
       # distinguished by whether nLockTime < LOCKTIME_THRESHOLD.
 
       # We want to compare apples to apples, so fail the script unless the type of nLockTime being tested is the same as the nLockTime in the transaction.
-      unless ((tx.lock_time < LOCKTIME_THRESHOLD && locktime < LOCKTIME_THRESHOLD) ||
-          (tx.lock_time >= LOCKTIME_THRESHOLD && locktime >= LOCKTIME_THRESHOLD))
+      unless (
+               (tx.lock_time < LOCKTIME_THRESHOLD && locktime < LOCKTIME_THRESHOLD) ||
+                 (tx.lock_time >= LOCKTIME_THRESHOLD && locktime >= LOCKTIME_THRESHOLD)
+             )
         return false
       end
 
@@ -68,6 +70,7 @@ module Tapyrus
 
     def check_sequence(sequence)
       tx_sequence = tx.inputs[input_index].sequence
+
       # Fail if the transaction's version number is not set high enough to trigger BIP 68 rules.
       return false if tx.features < 2
 
@@ -84,14 +87,21 @@ module Tapyrus
       # distinguished by whether sequence_masked < TxIn#SEQUENCE_LOCKTIME_TYPE_FLAG.
       # We want to compare apples to apples, so fail the script
       # unless the type of nSequenceMasked being tested is the same as the nSequenceMasked in the transaction.
-      unless ((tx_sequence_masked < TxIn::SEQUENCE_LOCKTIME_TYPE_FLAG && sequence_masked < TxIn::SEQUENCE_LOCKTIME_TYPE_FLAG) ||
-          (tx_sequence_masked >= TxIn::SEQUENCE_LOCKTIME_TYPE_FLAG && sequence_masked >= TxIn::SEQUENCE_LOCKTIME_TYPE_FLAG))
+      unless (
+               (
+                 tx_sequence_masked < TxIn::SEQUENCE_LOCKTIME_TYPE_FLAG &&
+                   sequence_masked < TxIn::SEQUENCE_LOCKTIME_TYPE_FLAG
+               ) ||
+                 (
+                   tx_sequence_masked >= TxIn::SEQUENCE_LOCKTIME_TYPE_FLAG &&
+                     sequence_masked >= TxIn::SEQUENCE_LOCKTIME_TYPE_FLAG
+                 )
+             )
         return false
       end
 
       # Now that we know we're comparing apples-to-apples, the comparison is a simple numeric one.
       sequence_masked <= tx_sequence_masked
     end
-
   end
-end
+end

data/lib/tapyrus/secp256k1/native.rb

@@ -3,7 +3,6 @@
 
 module Tapyrus
   module Secp256k1
-
     # binding for secp256k1 (https://github.com/chaintope/tapyrus-core/tree/v0.4.0/src/secp256k1)
     # tag: v0.4.0
     # this is not included by default, to enable set shared object path to ENV['SECP256K1_LIB_PATH']
@@ -80,8 +79,8 @@ module Tapyrus
             priv_key = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, SecureRandom.random_bytes(32))
             ret = secp256k1_ec_seckey_verify(context, priv_key)
           end
-          private_key =  priv_key.read_string(32).bth
-          [private_key , generate_pubkey_in_context(context,  private_key, compressed: compressed) ]
+          private_key = priv_key.read_string(32).bth
+          [private_key, generate_pubkey_in_context(context, private_key, compressed: compressed)]
         end
       end
 
@@ -92,9 +91,7 @@ module Tapyrus
       end
 
       def generate_pubkey(priv_key, compressed: true)
-        with_context do |context|
-          generate_pubkey_in_context(context, priv_key, compressed: compressed)
-        end
+        with_context { |context| generate_pubkey_in_context(context, priv_key, compressed: compressed) }
       end
 
       # sign data.
@@ -152,13 +149,14 @@ module Tapyrus
 
         pubkey = FFI::MemoryPointer.new(:uchar, 65)
         pubkey_len = FFI::MemoryPointer.new(:uint64)
-        result = if compressed
-                   pubkey_len.put_uint64(0, 33)
-                   secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_COMPRESSED)
-                 else
-                   pubkey_len.put_uint64(0, 65)
-                   secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_UNCOMPRESSED)
-                 end
+        result =
+          if compressed
+            pubkey_len.put_uint64(0, 33)
+            secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_COMPRESSED)
+          else
+            pubkey_len.put_uint64(0, 65)
+            secp256k1_ec_pubkey_serialize(context, pubkey, pubkey_len, internal_pubkey, SECP256K1_EC_UNCOMPRESSED)
+          end
         raise 'error serialize pubkey' unless result || pubkey_len.read_uint64 > 0
         pubkey.read_string(pubkey_len.read_uint64).bth
       end
@@ -196,7 +194,9 @@ module Tapyrus
 
           signature = FFI::MemoryPointer.new(:uchar, 64)
           msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
-          raise 'Failed to generate schnorr signature.' unless secp256k1_schnorr_sign(context, signature, msg32, secret, nil, nil) == 1
+          unless secp256k1_schnorr_sign(context, signature, msg32, secret, nil, nil) == 1
+            raise 'Failed to generate schnorr signature.'
+          end
           signature.read_string(64)
         end
       end
@@ -241,7 +241,6 @@ module Tapyrus
           result == 1
         end
       end
-
     end
   end
 end

data/lib/tapyrus/secp256k1/rfc6979.rb

@@ -1,7 +1,6 @@
 module Tapyrus
   module Secp256k1
     module RFC6979
-
       INITIAL_V = '0101010101010101010101010101010101010101010101010101010101010101'.htb
       INITIAL_K = '0000000000000000000000000000000000000000000000000000000000000000'.htb
       ZERO_B = '00'.htb
@@ -17,17 +16,22 @@ module Tapyrus
       def generate_rfc6979_nonce(key_data, extra_entropy)
         v = INITIAL_V # 3.2.b
         k = INITIAL_K # 3.2.c
+
         # 3.2.d
         k = Tapyrus.hmac_sha256(k, v + ZERO_B + key_data + extra_entropy)
+
         # 3.2.e
         v = Tapyrus.hmac_sha256(k, v)
+
         # 3.2.f
         k = Tapyrus.hmac_sha256(k, v + ONE_B + key_data + extra_entropy)
+
         # 3.2.g
         v = Tapyrus.hmac_sha256(k, v)
+
         # 3.2.h
         t = ''
-        10000.times do
+        10_000.times do
           v = Tapyrus.hmac_sha256(k, v)
           t = (t + v)
           t_num = t.bth.to_i(16)
@@ -37,7 +41,6 @@ module Tapyrus
         end
         raise 'A valid nonce was not found.'
       end
-
     end
   end
-end
+end

data/lib/tapyrus/secp256k1/ruby.rb

@@ -1,10 +1,8 @@
 module Tapyrus
   module Secp256k1
-
     # secp256 module using ecdsa gem
     # https://github.com/DavidEGrayson/ruby_ecdsa
     module Ruby
-
       module_function
 
       # generate ec private key and public key
@@ -58,7 +56,7 @@ module Tapyrus
         end
       end
 
-      alias :valid_sig? :verify_sig
+      alias valid_sig? verify_sig
 
       module_function :valid_sig?
 
@@ -68,7 +66,8 @@ module Tapyrus
       # @return [Boolean] If valid public key return true, otherwise false.
       def parse_ec_pubkey?(pubkey, allow_hybrid = false)
         begin
-          point = ECDSA::Format::PointOctetString.decode(pubkey.htb, ECDSA::Group::Secp256k1, allow_hybrid: allow_hybrid)
+          point =
+            ECDSA::Format::PointOctetString.decode(pubkey.htb, ECDSA::Group::Secp256k1, allow_hybrid: allow_hybrid)
           ECDSA::Group::Secp256k1.valid_public_key?(point)
         rescue ECDSA::Format::DecodeError
           false
@@ -80,11 +79,11 @@ module Tapyrus
       def repack_pubkey(pubkey)
         p = pubkey.htb
         case p[0]
-          when "\x06", "\x07"
-            p[0] = "\x04"
-            p
-          else
-            pubkey.htb
+        when "\x06", "\x07"
+          p[0] = "\x04"
+          p
+        else
+          pubkey.htb
         end
       end
 
@@ -104,7 +103,8 @@ module Tapyrus
         e = ECDSA.normalize_digest(data, GROUP.bit_length)
         s = point_field.mod(point_field.inverse(nonce) * (e + r * private_key))
 
-        if s > (GROUP.order / 2) # convert low-s
+        if s > (GROUP.order / 2)
+          # convert low-s
           s = GROUP.order - s
         end
 
@@ -125,8 +125,6 @@ module Tapyrus
           false
         end
       end
-
     end
-
   end
 end

data/lib/tapyrus/secp256k1.rb

@@ -1,13 +1,9 @@
 module Tapyrus
-
   module Secp256k1
-
     GROUP = ECDSA::Group::Secp256k1
 
     autoload :Ruby, 'tapyrus/secp256k1/ruby'
     autoload :Native, 'tapyrus/secp256k1/native'
     autoload :RFC6979, 'tapyrus/secp256k1/rfc6979'
-
   end
-
 end

data/lib/tapyrus/slip39/share.rb

@@ -1,36 +1,35 @@
 module Tapyrus
   module SLIP39
-
     # Share of Shamir's Secret Sharing Scheme
     class Share
-
-      attr_accessor :id               # 15 bits, Integer
-      attr_accessor :iteration_exp    # 5 bits, Integer
-      attr_accessor :group_index      # 4 bits, Integer
-      attr_accessor :group_threshold  # 4 bits, Integer
-      attr_accessor :group_count      # 4 bits, Integer
-      attr_accessor :member_index     # 4 bits, Integer
+      attr_accessor :id # 15 bits, Integer
+      attr_accessor :iteration_exp # 5 bits, Integer
+      attr_accessor :group_index # 4 bits, Integer
+      attr_accessor :group_threshold # 4 bits, Integer
+      attr_accessor :group_count # 4 bits, Integer
+      attr_accessor :member_index # 4 bits, Integer
       attr_accessor :member_threshold # 4 bits, Integer
-      attr_accessor :value            # 8n bits, hex string.
-      attr_accessor :checksum         # 30 bits, Integer
+      attr_accessor :value # 8n bits, hex string.
+      attr_accessor :checksum # 30 bits, Integer
 
       # Recover Share from the mnemonic words
       # @param [Array{String}] words the mnemonic words
       # @return [Tapyrus::SLIP39::Share] a share
       def self.from_words(words)
         raise ArgumentError, 'Mnemonics should be an array of strings' unless words.is_a?(Array)
-        indices = words.map do |word|
-          index = Tapyrus::SLIP39::WORDS.index(word.downcase)
-          raise IndexError, 'word not found in words list.' unless index
-          index
-        end
+        indices =
+          words.map do |word|
+            index = Tapyrus::SLIP39::WORDS.index(word.downcase)
+            raise IndexError, 'word not found in words list.' unless index
+            index
+          end
 
         raise ArgumentError, 'Invalid mnemonic length.' if indices.size < MIN_MNEMONIC_LENGTH_WORDS
         raise ArgumentError, 'Invalid mnemonic checksum.' unless verify_rs1024_checksum(indices)
 
         padding_length = (RADIX_BITS * (indices.size - METADATA_LENGTH_WORDS)) % 16
         raise ArgumentError, 'Invalid mnemonic length.' if padding_length > 8
-        data = indices.map{|i|i.to_s(2).rjust(10, '0')}.join
+        data = indices.map { |i| i.to_s(2).rjust(10, '0') }.join
 
         s = self.new
         s.id = data[0...ID_LENGTH_BITS].to_i(2)
@@ -38,14 +37,17 @@ module Tapyrus
         s.group_index = data[20...24].to_i(2)
         s.group_threshold = data[24...28].to_i(2) + 1
         s.group_count = data[28...32].to_i(2) + 1
-        raise ArgumentError, "Invalid mnemonic. Group threshold(#{s.group_threshold}) cannot be greater than group count(#{s.group_count})." if s.group_threshold > s.group_count
+        if s.group_threshold > s.group_count
+          raise ArgumentError,
+                "Invalid mnemonic. Group threshold(#{s.group_threshold}) cannot be greater than group count(#{s.group_count})."
+        end
         s.member_index = data[32...36].to_i(2)
         s.member_threshold = data[36...40].to_i(2) + 1
         value_length = data.length - 70
         start_index = 40 + padding_length
         end_index = start_index + value_length - padding_length
         padding_value = data[40...(40 + padding_length)]
-        raise ArgumentError, "Invalid mnemonic. padding must only zero." unless padding_value.to_i(2) == 0
+        raise ArgumentError, 'Invalid mnemonic. padding must only zero.' unless padding_value.to_i(2) == 0
         s.value = data[start_index...end_index].to_i(2).to_even_length_hex
         s.checksum = data[(40 + value_length)..-1].to_i(2)
         s
@@ -55,25 +57,34 @@ module Tapyrus
       # @return [Array[String]] array of mnemonic word.
       def to_words
         indices = build_word_indices
-        indices.map{|index| Tapyrus::SLIP39::WORDS[index]}
+        indices.map { |index| Tapyrus::SLIP39::WORDS[index] }
       end
 
       # Calculate checksum using current fields
       # @return [Integer] checksum
       def calculate_checksum
         indices = build_word_indices(false)
-        create_rs1024_checksum(indices).map{|i|i.to_bits(10)}.join.to_i(2)
+        create_rs1024_checksum(indices).map { |i| i.to_bits(10) }.join.to_i(2)
       end
 
       def self.rs1024_polymod(values)
-        gen = [0xe0e040, 0x1c1c080, 0x3838100, 0x7070200, 0xe0e0009, 0x1c0c2412, 0x38086c24, 0x3090fc48, 0x21b1f890, 0x3f3f120]
+        gen = [
+          0xe0e040,
+          0x1c1c080,
+          0x3838100,
+          0x7070200,
+          0xe0e0009,
+          0x1c0c2412,
+          0x38086c24,
+          0x3090fc48,
+          0x21b1f890,
+          0x3f3f120
+        ]
         chk = 1
         values.each do |v|
           b = (chk >> 20)
           chk = (chk & 0xfffff) << 10 ^ v
-          10.times do |i|
-            chk ^= (((b >> i) & 1 == 1) ? gen[i] : 0)
-          end
+          10.times { |i| chk ^= (((b >> i) & 1 == 1) ? gen[i] : 0) }
         end
         chk
       end
@@ -89,14 +100,16 @@ module Tapyrus
         s << group_index.to_bits(4)
         s << (group_threshold - 1).to_bits(4)
         s << (group_count - 1).to_bits(4)
-        raise StandardError, "Group threshold(#{group_threshold}) cannot be greater than group count(#{group_count})." if group_threshold > group_count
+        if group_threshold > group_count
+          raise StandardError, "Group threshold(#{group_threshold}) cannot be greater than group count(#{group_count})."
+        end
         s << member_index.to_bits(4)
         s << (member_threshold - 1).to_bits(4)
         value_length = value.to_i(16).bit_length
         padding_length = RADIX_BITS - (value_length % RADIX_BITS)
         s << value.to_i(16).to_bits(value_length + padding_length)
         s << checksum.to_bits(30) if include_checksum
-        s.chars.each_slice(10).map{|index| index.join.to_i(2)}
+        s.chars.each_slice(10).map { |index| index.join.to_i(2) }
       end
 
       # Verify RS1024 checksum
@@ -112,11 +125,10 @@ module Tapyrus
       def create_rs1024_checksum(data)
         values = CUSTOMIZATION_STRING + data + Array.new(CHECKSUM_LENGTH_WORDS, 0)
         polymod = Tapyrus::SLIP39::Share.rs1024_polymod(values) ^ 1
-        CHECKSUM_LENGTH_WORDS.times.to_a.reverse.map {|i|(polymod >> (10 * i)) & 1023 }
+        CHECKSUM_LENGTH_WORDS.times.to_a.reverse.map { |i| (polymod >> (10 * i)) & 1023 }
       end
 
       private_class_method :verify_rs1024_checksum
-
     end
   end
-end
+end

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
@@ -220,26 +260,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