tapyrus 0.3.4 → 0.3.5

data/lib/tapyrus/script/script.rb

@@ -46,7 +46,7 @@ module Tapyrus
     # @return [Script] CP2PKH script
     # @raise [ArgumentError] if color_id is nil or invalid
     def self.to_cp2pkh(color_id, pubkey_hash)
-      raise ArgumentError, 'Specified color identifier is invalid' unless color_id&.valid?
+      raise ArgumentError, "Specified color identifier is invalid" unless color_id&.valid?
       new << color_id.to_payload << OP_COLOR << OP_DUP << OP_HASH160 << pubkey_hash << OP_EQUALVERIFY << OP_CHECKSIG
     end
 
@@ -56,7 +56,7 @@ module Tapyrus
     # @return [Script] CP2SH script
     # @raise [ArgumentError] if color_id is nil or invalid
     def self.to_cp2sh(color_id, script_hash)
-      raise ArgumentError, 'Specified color identifier is invalid' unless color_id&.valid?
+      raise ArgumentError, "Specified color identifier is invalid" unless color_id&.valid?
       new << color_id.to_payload << OP_COLOR << OP_HASH160 << script_hash << OP_EQUAL
     end
 
@@ -66,8 +66,8 @@ module Tapyrus
     # @raise [ArgumentError] if color_id is nil or invalid
     # @raise [RuntimeError] if script is neither p2pkh nor p2sh
     def add_color(color_id)
-      raise ArgumentError, 'Specified color identifier is invalid' unless color_id&.valid?
-      raise RuntimeError, 'Only p2pkh and p2sh can add color' unless p2pkh? or p2sh?
+      raise ArgumentError, "Specified color identifier is invalid" unless color_id&.valid?
+      raise RuntimeError, "Only p2pkh and p2sh can add color" unless p2pkh? or p2sh?
       Tapyrus::Script.new.tap do |s|
         s << color_id.to_payload << OP_COLOR
         s.chunks += self.chunks
@@ -78,7 +78,7 @@ module Tapyrus
     # @return [Script] P2PKH or P2SH script
     # @raise [RuntimeError] if script is neither cp2pkh nor cp2sh
     def remove_color
-      raise RuntimeError, 'Only cp2pkh and cp2sh can remove color' unless cp2pkh? or cp2sh?
+      raise RuntimeError, "Only cp2pkh and cp2sh can remove color" unless cp2pkh? or cp2sh?
 
       Tapyrus::Script.new.tap { |s| s.chunks = self.chunks[2..-1] }
     end
@@ -101,7 +101,7 @@ module Tapyrus
     def self.from_string(string)
       script = new
       string
-        .split(' ')
+        .split(" ")
         .each do |v|
           opcode = Opcodes.name_to_opcode(v)
           if opcode
@@ -144,18 +144,18 @@ module Tapyrus
             case pushcode
             when OP_PUSHDATA1
               packed_size = buf.read(1)
-              packed_size.unpack('C').first
+              packed_size.unpack("C").first
             when OP_PUSHDATA2
               packed_size = buf.read(2)
-              packed_size.unpack('v').first
+              packed_size.unpack("v").first
             when OP_PUSHDATA4
               packed_size = buf.read(4)
-              packed_size.unpack('V').first
+              packed_size.unpack("V").first
             else
               pushcode if pushcode < OP_PUSHDATA1
             end
           if len
-            s.chunks << [len].pack('C') if buf.eof?
+            s.chunks << [len].pack("C") if buf.eof?
             unless buf.eof?
               chunk = (packed_size ? (opcode + packed_size) : (opcode)) + buf.read(len)
               s.chunks << chunk
@@ -374,11 +374,11 @@ module Tapyrus
               end
             else
               opcode = Opcodes.opcode_to_name(c.ord)
-              opcode ? opcode : 'OP_UNKNOWN [error]'
+              opcode ? opcode : "OP_UNKNOWN [error]"
             end
           end
         end
-        .join(' ')
+        .join(" ")
     end
 
     # generate sha-256 hash for payload
