tapyrus 0.1.0

data/lib/tapyrus/ext_key.rb

@@ -0,0 +1,337 @@
+module Tapyrus
+
+  # Integers modulo the order of the curve(secp256k1)
+  CURVE_ORDER = ECDSA::Group::Secp256k1.order
+
+  # BIP32 Extended private key
+  class ExtKey
+
+    attr_accessor :ver
+    attr_accessor :depth
+    attr_accessor :number
+    attr_accessor :chain_code
+    attr_accessor :key # Tapyrus::Key
+    attr_accessor :parent_fingerprint
+
+    # generate master key from seed.
+    # @params [String] seed a seed data with hex format.
+    def self.generate_master(seed)
+      ext_key = ExtKey.new
+      ext_key.depth = ext_key.number = 0
+      ext_key.parent_fingerprint = '00000000'
+      l = Tapyrus.hmac_sha512('Bitcoin seed', seed.htb)
+      left = l[0..31].bth.to_i(16)
+      raise 'invalid key' if left >= CURVE_ORDER || left == 0
+      ext_key.key = Tapyrus::Key.new(priv_key: l[0..31].bth, key_type: Tapyrus::Key::TYPES[:compressed])
+      ext_key.chain_code = l[32..-1]
+      ext_key
+    end
+
+    # get ExtPubkey from priv_key
+    def ext_pubkey
+      k = ExtPubkey.new
+      k.depth = depth
+      k.number = number
+      k.parent_fingerprint = parent_fingerprint
+      k.chain_code = chain_code
+      k.pubkey = key.pubkey
+      k.ver = priv_ver_to_pub_ver
+      k
+    end
+
+    # serialize extended private key
+    def to_payload
+      version.htb << [depth].pack('C') << parent_fingerprint.htb <<
+          [number].pack('N') << chain_code << [0x00].pack('C') << key.priv_key.htb
+    end
+
+    # Base58 encoded extended private key
+    def to_base58
+      h = to_payload.bth
+      hex = h + Tapyrus.calc_checksum(h)
+      Base58.encode(hex)
+    end
+
+    # get private key(hex)
+    def priv
+      key.priv_key
+    end
+
+    # get public key(hex)
+    def pub
+      key.pubkey
+    end
+
+    def hash160
+      Tapyrus.hash160(pub)
+    end
+
+    # get address
+    def addr
+      ext_pubkey.addr
+    end
+
+    # get key identifier
+    def identifier
+      Tapyrus.hash160(key.pubkey)
+    end
+
+    # get fingerprint
+    def fingerprint
+      identifier.slice(0..7)
+    end
+
+    # whether hardened key.
+    def hardened?
+      number >= Tapyrus::HARDENED_THRESHOLD
+    end
+
+    # derive new key
+    # @param [Integer] number a child index
+    # @param [Boolean] harden whether hardened key or not. If true, 2^31 is added to +number+.
+    # @return [Tapyrus::ExtKey] derived new key.
+    def derive(number, harden = false)
+      number += Tapyrus::HARDENED_THRESHOLD if harden
+      new_key = ExtKey.new
+      new_key.depth = depth + 1
+      new_key.number = number
+      new_key.parent_fingerprint = fingerprint
+      if number > (Tapyrus::HARDENED_THRESHOLD - 1)
+        data = [0x00].pack('C') << key.priv_key.htb << [number].pack('N')
+      else
+        data = key.pubkey.htb << [number].pack('N')
+      end
+      l = Tapyrus.hmac_sha512(chain_code, data)
+      left = l[0..31].bth.to_i(16)
+      raise 'invalid key' if left >= CURVE_ORDER
+      child_priv = (left + key.priv_key.to_i(16)) % CURVE_ORDER
+      raise 'invalid key ' if child_priv >= CURVE_ORDER
+      new_key.key = Tapyrus::Key.new(
+          priv_key: child_priv.to_even_length_hex.rjust(64, '0'), key_type: key_type)
+      new_key.chain_code = l[32..-1]
+      new_key.ver = version
+      new_key
+    end
+
+    # get version bytes using serialization format
+    def version
+      return ExtKey.version_from_purpose(number) if depth == 1
+      ver ? ver : Tapyrus.chain_params.extended_privkey_version
+    end
+
+    # get key type defined by BIP-178 using version.
+    def key_type
+      v = version
+      case v
+      when Tapyrus.chain_params.bip49_privkey_p2wpkh_p2sh_version
+        Tapyrus::Key::TYPES[:p2wpkh_p2sh]
+      when Tapyrus.chain_params.bip84_privkey_p2wpkh_version
+        Tapyrus::Key::TYPES[:p2wpkh]
+      when Tapyrus.chain_params.extended_privkey_version
+        Tapyrus::Key::TYPES[:compressed]
+      end
+    end
+
+    def ==(other)
+      to_payload == other.to_payload
+    end
+
+    def self.parse_from_payload(payload)
+      buf = StringIO.new(payload)
+      ext_key = ExtKey.new
+      ext_key.ver = buf.read(4).bth # version
+      raise 'An unsupported version byte was specified.' unless ExtKey.support_version?(ext_key.ver)
+      ext_key.depth = buf.read(1).unpack('C').first
+      ext_key.parent_fingerprint = buf.read(4).bth
+      ext_key.number = buf.read(4).unpack('N').first
+      ext_key.chain_code = buf.read(32)
+      buf.read(1) # 0x00
+      ext_key.key = Tapyrus::Key.new(priv_key: buf.read(32).bth, key_type: Tapyrus::Key::TYPES[:compressed])
+      ext_key
+    end
+
+    # import private key from Base58 private key address
+    def self.from_base58(address)
+      ExtKey.parse_from_payload(Base58.decode(address).htb)
+    end
+
+    # get version bytes from purpose' value.
+    def self.version_from_purpose(purpose)
+      v = purpose - Tapyrus::HARDENED_THRESHOLD
+      case v
+        when 49
+          Tapyrus.chain_params.bip49_privkey_p2wpkh_p2sh_version
+        when 84
+          Tapyrus.chain_params.bip84_privkey_p2wpkh_version
+        else
+          Tapyrus.chain_params.extended_privkey_version
+      end
+    end
+
+    # check whether +version+ is supported version bytes.
+    def self.support_version?(version)
+      p = Tapyrus.chain_params
+      [p.bip49_privkey_p2wpkh_p2sh_version, p.bip84_privkey_p2wpkh_version, p.extended_privkey_version].include?(version)
+    end
+
+    # convert privkey version to pubkey version
+    def priv_ver_to_pub_ver
+      case version
+        when Tapyrus.chain_params.bip49_privkey_p2wpkh_p2sh_version
+          Tapyrus.chain_params.bip49_pubkey_p2wpkh_p2sh_version
+        when Tapyrus.chain_params.bip84_privkey_p2wpkh_version
+          Tapyrus.chain_params.bip84_pubkey_p2wpkh_version
+        else
+          Tapyrus.chain_params.extended_pubkey_version
+      end
+    end
+
+  end
+
+  # BIP-32 Extended public key
+  class ExtPubkey
+
+    attr_accessor :ver
+    attr_accessor :depth
+    attr_accessor :number
+    attr_accessor :chain_code
+    attr_accessor :pubkey # hex format
+    attr_accessor :parent_fingerprint
+
+    # serialize extended pubkey
+    def to_payload
+      version.htb << [depth].pack('C') <<
+          parent_fingerprint.htb << [number].pack('N') << chain_code << pub.htb
+    end
+
+    def pub
+      pubkey
+    end
+
+    def hash160
+      Tapyrus.hash160(pub)
+    end
+
+    # get address
+    def addr
+      case version
+        when Tapyrus.chain_params.bip49_pubkey_p2wpkh_p2sh_version
+          key.to_nested_p2wpkh
+        when Tapyrus.chain_params.bip84_pubkey_p2wpkh_version
+          key.to_p2wpkh
+        else
+          key.to_p2pkh
+      end
+    end
+
+    # get key object
+    # @return [Tapyrus::Key]
+    def key
+      Tapyrus::Key.new(pubkey: pubkey, key_type: key_type)
+    end
+
+    # get key identifier
+    def identifier
+      Tapyrus.hash160(pub)
+    end
+
+    # get fingerprint
+    def fingerprint
+      identifier.slice(0..7)
+    end
+
+    # Base58 encoded extended pubkey
+    def to_base58
+      h = to_payload.bth
+      hex = h + Tapyrus.calc_checksum(h)
+      Base58.encode(hex)
+    end
+
+    # whether hardened key.
+    def hardened?
+      number >= Tapyrus::HARDENED_THRESHOLD
+    end
+
+    # derive child key
+    def derive(number)
+      new_key = ExtPubkey.new
+      new_key.depth = depth + 1
+      new_key.number = number
+      new_key.parent_fingerprint = fingerprint
+      raise 'hardened key is not support' if number > (Tapyrus::HARDENED_THRESHOLD - 1)
+      data = pub.htb << [number].pack('N')
+      l = Tapyrus.hmac_sha512(chain_code, data)
+      left = l[0..31].bth.to_i(16)
+      raise 'invalid key' if left >= CURVE_ORDER
+      p1 = Tapyrus::Secp256k1::GROUP.generator.multiply_by_scalar(left)
+      p2 = Tapyrus::Key.new(pubkey: pubkey, key_type: key_type).to_point
+      new_key.pubkey = ECDSA::Format::PointOctetString.encode(p1 + p2, compression: true).bth
+      new_key.chain_code = l[32..-1]
+      new_key.ver = version
+      new_key
+    end
+
+    # get version bytes using serialization format
+    def version
+      return ExtPubkey.version_from_purpose(number) if depth == 1
+      ver ? ver : Tapyrus.chain_params.extended_pubkey_version
+    end
+
+    # get key type defined by BIP-178 using version.
+    def key_type
+      v = version
+      case v
+      when Tapyrus.chain_params.bip49_pubkey_p2wpkh_p2sh_version
+        Tapyrus::Key::TYPES[:p2wpkh_p2sh]
+      when Tapyrus.chain_params.bip84_pubkey_p2wpkh_version
+        Tapyrus::Key::TYPES[:p2wpkh]
+      when Tapyrus.chain_params.extended_pubkey_version
+        Tapyrus::Key::TYPES[:compressed]
+      end
+    end
+
+    def ==(other)
+      to_payload == other.to_payload
+    end
+
+    def self.parse_from_payload(payload)
+      buf = StringIO.new(payload)
+      ext_pubkey = ExtPubkey.new
+      ext_pubkey.ver = buf.read(4).bth # version
+      raise 'An unsupported version byte was specified.' unless ExtPubkey.support_version?(ext_pubkey.ver)
+      ext_pubkey.depth = buf.read(1).unpack('C').first
+      ext_pubkey.parent_fingerprint = buf.read(4).bth
+      ext_pubkey.number = buf.read(4).unpack('N').first
+      ext_pubkey.chain_code = buf.read(32)
+      ext_pubkey.pubkey = buf.read(33).bth
+      ext_pubkey
+    end
+
+
+    # import pub key from Base58 private key address
+    def self.from_base58(address)
+      ExtPubkey.parse_from_payload(Base58.decode(address).htb)
+    end
+
+    # get version bytes from purpose' value.
+    def self.version_from_purpose(purpose)
+      v = purpose - Tapyrus::HARDENED_THRESHOLD
+      case v
+        when 49
+          Tapyrus.chain_params.bip49_pubkey_p2wpkh_p2sh_version
+        when 84
+          Tapyrus.chain_params.bip84_pubkey_p2wpkh_version
+        else
+          Tapyrus.chain_params.extended_pubkey_version
+      end
+    end
+
+    # check whether +version+ is supported version bytes.
+    def self.support_version?(version)
+      p = Tapyrus.chain_params
+      [p.bip49_pubkey_p2wpkh_p2sh_version, p.bip84_pubkey_p2wpkh_version, p.extended_pubkey_version].include?(version)
+    end
+
+  end
+
+end

