bitcoinrb 0.0.1

data/lib/bitcoin/key.rb

@@ -0,0 +1,131 @@
+module Bitcoin
+
+  # bitcoin key class
+  class Key
+
+    attr_accessor :priv_key
+    attr_accessor :pubkey
+    attr_accessor :compressed
+
+    def initialize(priv_key: nil, pubkey: nil, compressed: true)
+      extend Bitcoin.secp_impl
+      @priv_key = priv_key
+      if pubkey
+        @pubkey = pubkey
+      else
+        @pubkey = generate_pubkey(priv_key, compressed: compressed) if priv_key
+      end
+      @compressed = compressed
+    end
+
+    # import private key from wif format
+    # https://en.bitcoin.it/wiki/Wallet_import_format
+    def self.from_wif(wif)
+      compressed = wif.size == 52
+      hex = Base58.decode(wif)
+      version, key, flag, checksum = hex.unpack("a2a64a#{compressed ? 2 : 0}a8")
+      raise ArgumentError, 'invalid version' unless version == Bitcoin.chain_params.privkey_version
+      raise ArgumentError, 'invalid checksum' unless Bitcoin.calc_checksum(version + key + flag) == checksum
+      new(priv_key: key, compressed: compressed)
+    end
+
+    # export private key with wif format
+    def to_wif
+      version = Bitcoin.chain_params.privkey_version
+      hex = version + priv_key
+      hex += '01' if compressed?
+      hex += Bitcoin.calc_checksum(hex)
+      Base58.encode(hex)
+    end
+
+    # sign +data+ with private key
+    def sign(data)
+      sign_data(data, priv_key)
+    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)
+      verify_sig(origin, sig, pubkey)
+    end
+
+    # get pay to pubkey hash address
+    def to_p2pkh
+      Bitcoin::Script.to_p2pkh(Bitcoin.hash160(pubkey)).to_addr
+    end
+
+    # get pay to witness pubkey hash address
+    def to_p2wpkh
+      Bitcoin::Script.to_p2wpkh(Bitcoin.hash160(pubkey)).to_addr
+    end
+
+    def compressed?
+      @compressed
+    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, Bitcoin::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 < 33
+      case p[0]
+        when "\x04"
+          return false unless p.bytesize == 65
+        when "\x02", "\x03"
+          return false unless p.bytesize == 33
+        else
+          return false
+      end
+      true
+    end
+
+    # check +pubkey+ (hex) is compress pubkey.
+    def self.compress_pubkey?(pubkey)
+      p = pubkey.htb
+      p.bytesize == 33 && ["\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
+
+    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
+
+  end
+
+end

data/lib/bitcoin/logger.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+module Bitcoin
+
+  # Simple Logger module
+  module Logger
+
+    # Create a logger with given +name+.log in $HOME/.bitcoinrb/log.
+    def self.create(name, level = ::Logger::INFO)
+      dir = "#{Bitcoin.base_dir}/log"
+      FileUtils.mkdir_p(dir)
+      logger = ::Logger.new(dir + "/#{name}.log", 10)
+      logger.level = level
+      logger
+    end
+
+  end
+end

data/lib/bitcoin/merkle_tree.rb

@@ -0,0 +1,120 @@
+module Bitcoin
+
+  # merkle tree
+  class MerkleTree
+
+    attr_accessor :root
+
+    def initialize(root = nil)
+      @root = root
+    end
+
+    def merkle_root
+      root.hash
+    end
+
+    def self.build_from_leaf(txids)
+      nodes = txids.each_slice(2).map{ |m|
+        left = Node.new(m[0])
+        right = Node.new(m[1] ? m[1] : m[0])
+        [left, right]
+      }.flatten
+      new(build_initial_tree(nodes))
+    end
+
+    # https://bitcoin.org/en/developer-reference#creating-a-merkleblock-message
+    def self.build_partial(tx_count, hashes, flags)
+      flags = flags.each_char.map(&:to_i)
+      root = build_initial_tree( Array.new(tx_count) { Node.new })
+      current_node = root
+      hash_index = 0
+      flags.each do |f|
+        current_node.flag = f
+        if f.zero? || current_node.leaf?
+          current_node.hash = hashes[hash_index]
+          hash_index += 1
+        end
+        current_node = current_node.next_partial
+        break if hash_index == hashes.size
+      end
+      new(root)
+    end
+
+    def self.build_initial_tree(nodes)
+      while nodes.size != 1
+        nodes = nodes.each_slice(2).map { |m|
+          parent = Node.new
+          parent.left = m[0]
+          parent.right = m[1] ? m[1] : m[0].dup
+          parent
+        }
+      end
+      nodes.first
+    end
+
+  end
+
+  # node of merkle tree
+  class Node
+
+    attr_accessor :flag
+    attr_accessor :hash
+    attr_accessor :parent
+    attr_accessor :left
+    attr_accessor :right
+
+    def initialize(hash = nil)
+      @hash = hash
+    end
+
+    def left=(node)
+      node.parent = self
+      @left = node
+    end
+
+    def right=(node)
+      node.parent = self
+      @right = node
+    end
+
+    def hash
+      return @hash if @hash
+      self.right = left.dup unless right
+      Digest::SHA256.digest(Digest::SHA256.digest(
+          [right.hash + left.hash].pack('H*').reverse )).reverse.bth
+    end
+
+    def root?
+      parent.nil?
+    end
+
+    def leaf?
+      right.nil? && left.nil?
+    end
+
+    def partial?
+      !flag.nil?
+    end
+
+    def next_partial
+      return nil if root? && (flag.zero? || (left.partial? && right.partial?))
+      return parent.next_partial if flag.zero? || leaf?
+      return left unless left.partial?
+      self.right = left.dup unless right
+      right.partial? ? parent.next_partial : right
+    end
+
+    # calculate the depth of this node in the tree.
+    def depth
+      d = 0
+      current_node = self
+      until current_node.root? do
+        current_node = current_node.parent
+        d += 1
+      end
+      d
+    end
+
+  end
+
+end

data/lib/bitcoin/message.rb

@@ -0,0 +1,42 @@
+module Bitcoin
+  module Message
+
+    autoload :Handler, 'bitcoin/message/handler'
+    autoload :Base, 'bitcoin/message/base'
+    autoload :Inventory, 'bitcoin/message/inventory'
+    autoload :InventoriesParser, 'bitcoin/message/inventories_parser'
+    autoload :HeadersParser, 'bitcoin/message/headers_parser'
+    autoload :Version, 'bitcoin/message/version'
+    autoload :VerAck, 'bitcoin/message/ver_ack'
+    autoload :Addr, 'bitcoin/message/addr'
+    autoload :Block, 'bitcoin/message/block'
+    autoload :FilterLoad, 'bitcoin/message/filter_load'
+    autoload :FilterAdd, 'bitcoin/message/filter_add'
+    autoload :FilterClear, 'bitcoin/message/filter_clear'
+    autoload :MerkleBlock, 'bitcoin/message/merkle_block'
+    autoload :Tx, 'bitcoin/message/tx'
+    autoload :Ping, 'bitcoin/message/ping'
+    autoload :Pong, 'bitcoin/message/pong'
+    autoload :Inv, 'bitcoin/message/inv'
+    autoload :GetBlocks, 'bitcoin/message/get_blocks'
+    autoload :GetHeaders, 'bitcoin/message/get_headers'
+    autoload :Headers, 'bitcoin/message/headers'
+    autoload :GetAddr, 'bitcoin/message/get_addr'
+    autoload :GetData, 'bitcoin/message/get_data'
+    autoload :SendHeaders, 'bitcoin/message/send_headers'
+    autoload :FeeFilter, 'bitcoin/message/fee_filter'
+    autoload :MemPool, 'bitcoin/message/mem_pool'
+    autoload :NotFound, 'bitcoin/message/not_found'
+    autoload :Error, 'bitcoin/message/error'
+    autoload :Reject, 'bitcoin/message/reject'
+    autoload :SendCmpct, 'bitcoin/message/send_cmpct'
+
+    HEADER_SIZE = 24
+    USER_AGENT = "/bitcoinrb:#{Bitcoin::VERSION}/"
+
+    SERVICE_FLAGS = {none: 0, network: 1 << 0, getutxo: 1 << 1, bloom: 1 << 2, witness: 1 << 3, xthin: 1 << 4}
+
+    DEFAULT_STOP_HASH = "00"*32
+
+  end
+end

data/lib/bitcoin/message/addr.rb

@@ -0,0 +1,74 @@
+require 'ipaddr'
+
+module Bitcoin
+  module Message
+
+    # addr message
+    # https://bitcoin.org/en/developer-reference#addr
+    class Addr < Base
+
+      COMMAND = 'addr'
+
+      attr_reader :addrs
+
+      def initialize(addrs = [])
+        @addrs = addrs
+      end
+
+      def self.parse_from_payload(payload)
+        buf = StringIO.new(payload)
+        addr_count = Bitcoin.unpack_var_int_from_io(buf)
+        addr = new
+        addr_count.times do
+          addr.addrs << NetworkAddr.parse_from_payload(buf)
+        end
+        addr
+      end
+
+      def to_payload
+        Bitcoin.pack_var_int(addrs.length) << addrs.map(&:to_payload).join
+      end
+
+    end
+
+    class NetworkAddr
+
+      # unix time.
+      # Nodes advertising their own IP address set this to the current time.
+      # Nodes advertising IP addresses they’ve connected to set this to the last time they connected to that node.
+      # Other nodes just relaying the IP address should not change the time. Nodes can use the time field to avoid relaying old addr messages.
+      attr_accessor :time
+
+      # The services the node advertised in its version message.
+      attr_accessor :services
+
+      attr_accessor :ip
+
+      attr_accessor :port
+
+      def initialize
+        @time = Time.now.to_i
+        @services = Bitcoin::Message::SERVICE_FLAGS[:network]
+      end
+
+      def self.parse_from_payload(payload)
+        buf = payload.is_a?(String) ? StringIO.new(payload) : payload
+        addr = new
+        addr.time = buf.read(4).unpack('V').first
+        addr.services = buf.read(8).unpack('Q').first
+        ip = IPAddr::new_ntoh(buf.read(16))
+        addr.ip = ip.ipv4_mapped? ? ip.native : ip.to_s
+        addr.port = buf.read(2).unpack('n').first
+        addr
+      end
+
+      def to_payload
+        ip_addr = IPAddr.new (ip)
+        ip_addr = ip_addr.ipv4_mapped if ip_addr.ipv4?
+        [time, services].pack('VQ') << ip_addr.hton << [port].pack('n')
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/message/base.rb

@@ -0,0 +1,40 @@
+module Bitcoin
+  module Message
+
+    # Base message class
+    class Base
+      include Bitcoin::Util
+      extend Bitcoin::Util
+
+      # generate message header (binary format)
+      # https://bitcoin.org/en/developer-reference#message-headers
+      def to_pkt
+        payload = to_payload
+        magic = Bitcoin.chain_params.magic_head.htb
+        command_name = self.class.const_get(:COMMAND, false).ljust(12, "\x00")
+        payload_size = [payload.bytesize].pack('V')
+        checksum = Bitcoin.double_sha256(payload)[0...4]
+        magic << command_name << payload_size << checksum << payload
+      end
+
+      # abstract method
+      def to_payload
+        raise 'to_payload must be implemented in a child class.'
+      end
+
+      def to_json
+        to_h.to_json
+      end
+
+      def to_h
+        instance_variables.inject({}) do |result, var|
+          key = var.to_s
+          key.slice!(0) if key.start_with?('@')
+          result.update(key => instance_variable_get(var))
+        end
+      end
+
+    end
+
+  end
+end

data/lib/bitcoin/message/block.rb

@@ -0,0 +1,41 @@
+module Bitcoin
+  module Message
+
+    # block message
+    # https://bitcoin.org/en/developer-reference#block
+    class Block < Base
+
+      attr_accessor :header
+      attr_accessor :transactions
+      attr_accessor :use_segwit
+
+      COMMAND = 'block'
+
+      def initialize(header, transactions = [], use_segwit = false)
+        @header = header
+        @transactions = transactions
+        @use_segwit = use_segwit
+      end
+
+      def self.parse_from_payload(payload)
+        buf = StringIO.new(payload)
+        header = Bitcoin::BlockHeader.parse_from_payload(buf.read(80))
+        transactions = []
+        unless buf.eof?
+          tx_count = Bitcoin.unpack_var_int_from_io(buf)
+          tx_count.times do
+            transactions << Bitcoin::Tx.parse_from_payload(buf)
+          end
+        end
+        new(header, transactions)
+      end
+
+      def to_payload
+        header.to_payload << Bitcoin.pack_var_int(transactions.size) <<
+          transactions.map{|t|use_segwit ? t.to_payload : t.serialize_old_format}.join
+      end
+
+    end
+
+  end
+end