@@ -410,15 +410,15 @@ module Tapyrus
     # Byte vectors are interpreted as Booleans where False is represented by any representation of zero,
     # and True is represented by any representation of non-zero.
     def self.encode_number(i)
-      return '' if i == 0
+      return "" if i == 0
       negative = i < 0
 
       hex = i.abs.to_even_length_hex
-      hex = '0' + hex unless (hex.length % 2).zero?
+      hex = "0" + hex unless (hex.length % 2).zero?
       v = hex.htb.reverse # change endian
 
-      v = v << (negative ? 0x80 : 0x00) unless (v[-1].unpack('C').first & 0x80) == 0
-      v[-1] = [v[-1].unpack('C').first | 0x80].pack('C') if negative
+      v = v << (negative ? 0x80 : 0x00) unless (v[-1].unpack("C").first & 0x80) == 0
+      v[-1] = [v[-1].unpack("C").first | 0x80].pack("C") if negative
       v.bth
     end
 
@@ -426,8 +426,8 @@ module Tapyrus
     def self.decode_number(s)
       v = s.htb.reverse
       return 0 if v.length.zero?
-      mbs = v[0].unpack('C').first
-      v[0] = [mbs - 0x80].pack('C') unless (mbs & 0x80) == 0
+      mbs = v[0].unpack("C").first
+      v[0] = [mbs - 0x80].pack("C") unless (mbs & 0x80) == 0
       result = v.bth.to_i(16)
       result = -result unless (mbs & 0x80) == 0
       result
@@ -438,15 +438,15 @@ module Tapyrus
       size = data.bytesize
       header =
         if size < OP_PUSHDATA1
-          [size].pack('C')
+          [size].pack("C")
         elsif size < 0xff
-          [OP_PUSHDATA1, size].pack('CC')
+          [OP_PUSHDATA1, size].pack("CC")
         elsif size < 0xffff
-          [OP_PUSHDATA2, size].pack('Cv')
+          [OP_PUSHDATA2, size].pack("Cv")
         elsif size < 0xffffffff
-          [OP_PUSHDATA4, size].pack('CV')
+          [OP_PUSHDATA4, size].pack("CV")
         else
-          raise ArgumentError, 'data size is too big.'
+          raise ArgumentError, "data size is too big."
         end
       header + data
     end
@@ -460,7 +460,7 @@ module Tapyrus
 
     # removes chunks matching subscript byte-for-byte and returns as a new object.
     def find_and_delete(subscript)
-      raise ArgumentError, 'subscript must be Tapyrus::Script' unless subscript.is_a?(Script)
+      raise ArgumentError, "subscript must be Tapyrus::Script" unless subscript.is_a?(Script)
       return self if subscript.chunks.empty?
       buf = []
       i = 0
@@ -519,10 +519,10 @@ module Tapyrus
     end
 
     def type
-      return 'pubkeyhash' if p2pkh?
-      return 'scripthash' if p2sh?
-      return 'multisig' if multisig?
-      'nonstandard'
+      return "pubkeyhash" if p2pkh?
+      return "scripthash" if p2sh?
+      return "multisig" if multisig?
+      "nonstandard"
     end
 
     def to_h

data/lib/tapyrus/script/script_error.rb

@@ -4,8 +4,8 @@ module Tapyrus
     attr_accessor :code
     attr_accessor :extra_msg
 
-    def initialize(code, extra_msg = '')
-      raise 'invalid error code.' unless ERRCODES_MAP[code]
+    def initialize(code, extra_msg = "")
+      raise "invalid error code." unless ERRCODES_MAP[code]
       @code = code
       @extra_msg = extra_msg
     end
@@ -13,85 +13,85 @@ module Tapyrus
     def to_s
       case code
       when SCRIPT_ERR_OK
-        'No error'
+        "No error"
       when SCRIPT_ERR_EVAL_FALSE
-        'Script evaluated without error but finished with a false/empty top stack element'
+        "Script evaluated without error but finished with a false/empty top stack element"
       when SCRIPT_ERR_VERIFY