data/lib/tapyrus/key.rb

@@ -0,0 +1,296 @@
+# Porting part of the code from bitcoin-ruby. see the license.
+# https://github.com/lian/bitcoin-ruby/blob/master/COPYING
+
+module Tapyrus
+
+  # tapyrus key class
+  class Key
+
+    PUBLIC_KEY_SIZE = 65
+    COMPRESSED_PUBLIC_KEY_SIZE = 33
+    SIGNATURE_SIZE = 72
+    COMPACT_SIGNATURE_SIZE = 65
+
+    attr_accessor :priv_key
+    attr_accessor :pubkey
+    attr_accessor :key_type
+    attr_reader :secp256k1_module
+
+    TYPES = {uncompressed: 0x00, compressed: 0x01, p2pkh: 0x10, p2wpkh: 0x11, p2wpkh_p2sh: 0x12}
+
+    MIN_PRIV_KEY_MOD_ORDER = 0x01
+    # Order of secp256k1's generator minus 1.
+    MAX_PRIV_KEY_MOD_ORDER = ECDSA::Group::Secp256k1.order - 1
+
+    # initialize private key
+    # @param [String] priv_key a private key with hex format.
+    # @param [String] pubkey a public key with hex format.
+    # @param [Integer] key_type a key type which determine address type.
+    # @param [Boolean] compressed [Deprecated] whether public key is compressed.
+    # @return [Tapyrus::Key] a key object.
+    def initialize(priv_key: nil, pubkey: nil, key_type: nil, compressed: true)
+      puts "[Warning] Use key_type parameter instead of compressed. compressed parameter removed in the future." if key_type.nil? && !compressed.nil? && pubkey.nil?
+      if key_type
+        @key_type = key_type
+        compressed = @key_type != TYPES[:uncompressed]
+      else
+        @key_type = compressed ? TYPES[:compressed] : TYPES[:uncompressed]
+      end
+      @secp256k1_module =  Tapyrus.secp_impl
+      @priv_key = priv_key
+      if @priv_key
+        raise ArgumentError, 'private key is not on curve' unless validate_private_key_range(@priv_key)
+      end
+      if pubkey
+        @pubkey = pubkey
+      else
+        @pubkey = generate_pubkey(priv_key, compressed: compressed) if priv_key
+      end
+    end
+
+    # generate key pair
+    def self.generate(key_type = TYPES[:compressed])
+      priv_key, pubkey = Tapyrus.secp_impl.generate_key_pair
+      new(priv_key: priv_key, pubkey: pubkey, key_type: key_type)
+    end
+
+    # import private key from wif format
+    # https://en.bitcoin.it/wiki/Wallet_import_format
+    def self.from_wif(wif)
+      hex = Base58.decode(wif)
+      raise ArgumentError, 'data is too short' if hex.htb.bytesize < 4
+      version = hex[0..1]
+      data = hex[2...-8].htb
+      checksum = hex[-8..-1]
+      raise ArgumentError, 'invalid version' unless version == Tapyrus.chain_params.privkey_version
+      raise ArgumentError, 'invalid checksum' unless Tapyrus.calc_checksum(version + data.bth) == checksum
+      key_len = data.bytesize
+      if key_len == COMPRESSED_PUBLIC_KEY_SIZE && data[-1].unpack('C').first == 1
+        key_type = TYPES[:compressed]
+        data = data[0..-2]
+      elsif key_len == 32
+        key_type = TYPES[:uncompressed]
+      else
+        raise ArgumentError, 'Wrong number of bytes for a private key, not 32 or 33'
+      end
+      new(priv_key: data.bth, key_type: key_type)
+    end
+
+    # export private key with wif format
+    def to_wif
+      version = Tapyrus.chain_params.privkey_version
+      hex = version + priv_key
+      hex += '01' if compressed?
+      hex += Tapyrus.calc_checksum(hex)
+      Base58.encode(hex)
+    end
+
+    # sign +data+ with private key
+    # @param [String] data a data to be signed with binary format
+    # @param [Boolean] low_r flag to apply low-R.
+    # @param [String] extra_entropy the extra entropy for rfc6979.
+    # @return [String] signature data with binary format
+    def sign(data, low_r = true, extra_entropy = nil)
+      sig = secp256k1_module.sign_data(data, priv_key, extra_entropy)
+      if low_r && !sig_has_low_r?(sig)
+        counter = 1
+        until sig_has_low_r?(sig)
+          extra_entropy = [counter].pack('I*').bth.ljust(64, '0').htb
+          sig = secp256k1_module.sign_data(data, priv_key, extra_entropy)
+          counter += 1
+        end
+      end
+      sig
+    end
+
+    # verify signature using public key
+    # @param [String] sig signature data with binary format
+    # @param [String] origin original message
+    # @return [Boolean] verify result
+    def verify(sig, origin)
+      return false unless valid_pubkey?
+      begin
+        sig = ecdsa_signature_parse_der_lax(sig)
+        secp256k1_module.verify_sig(origin, sig, pubkey)
+      rescue Exception
+        false
+      end
+    end
+
+    # get hash160 public key.
+    def hash160
+      Tapyrus.hash160(pubkey)
+    end
+
+    # get pay to pubkey hash address
+    # @deprecated
+    def to_p2pkh
+      Tapyrus::Script.to_p2pkh(hash160).addresses.first
+    end
+
+    # get pay to witness pubkey hash address
+    # @deprecated
+    def to_p2wpkh
+      Tapyrus::Script.to_p2wpkh(hash160).addresses.first
+    end
+
+    # get p2wpkh address nested in p2sh.
+    # @deprecated
+    def to_nested_p2wpkh
+      Tapyrus::Script.to_p2wpkh(hash160).to_p2sh.addresses.first
+    end
+
+    def compressed?
+      key_type != TYPES[:uncompressed]
+    end
+
+    # generate pubkey ec point
+    # @return [ECDSA::Point]
+    def to_point
+      p = pubkey
+      p ||= generate_pubkey(priv_key, compressed: compressed)
+      ECDSA::Format::PointOctetString.decode(p.htb, Tapyrus::Secp256k1::GROUP)
+    end
+
+    # check +pubkey+ (hex) is compress or uncompress pubkey.
+    def self.compress_or_uncompress_pubkey?(pubkey)
+      p = pubkey.htb
+      return false if p.bytesize < COMPRESSED_PUBLIC_KEY_SIZE
+      case p[0]
+        when "\x04"
+          return false unless p.bytesize == PUBLIC_KEY_SIZE
+        when "\x02", "\x03"
+          return false unless p.bytesize == COMPRESSED_PUBLIC_KEY_SIZE
+        else
+          return false
+      end
+      true
+    end
+
+    # check +pubkey+ (hex) is compress pubkey.
+    def self.compress_pubkey?(pubkey)
+      p = pubkey.htb
+      p.bytesize == COMPRESSED_PUBLIC_KEY_SIZE && ["\x02", "\x03"].include?(p[0])
+    end
+
+    # check +sig+ is low.
+    def self.low_signature?(sig)
+      s = sig.unpack('C*')
+      len_r = s[3]
+      len_s = s[5 + len_r]
+      val_s = s.slice(6 + len_r, len_s)
+      max_mod_half_order = [
+          0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+          0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+          0x5d,0x57,0x6e,0x73,0x57,0xa4,0x50,0x1d,
+          0xdf,0xe9,0x2f,0x46,0x68,0x1b,0x20,0xa0]
+      compare_big_endian(val_s, [0]) > 0 &&
+          compare_big_endian(val_s, max_mod_half_order) <= 0
+    end
+
+
+    # check +sig+ is correct der encoding.
+    # This function is consensus-critical since BIP66.
+    def self.valid_signature_encoding?(sig)
+      return false if sig.bytesize < 9 || sig.bytesize > 73 # Minimum and maximum size check
+
+      s = sig.unpack('C*')
+
+      return false if s[0] != 0x30 || s[1] != s.size - 3 # A signature is of type 0x30 (compound). Make sure the length covers the entire signature.
+
+      len_r = s[3]
+      return false if 5 + len_r >= s.size # Make sure the length of the S element is still inside the signature.
+
+      len_s = s[5 + len_r]
+      return false unless len_r + len_s + 7 == s.size #Verify that the length of the signature matches the sum of the length of the elements.
+
+      return false unless s[2] == 0x02 # Check whether the R element is an integer.
+
+      return false if len_r == 0 # Zero-length integers are not allowed for R.
+
+      return false unless s[4] & 0x80 == 0 # Negative numbers are not allowed for R.
+
+      # Null bytes at the start of R are not allowed, unless R would otherwise be interpreted as a negative number.
+      return false if len_r > 1 && (s[4] == 0x00) && (s[5] & 0x80 == 0)
+
+      return false unless s[len_r + 4] == 0x02 # Check whether the S element is an integer.
+
+      return false if len_s == 0 # Zero-length integers are not allowed for S.
+      return false unless (s[len_r + 6] & 0x80) == 0 # Negative numbers are not allowed for S.
+
+      # Null bytes at the start of S are not allowed, unless S would otherwise be interpreted as a negative number.
+      return false if len_s > 1 && (s[len_r + 6] == 0x00) && (s[len_r + 7] & 0x80 == 0)
+
+      true
+    end
+
+    # fully validate whether this is a valid public key (more expensive than IsValid())
+    def fully_valid_pubkey?
+      return false unless valid_pubkey?
+      begin
+        point = ECDSA::Format::PointOctetString.decode(pubkey.htb, ECDSA::Group::Secp256k1)
+        ECDSA::Group::Secp256k1.valid_public_key?(point)
+      rescue ECDSA::Format::DecodeError
+        false
+      end
+    end
+
+    private
+
+    def self.compare_big_endian(c1, c2)
+      c1, c2 = c1.dup, c2.dup # Clone the arrays
+
+      while c1.size > c2.size
+        return 1 if c1.shift > 0
+      end
+
+      while c2.size > c1.size
+        return -1 if c2.shift > 0
+      end
+
+      c1.size.times{|idx| return c1[idx] - c2[idx] if c1[idx] != c2[idx] }
+      0
+    end
+
+    # generate publick key from private key
+    # @param [String] privkey a private key with string format
+    # @param [Boolean] compressed pubkey compressed?
+    # @return [String] a pubkey which generate from privkey
+    def generate_pubkey(privkey, compressed: true)
+      @secp256k1_module.generate_pubkey(privkey, compressed: compressed)
+    end
+
+    # check private key range.
+    def validate_private_key_range(private_key)
+      value = private_key.to_i(16)
+      MIN_PRIV_KEY_MOD_ORDER <= value && value <= MAX_PRIV_KEY_MOD_ORDER
+    end
+
+    # Supported violations include negative integers, excessive padding, garbage
+    # at the end, and overly long length descriptors. This is safe to use in
+    # Bitcoin because since the activation of BIP66, signatures are verified to be
+    # strict DER before being passed to this module, and we know it supports all
+    # violations present in the blockchain before that point.
+    def ecdsa_signature_parse_der_lax(sig)
+      sig_array = sig.unpack('C*')
+      len_r = sig_array[3]
+      r = sig_array[4...(len_r+4)].pack('C*').bth
+      len_s = sig_array[len_r + 5]
+      s = sig_array[(len_r + 6)...(len_r + 6 + len_s)].pack('C*').bth
+      ECDSA::Signature.new(r.to_i(16), s.to_i(16)).to_der
+    end
+
+    def valid_pubkey?
+      !pubkey.nil? && pubkey.size > 0
+    end
+
+    # check whether the signature is low-R
+    # @param [String] sig the signature data
+    # @return [Boolean] result
+    def sig_has_low_r?(sig)
+      sig[3].bth.to_i(16) == 0x20 && sig[4].bth.to_i(16) < 0x80
+    end
+
+  end
+
+end

data/lib/tapyrus/key_path.rb

@@ -0,0 +1,26 @@
+module Tapyrus
+  module KeyPath
+
+    # key path convert an array of derive number
+    # @param [String] path_string
+    # @return [Array[Integer]] key path numbers.
+    def parse_key_path(path_string)
+      path_string.split('/').map.with_index do|p, index|
+        if index == 0
+          raise ArgumentError.new("#{path_string} is invalid format.") unless p == 'm'
+          next
+        end
+        raise ArgumentError.new("#{path_string} is invalid format.") unless p.delete("'") =~ /^[0-9]+$/
+        (p[-1] == "'" ? p.delete("'").to_i + Tapyrus::HARDENED_THRESHOLD : p.to_i)
+      end[1..-1]
+    end
+
+    # key path numbers convert to path string.
+    # @param [Array[Integer]] key path numbers.
+    # @return [String] path string.
+    def to_key_path(numbers)
+      "m/#{numbers.map{|p| p >= Tapyrus::HARDENED_THRESHOLD ? "#{p - Tapyrus::HARDENED_THRESHOLD}'" : p.to_s}.join('/')}"
+    end
+
+  end
+end

data/lib/tapyrus/logger.rb

@@ -0,0 +1,42 @@
+require 'logger'
+
+module Tapyrus
+
+  # Simple Logger module
+  module Logger
+
+    Format = "%s, [%s#%d #%d] %5s -- %s: %s\n".freeze
+
+    module_function
+
+    # Create a logger with given +name+.log in $HOME/.tapyrusrb/log.
+    def create(name, level = ::Logger::INFO)
+      dir = "#{Tapyrus.base_dir}/log"
+      FileUtils.mkdir_p(dir)
+      logger = ::Logger.new(dir + "/#{name}.log", 10)
+      logger.level = level
+      logger.formatter =  proc do |severity, datetime, progname, msg|
+        Format % [severity[0..0], format_datetime(datetime), $$,
+                  Thread.current.object_id, severity, progname, msg2str(msg)]
+      end
+      logger
+    end
+
+    def self.msg2str(msg)
+      case msg
+        when ::String
+          msg
+        when ::Exception
+          "#{ msg.message } (#{ msg.class })\n" <<
+              (msg.backtrace || []).join("\n")
+        else
+          msg.inspect
+      end
+    end
+
+    def format_datetime(time)
+      time.strftime(@datetime_format || "%Y-%m-%dT%H:%M:%S.%6N ".freeze)
+    end
+
+  end
+end