-        'Script failed an OP_VERIFY operation'
+        "Script failed an OP_VERIFY operation"
       when SCRIPT_ERR_EQUALVERIFY
-        'Script failed an OP_EQUALVERIFY operation'
+        "Script failed an OP_EQUALVERIFY operation"
       when SCRIPT_ERR_CHECKMULTISIGVERIFY
-        'Script failed an OP_CHECKMULTISIGVERIFY operation'
+        "Script failed an OP_CHECKMULTISIGVERIFY operation"
       when SCRIPT_ERR_CHECKSIGVERIFY
-        'Script failed an OP_CHECKSIGVERIFY operation'
+        "Script failed an OP_CHECKSIGVERIFY operation"
       when SCRIPT_ERR_NUMEQUALVERIFY
-        'Script failed an OP_NUMEQUALVERIFY operation'
+        "Script failed an OP_NUMEQUALVERIFY operation"
       when SCRIPT_ERR_SCRIPT_SIZE
-        'Script is too big'
+        "Script is too big"
       when SCRIPT_ERR_PUSH_SIZE
-        'Push value size limit exceeded'
+        "Push value size limit exceeded"
       when SCRIPT_ERR_OP_COUNT
-        'Operation limit exceeded'
+        "Operation limit exceeded"
       when SCRIPT_ERR_STACK_SIZE
-        'Stack size limit exceeded'
+        "Stack size limit exceeded"
       when SCRIPT_ERR_SIG_COUNT
-        'Signature count negative or greater than pubkey count'
+        "Signature count negative or greater than pubkey count"
       when SCRIPT_ERR_PUBKEY_COUNT
-        'Pubkey count negative or limit exceeded'
+        "Pubkey count negative or limit exceeded"
       when SCRIPT_ERR_BAD_OPCODE
-        'Opcode missing or not understood'
+        "Opcode missing or not understood"
       when SCRIPT_ERR_DISABLED_OPCODE
-        'Attempted to use a disabled opcode'
+        "Attempted to use a disabled opcode"
       when SCRIPT_ERR_INVALID_STACK_OPERATION
-        'Operation not valid with the current stack size'
+        "Operation not valid with the current stack size"
       when SCRIPT_ERR_INVALID_ALTSTACK_OPERATION
-        'Operation not valid with the current altstack size'
+        "Operation not valid with the current altstack size"
       when SCRIPT_ERR_OP_RETURN
-        'OP_was encountered'
+        "OP_was encountered"
       when SCRIPT_ERR_UNBALANCED_CONDITIONAL
-        'Invalid OP_IF construction'
+        "Invalid OP_IF construction"
       when SCRIPT_ERR_NEGATIVE_LOCKTIME
-        'Negative locktime'
+        "Negative locktime"
       when SCRIPT_ERR_UNSATISFIED_LOCKTIME
-        'Locktime requirement not satisfied'
+        "Locktime requirement not satisfied"
       when SCRIPT_ERR_SIG_HASHTYPE
-        'Signature hash type missing or not understood'
+        "Signature hash type missing or not understood"
       when SCRIPT_ERR_SIG_DER
-        'Non-canonical DER signature'
+        "Non-canonical DER signature"
       when SCRIPT_ERR_MINIMALDATA
-        'Data push larger than necessary'
+        "Data push larger than necessary"
       when SCRIPT_ERR_SIG_PUSHONLY
-        'Only non-push operators allowed in signatures'
+        "Only non-push operators allowed in signatures"
       when SCRIPT_ERR_SIG_HIGH_S
-        'Non-canonical signature S value is unnecessarily high'
+        "Non-canonical signature S value is unnecessarily high"
       when SCRIPT_ERR_SIG_NULLDUMMY
-        'Dummy CHECKMULTISIG argument must be zero'
+        "Dummy CHECKMULTISIG argument must be zero"
       when SCRIPT_ERR_MINIMALIF
-        'OP_IF/NOTIF argument must be minimal'
+        "OP_IF/NOTIF argument must be minimal"
       when SCRIPT_ERR_SIG_NULLFAIL
-        'Signature must be zero for failed CHECK(MULTI)SIG operation'
+        "Signature must be zero for failed CHECK(MULTI)SIG operation"
       when SCRIPT_ERR_DISCOURAGE_UPGRADABLE_NOPS
-        'NOPx reserved for soft-fork upgrades'
+        "NOPx reserved for soft-fork upgrades"
       when SCRIPT_ERR_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM
-        'Witness version reserved for soft-fork upgrades'
+        "Witness version reserved for soft-fork upgrades"
       when SCRIPT_ERR_PUBKEYTYPE
-        'Public key is neither compressed or uncompressed'
+        "Public key is neither compressed or uncompressed"
       when SCRIPT_ERR_OP_CODESEPARATOR
-        'Using OP_CODESEPARATOR in non-witness scrip'
+        "Using OP_CODESEPARATOR in non-witness scrip"
       when SCRIPT_ERR_SIG_FINDANDDELETE
-        'Signature is found in scriptCode'
+        "Signature is found in scriptCode"
       when SCRIPT_ERR_OP_COLOR_UNEXPECTED
-        'Unexpected OP_COLOR in script'
+        "Unexpected OP_COLOR in script"
       when SCRIPT_ERR_OP_COLOR_ID_INVALID
-        'Invalid ColorId in script'
+        "Invalid ColorId in script"
       when SCRIPT_ERR_OP_COLOR_MULTIPLE
-        'Multiple OP_COLOR found in script'
+        "Multiple OP_COLOR found in script"
       when SCRIPT_ERR_OP_COLOR_IN_BRANCH
-        'OP_COLOR is not permitted in a script branch'
+        "OP_COLOR is not permitted in a script branch"
       when SCRIPT_ERR_UNKNOWN_ERROR, SCRIPT_ERR_ERROR_COUNT
-        'unknown error'
+        "unknown error"
       else
-        extra_msg ? extra_msg : 'unknown error'
+        extra_msg ? extra_msg : "unknown error"
       end
     end
 

data/lib/tapyrus/script/script_interpreter.rb

@@ -70,7 +70,7 @@ module Tapyrus
         return set_error(SCRIPT_ERR_SIG_PUSHONLY) unless script_sig.push_only?
         tmp = stack
         @stack = stack_copy
-        raise 'stack cannot be empty.' if stack.empty?
+        raise "stack cannot be empty." if stack.empty?
         begin
           redeem_script = Tapyrus::Script.parse_from_payload(stack.pop.htb)
         rescue Exception => e
@@ -86,7 +86,7 @@ module Tapyrus
       if flag?(SCRIPT_VERIFY_CLEANSTACK)
         # Disallow CLEANSTACK without P2SH, as otherwise a switch CLEANSTACK->P2SH+CLEANSTACK would be possible,
         # which is not a softfork (and P2SH should be one).
-        raise 'assert' unless flag?(SCRIPT_VERIFY_P2SH)
+        raise "assert" unless flag?(SCRIPT_VERIFY_P2SH)
         return set_error(SCRIPT_ERR_CLEANSTACK) unless stack.size == 1
       end
 
@@ -146,7 +146,7 @@ module Tapyrus
         else
           case opcode
           when OP_0
-            stack << ''
+            stack << ""
           when OP_DEPTH
             push_int(stack.size)
           when OP_EQUAL, OP_EQUALVERIFY
@@ -184,7 +184,7 @@ module Tapyrus
               return set_error(SCRIPT_ERR_UNBALANCED_CONDITIONAL) if stack.size < 1
               value = pop_string.htb
               if flag?(SCRIPT_VERIFY_MINIMALIF)
-                if value.bytesize > 1 || (value.bytesize == 1 && value[0].unpack('C').first != 1)
+                if value.bytesize > 1 || (value.bytesize == 1 && value[0].unpack("C").first != 1)
                   return set_error(SCRIPT_ERR_MINIMALIF)
                 end
               end
@@ -585,7 +585,7 @@ module Tapyrus
       raise '"script number overflow"' if data.bytesize > max_num_size
       if require_minimal && data.bytesize > 0
         if data.bytes[-1] & 0x7f == 0 && (data.bytesize <= 1 || data.bytes[data.bytesize - 2] & 0x80 == 0)
-          raise 'non-minimally encoded script number'
+          raise "non-minimally encoded script number"
         end
       end
       Script.decode_number(s)
@@ -644,7 +644,7 @@ module Tapyrus
     def defined_hashtype_signature?(signature)
       sig = signature.htb
       return false if sig.empty?
-      s = sig.unpack('C*')
+      s = sig.unpack("C*")
       hash_type = s[-1] & (~(SIGHASH_TYPE[:anyonecanpay]))
       return false if hash_type < SIGHASH_TYPE[:all] || hash_type > SIGHASH_TYPE[:single]
       true
@@ -680,13 +680,13 @@ module Tapyrus
         case opcode
         when OP_PUSHDATA1
           offset += 1
-          buf.read(1).unpack('C').first
+          buf.read(1).unpack("C").first
         when OP_PUSHDATA2
           offset += 2
-          buf.read(2).unpack('v').first
+          buf.read(2).unpack("v").first
         when OP_PUSHDATA4
           offset += 4
-          buf.read(4).unpack('V').first
+          buf.read(4).unpack("V").first
         else
           opcode
         end

data/lib/tapyrus/script/tx_checker.rb

@@ -16,7 +16,7 @@ module Tapyrus
     def check_sig(script_sig, pubkey, script_code)
       return false if script_sig.empty?
       script_sig = script_sig.htb
-      hash_type = script_sig[-1].unpack('C').first
+      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)
       verify_sig(sig.bth, pubkey, sighash)
@@ -29,7 +29,7 @@ module Tapyrus
     # @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]
+        pubkey.start_with?("02") || pubkey.start_with?("03") ? Key::TYPES[:compressed] : Key::TYPES[:uncompressed]
       sig = sig.htb
       algo = sig.bytesize == 64 ? :schnorr : :ecdsa
       begin

data/lib/tapyrus/secp256k1/native.rb

@@ -31,26 +31,26 @@ module Tapyrus
       module_function
 
       def init
-        raise 'secp256k1 library dose not found.' unless File.exist?(ENV['SECP256K1_LIB_PATH'])
-        ffi_lib(ENV['SECP256K1_LIB_PATH'])
+        raise "secp256k1 library dose not found." unless File.exist?(ENV["SECP256K1_LIB_PATH"])
+        ffi_lib(ENV["SECP256K1_LIB_PATH"])
         load_functions
       end
 
       def load_functions
         attach_function(:secp256k1_context_create, [:uint], :pointer)
         attach_function(:secp256k1_context_destroy, [:pointer], :void)
-        attach_function(:secp256k1_context_randomize, [:pointer, :pointer], :int)
-        attach_function(:secp256k1_ec_pubkey_create, [:pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ec_seckey_verify, [:pointer, :pointer], :int)
-        attach_function(:secp256k1_ecdsa_sign, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ec_pubkey_serialize, [:pointer, :pointer, :pointer, :pointer, :uint], :int)
-        attach_function(:secp256k1_ecdsa_signature_serialize_der, [:pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ec_pubkey_parse, [:pointer, :pointer, :pointer, :size_t], :int)
-        attach_function(:secp256k1_ecdsa_signature_parse_der, [:pointer, :pointer, :pointer, :size_t], :int)
-        attach_function(:secp256k1_ecdsa_signature_normalize, [:pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_ecdsa_verify, [:pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_schnorr_sign, [:pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :int)
-        attach_function(:secp256k1_schnorr_verify, [:pointer, :pointer, :pointer, :pointer], :int)
+        attach_function(:secp256k1_context_randomize, %i[pointer pointer], :int)
+        attach_function(:secp256k1_ec_pubkey_create, %i[pointer pointer pointer], :int)
+        attach_function(:secp256k1_ec_seckey_verify, %i[pointer pointer], :int)
+        attach_function(:secp256k1_ecdsa_sign, %i[pointer pointer pointer pointer pointer pointer], :int)
+        attach_function(:secp256k1_ec_pubkey_serialize, %i[pointer pointer pointer pointer uint], :int)
+        attach_function(:secp256k1_ecdsa_signature_serialize_der, %i[pointer pointer pointer pointer], :int)
+        attach_function(:secp256k1_ec_pubkey_parse, %i[pointer pointer pointer size_t], :int)
+        attach_function(:secp256k1_ecdsa_signature_parse_der, %i[pointer pointer pointer size_t], :int)
+        attach_function(:secp256k1_ecdsa_signature_normalize, %i[pointer pointer pointer], :int)
+        attach_function(:secp256k1_ecdsa_verify, %i[pointer pointer pointer pointer], :int)
+        attach_function(:secp256k1_schnorr_sign, %i[pointer pointer pointer pointer pointer pointer], :int)
+        attach_function(:secp256k1_schnorr_verify, %i[pointer pointer pointer pointer], :int)
       end
 
       def with_context(flags: (SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN))
@@ -59,7 +59,7 @@ module Tapyrus
           context = secp256k1_context_create(flags)
           ret, tries, max = 0, 0, 20
           while ret != 1
-            raise 'secp256k1_context_randomize failed.' if tries >= max
+            raise "secp256k1_context_randomize failed." if tries >= max
             tries += 1
             ret = secp256k1_context_randomize(context, FFI::MemoryPointer.from_string(SecureRandom.random_bytes(32)))
           end
@@ -74,7 +74,7 @@ module Tapyrus
         with_context do |context|
           ret, tries, max = 0, 0, 20
           while ret != 1
-            raise 'secp256k1_ec_seckey_verify in generate_key_pair failed.' if tries >= max
+            raise "secp256k1_ec_seckey_verify in generate_key_pair failed." if tries >= max
             tries += 1
             priv_key = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, SecureRandom.random_bytes(32))
             ret = secp256k1_ec_seckey_verify(context, priv_key)
@@ -145,7 +145,7 @@ module Tapyrus
       def generate_pubkey_in_context(context, privkey, compressed: true)
         internal_pubkey = FFI::MemoryPointer.new(:uchar, 64)
         result = secp256k1_ec_pubkey_create(context, internal_pubkey, privkey.htb)
-        raise 'error creating pubkey' unless result
+        raise "error creating pubkey" unless result
 
         pubkey = FFI::MemoryPointer.new(:uchar, 65)
         pubkey_len = FFI::MemoryPointer.new(:uint64)
@@ -157,14 +157,14 @@ module Tapyrus
             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
+        raise "error serialize pubkey" unless result || pubkey_len.read_uint64 > 0
         pubkey.read_string(pubkey_len.read_uint64).bth
       end
 
       def sign_ecdsa(data, privkey, extra_entropy)
         with_context do |context|
           secret = FFI::MemoryPointer.new(:uchar, privkey.htb.bytesize).put_bytes(0, privkey.htb)
-          raise 'priv_key invalid' unless secp256k1_ec_seckey_verify(context, secret)
+          raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, secret)
 
           internal_signature = FFI::MemoryPointer.new(:uchar, 64)
           msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
@@ -173,7 +173,7 @@ module Tapyrus
           ret, tries, max = 0, 0, 20
 
           while ret != 1
-            raise 'secp256k1_ecdsa_sign failed.' if tries >= max
+            raise "secp256k1_ecdsa_sign failed." if tries >= max
             tries += 1
             ret = secp256k1_ecdsa_sign(context, internal_signature, msg32, secret, nil, entropy)
           end
@@ -181,7 +181,7 @@ module Tapyrus
           signature = FFI::MemoryPointer.new(:uchar, 72)
           signature_len = FFI::MemoryPointer.new(:uint64).put_uint64(0, 72)
           result = secp256k1_ecdsa_signature_serialize_der(context, signature, signature_len, internal_signature)
-          raise 'secp256k1_ecdsa_signature_serialize_der failed' unless result
+          raise "secp256k1_ecdsa_signature_serialize_der failed" unless result
 
           signature.read_string(signature_len.read_uint64)
         end
@@ -190,12 +190,12 @@ module Tapyrus
       def sign_schnorr(data, privkey)
         with_context do |context|
           secret = FFI::MemoryPointer.new(:uchar, privkey.htb.bytesize).put_bytes(0, privkey.htb)
-          raise 'priv_key invalid' unless secp256k1_ec_seckey_verify(context, secret)
+          raise "priv_key invalid" unless secp256k1_ec_seckey_verify(context, secret)
 
           signature = FFI::MemoryPointer.new(:uchar, 64)
           msg32 = FFI::MemoryPointer.new(:uchar, 32).put_bytes(0, data)
           unless secp256k1_schnorr_sign(context, signature, msg32, secret, nil, nil) == 1
-            raise 'Failed to generate schnorr signature.'
+            raise "Failed to generate schnorr signature."
           end
           signature.read_string(64)
         end

data/lib/tapyrus/secp256k1/rfc6979.rb

@@ -1,10 +1,10 @@
 module Tapyrus
   module Secp256k1
     module RFC6979
-      INITIAL_V = '0101010101010101010101010101010101010101010101010101010101010101'.htb
-      INITIAL_K = '0000000000000000000000000000000000000000000000000000000000000000'.htb
-      ZERO_B = '00'.htb
-      ONE_B = '01'.htb
+      INITIAL_V = "0101010101010101010101010101010101010101010101010101010101010101".htb
+      INITIAL_K = "0000000000000000000000000000000000000000000000000000000000000000".htb
+      ZERO_B = "00".htb
+      ONE_B = "01".htb
 
       module_function
 
@@ -30,16 +30,16 @@ module Tapyrus
         v = Tapyrus.hmac_sha256(k, v)
 
         # 3.2.h
-        t = ''
+        t = ""
         10_000.times do
           v = Tapyrus.hmac_sha256(k, v)
           t = (t + v)
           t_num = t.bth.to_i(16)
           return t_num if 1 <= t_num && t_num < Tapyrus::Secp256k1::GROUP.order
-          k = Tapyrus.hmac_sha256(k, v + '00'.htb)
+          k = Tapyrus.hmac_sha256(k, v + "00".htb)
           v = Tapyrus.hmac_sha256(k, v)
         end
-        raise 'A valid nonce was not found.'
+        raise "A valid nonce was not found."
       end
     end
   end

data/lib/tapyrus/secp256k1/ruby.rb

@@ -90,7 +90,7 @@ module Tapyrus
       def sign_ecdsa(data, privkey, extra_entropy)
         privkey = privkey.htb
         private_key = ECDSA::Format::IntegerOctetString.decode(privkey)
-        extra_entropy ||= ''
+        extra_entropy ||= ""
         nonce = RFC6979.generate_rfc6979_nonce(privkey + data, extra_entropy)
 
         # port form ecdsa gem.
@@ -112,7 +112,7 @@ module Tapyrus
 
         signature = ECDSA::Signature.new(r, s).to_der
         public_key = Tapyrus::Key.new(priv_key: privkey.bth).pubkey
-        raise 'Creation of signature failed.' unless Tapyrus::Secp256k1::Ruby.verify_sig(data, signature, public_key)
+        raise "Creation of signature failed." unless Tapyrus::Secp256k1::Ruby.verify_sig(data, signature, public_key)
         signature
       end
 

data/lib/tapyrus/secp256k1.rb

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

data/lib/tapyrus/slip39/share.rb

@@ -16,20 +16,20 @@ module Tapyrus
       # @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)
+        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
+            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)
+        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
+        raise ArgumentError, "Invalid mnemonic length." if padding_length > 8
+        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)
@@ -47,7 +47,7 @@ module Tapyrus
         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