bitcoin-ruby 0.0.1

data/lib/bitcoin/protocol.rb

@@ -0,0 +1,140 @@
+require 'socket'
+require 'digest/sha2'
+require 'json'
+
+module Bitcoin
+  module Protocol
+
+    autoload :TxIn,    'bitcoin/protocol/txin'
+    autoload :TxOut,   'bitcoin/protocol/txout'
+    autoload :Tx,      'bitcoin/protocol/tx'
+    autoload :Block,   'bitcoin/protocol/block'
+    autoload :Addr,    'bitcoin/protocol/address'
+    autoload :Alert,   'bitcoin/protocol/alert'
+    autoload :Version, 'bitcoin/protocol/version'
+
+    autoload :Handler, 'bitcoin/protocol/handler'
+    autoload :Parser,  'bitcoin/protocol/parser'
+
+    VERSION = 60001
+
+    DNS_Seed = [ "bitseed.xf2.org", "bitseed.bitcoin.org.uk" ]
+    Uniq = rand(0xffffffffffffffff)
+
+    def self.unpack_var_int(payload)
+      case payload.unpack("C")[0] # TODO add test cases
+      when 0xfd; payload.unpack("xva*")
+      when 0xfe; payload.unpack("xVa*")
+      when 0xff; payload.unpack("xQa*") # TODO add little-endian version of Q
+      else;      payload.unpack("Ca*")
+      end
+    end
+
+    def self.pack_var_int(i)
+      if    i <  0xfd;                [      i].pack("C")
+      elsif i <= 0xffff;              [0xfd, i].pack("Cv")
+      elsif i <= 0xffffffff;          [0xfe, i].pack("CV")
+      elsif i <= 0xffffffffffffffff;  [0xff, i].pack("CQ")
+      else raise "int(#{i}) too large!"
+      end
+    end
+
+    def self.unpack_var_string(payload)
+      size, payload = unpack_var_int(payload)
+      size > 0 ? (string, payload = payload.unpack("a#{size}a*")) : [nil, payload]
+    end
+
+    def self.pack_var_string(payload)
+      pack_var_int(payload.bytesize) + payload
+    end
+
+    def self.unpack_var_string_array(payload) # unpacks set<string>
+      size, payload = unpack_var_int(payload)
+      return [nil, payload] if size == 0
+      [(0...size).map{ s, payload = unpack_var_string(payload); s }, payload]
+    end
+
+    def self.unpack_var_int_array(payload) # unpacks set<int>
+      size, payload = unpack_var_int(payload)
+      return [nil, payload] if size == 0
+      [(0...size).map{ i, payload = unpack_var_int(payload); i }, payload]
+    end
+
+
+    def self.pkt(command, payload)
+      cmd      = command.ljust(12, "\x00")[0...12]
+      length   = [payload.bytesize].pack("I")
+      checksum = Digest::SHA256.digest(Digest::SHA256.digest(payload))[0...4]
+
+      [Bitcoin.network[:magic_head], cmd, length, checksum, payload].join
+    end
+
+    def self.version_pkt(from_id, from=nil, to=nil, last_block=nil, time=nil, user_agent=nil, version=nil)
+      opts = if from_id.is_a?(Hash)
+        from_id
+      else
+        STDERR.puts "Bitcoin::Protocol.version_pkt - API deprecated. please change it soon.."
+        {
+          :nonce => from_id, :from => from, :to => to, :last_block => last_block,
+          :time => time, :user_agent => user_agent, :version => version
+        }
+      end
+      version = Protocol::Version.new(opts)
+      version.to_pkt
+    end
+
+    def self.ping_pkt(nonce = rand(0xffffffff))
+      pkt("ping", [nonce].pack("Q"))
+    end
+
+    def self.pong_pkt(nonce)
+      pkt("pong", [nonce].pack("Q"))
+    end
+
+    def self.verack_pkt
+      pkt("verack", "")
+    end
+
+    TypeLookup = Hash[:tx, 1, :block, 2, nil, 0]
+
+    def self.getdata_pkt(type, hashes)
+      return if hashes.size >= 256
+      t = [ TypeLookup[type] ].pack("I")
+      pkt("getdata", [hashes.size].pack("C") + hashes.map{|hash| t + hash[0..32].reverse }.join)
+    end
+
+    def self.inv_pkt(type, hashes)
+      return if hashes.size >= 256
+      t = [ TypeLookup[type] ].pack("I")
+      pkt("inv", [hashes.size].pack("C") + hashes.map{|hash| t + hash[0..32].reverse }.join)
+    end
+
+    DEFAULT_STOP_HASH = "00"*32
+
+    def self.locator_payload(locator_hashes, stop_hash)
+      payload = [
+        Bitcoin.network[:magic_head],
+        pack_var_int(locator_hashes.size),
+        locator_hashes.map{|l| htb(l).reverse }.join,
+        htb(stop_hash).reverse
+      ].join
+    end
+
+    def self.getblocks_pkt(locator_hashes, stop_hash=DEFAULT_STOP_HASH)
+      pkt "getblocks",  locator_payload(locator_hashes, stop_hash)
+    end
+
+    def self.getheaders_pkt(locator_hashes, stop_hash=DEFAULT_STOP_HASH)
+      pkt "getheaders", locator_payload(locator_hashes, stop_hash)
+    end
+
+    def self.hth(h); h.unpack("H*")[0]; end
+    def self.htb(h); [h].pack("H*"); end
+
+    def self.read_binary_file(path)
+      File.open(path, 'rb'){|f| f.read }
+    end
+  end
+
+  P = Protocol
+end

data/lib/bitcoin/protocol/address.rb

@@ -0,0 +1,48 @@
+module Bitcoin
+  module Protocol
+
+    class Addr < Struct.new(:time, :service, :ip, :port)
+
+      # # IP Address / Port
+      # attr_reader :ip, :port
+
+      # # Time the node was last active
+      # attr_reader :time
+
+      # # Services supported by this node
+      # attr_reader :service
+
+      # create addr from raw binary +data+
+      def initialize(data = nil)
+        if data
+          self[:time], self[:service], self[:ip], self[:port] = data.unpack("IQx12a4n")
+          self[:ip] = ip.unpack("C*").join(".")
+        else
+          self[:time], self[:service] = Time.now.to_i, 1
+          self[:ip], self[:port] = "127.0.0.1", Bitcoin.network[:default_port]
+        end
+      end
+
+      # is this address alive?
+      def alive?
+        (Time.now.tv_sec-7200) <= self[:time]
+      end
+
+      def to_payload
+        ip = self[:ip].split(".").map(&:to_i)
+        [ time, service, ("\x00"*10)+"\xff\xff", *ip, port ].pack("IQa12C4n")
+      end
+
+      def string
+        "#{self[:ip]}:#{self[:port]}"
+      end
+
+      def self.pkt(*addrs)
+        addrs = addrs.select{|i| i.is_a?(Bitcoin::Protocol::Addr) }
+        length = Bitcoin::Protocol.pack_var_int(addrs.size)
+        Bitcoin::Protocol.pkt("addr", length + addrs.map(&:to_payload).join)
+      end
+    end
+
+  end
+end

data/lib/bitcoin/protocol/alert.rb

@@ -0,0 +1,47 @@
+module Bitcoin
+module Protocol
+
+  class Alert < Struct.new(:version, :relay_until, :expiration, :id, :cancel, :set_cancel,
+                           :min_ver, :max_ver, :set_sub_ver, :priority, :comment, :status_bar, :reserved)
+
+    attr_accessor :payload, :signature
+
+    def initialize(values, alert_payload=nil, alert_signature=nil)
+      @payload, @signature = alert_payload, alert_signature
+      super(*values)
+    end
+
+
+    Valid_Keys = [ "04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284" ] 
+
+    def valid_signature?
+      return false unless @payload && @signature
+      hash = Digest::SHA256.digest(Digest::SHA256.digest(@payload))
+      Valid_Keys.any?{|public_key| Bitcoin.verify_signature(hash, @signature, public_key) }
+    end
+
+
+    def self.parse(payload)
+      count,             payload = Bitcoin::Protocol.unpack_var_int(payload)
+      alert_payload,     payload = payload.unpack("a#{count}a*")
+      count,             payload = Bitcoin::Protocol.unpack_var_int(payload)
+      alert_signature,   payload = payload.unpack("a#{count}a*")
+
+      version, relay_until, expiration, id, cancel, payload = alert_payload.unpack("VQQVVa*")
+
+      set_cancel,        payload = Bitcoin::Protocol.unpack_var_int_array(payload)
+      min_ver, max_ver,  payload = payload.unpack("VVa*")
+      set_sub_ver,       payload = Bitcoin::Protocol.unpack_var_string_array(payload)
+      priority,          payload = payload.unpack("Va*")
+      comment,           payload = Bitcoin::Protocol.unpack_var_string(payload)
+      status_bar,        payload = Bitcoin::Protocol.unpack_var_string(payload)
+      reserved,          payload = Bitcoin::Protocol.unpack_var_string(payload)
+
+      values = [ version, relay_until, expiration, id, cancel, set_cancel, min_ver, max_ver, set_sub_ver, priority, comment, status_bar, reserved ]
+
+      new(values, alert_payload, alert_signature)
+    end
+  end
+
+end
+end

data/lib/bitcoin/protocol/block.rb

@@ -0,0 +1,154 @@
+module Bitcoin
+  module Protocol
+
+    class Block
+
+      # block hash
+      attr_accessor :hash
+
+      # previous block hash
+      attr_accessor :prev_block
+
+      # transactions (Array of Tx)
+      attr_accessor :tx
+
+      # merkle root
+      attr_accessor :mrkl_root
+
+      # block generation time
+      attr_accessor :time
+
+      # difficulty target bits
+      attr_accessor :bits
+
+      # nonce (number counted when searching for block hash matching target)
+      attr_accessor :nonce
+
+      # version (usually 1)
+      attr_accessor :ver
+
+      # raw protocol payload
+      attr_accessor :payload
+
+      alias :transactions :tx
+
+      # compare to another block
+      def ==(other)
+        @hash == other.hash
+      end
+
+      # create block from raw binary +data+
+      def initialize(data)
+        @tx = []
+        parse_data(data) if data
+      end
+
+      # parse raw binary data
+      def parse_data(data)
+        @ver, @prev_block, @mrkl_root, @time, @bits, @nonce, payload = data.unpack("Ia32a32IIIa*")
+        recalc_block_hash
+
+        tx_size, payload = Protocol.unpack_var_int(payload)
+        (0...tx_size).each{  break if payload == true
+          t = Tx.new(nil)
+          payload = t.parse_data(payload)
+          @tx << t
+        }
+
+        @payload = to_payload
+        payload
+      end
+
+      # recalculate the block hash
+      def recalc_block_hash
+        @hash = Bitcoin.block_hash(hth(@prev_block), hth(@mrkl_root), @time, @bits, @nonce, @ver)
+      end
+
+      # get the block header info
+      # [<version>, <prev_block>, <merkle_root>, <time>, <bits>, <nonce>, <txcount>, <size>]
+      def header_info
+        [@ver, hth(@prev_block), hth(@mrkl_root), Time.at(@time), @bits, @nonce, @tx.size, @payload.size]
+      end
+
+      def hth(h); h.reverse.unpack("H*")[0]; end
+      def htb(s); [s].pack('H*').reverse; end
+
+      # convert to raw binary format
+      def to_payload
+        head = [@ver, @prev_block, @mrkl_root, @time, @bits, @nonce].pack("Ia32a32III")
+        [head, Protocol.pack_var_int(@tx.size), @tx.map(&:to_payload).join].join
+      end
+
+      # convert to ruby hash (see also #from_hash)
+      def to_hash
+        {
+          'hash' => @hash, 'ver' => @ver,
+          'prev_block' => hth(@prev_block), 'mrkl_root' => hth(@mrkl_root),
+          'time' => @time, 'bits' => @bits, 'nonce' => @nonce,
+          'n_tx' => @tx.size, 'size' => (@payload||to_payload).bytesize,
+          'tx' => @tx.map{|i| i.to_hash },
+          'mrkl_tree' => Bitcoin.hash_mrkl_tree( @tx.map{|i| i.hash } )
+        }
+      end
+
+      def hextarget
+        Bitcoin.decode_compact_bits(@bits)
+      end
+
+      def decimaltarget
+        Bitcoin.decode_compact_bits(@bits).to_i(16)
+      end
+
+      def difficulty
+        Bitcoin.block_difficulty(@bits)
+      end
+
+      # convert to json representation as seen in the block explorer.
+      # (see also #from_json)
+      def to_json(options = {:space => ''}, *a)
+        JSON.pretty_generate( to_hash, options )
+      end
+
+      # write json representation to a file
+      # (see also #to_json)
+      def to_json_file(path)
+        File.open(path, 'wb'){|f| f.print to_json; }
+      end
+
+      # parse ruby hash (see also #to_hash)
+      def self.from_hash(h)
+        blk = new(nil)
+        blk.instance_eval{
+          @ver, @time, @bits, @nonce = h.values_at('ver', 'time', 'bits', 'nonce')
+          @prev_block, @mrkl_root = h.values_at('prev_block', 'mrkl_root').map{|i| htb(i) }
+          recalc_block_hash
+          h['tx'].each{|tx| @tx << Tx.from_hash(tx) }
+        }
+        blk
+      end
+
+      # convert ruby hash to raw binary
+      def self.binary_from_hash(h); from_hash(h).to_payload; end
+
+      # parse json representation (see also #to_json)
+      def self.from_json(json_string); from_hash( JSON.load(json_string) ); end
+
+      # convert json representation to raw binary
+      def self.binary_from_json(json_string); from_json(json_string).to_payload; end
+
+      # convert header to json representation.
+      def header_to_json(options = {:space => ''})
+        h = to_hash
+        %w[tx mrkl_tree].each{|k| h.delete(k) }
+        JSON.pretty_generate( h, options )
+      end
+
+      # read binary block from a file
+      def self.from_file(path); new( Bitcoin::Protocol.read_binary_file(path) ); end
+
+      # read json block from a file
+      def self.from_json_file(path); from_json( Bitcoin::Protocol.read_binary_file(path) ); end
+    end
+
+  end
+end

data/lib/bitcoin/protocol/handler.rb

@@ -0,0 +1,38 @@
+module Bitcoin
+  module Protocol
+
+    class Handler
+      def on_inv_transaction(hash)
+        p ['inv transaction', hth(hash)]
+      end
+
+      def on_inv_block(hash)
+        p ['inv block', hth(hash)]
+      end
+
+      def on_get_transaction(hash)
+        p ['get transaction', hth(hash)]
+      end
+
+      def on_get_block(hash)
+        p ['get block', hth(hash)]
+      end
+
+      def on_addr(addr)
+        p ['addr', addr, addr.alive?]
+      end
+
+      def on_tx(tx)
+        p ['tx', tx]
+      end
+
+      def on_block(block)
+        #p ['block', block]
+        puts block.to_json
+      end
+
+      def hth(h); h.unpack("H*")[0]; end
+    end
+
+  end
+end

data/lib/bitcoin/protocol/parser.rb

@@ -0,0 +1,148 @@
+module Bitcoin
+  module Protocol
+
+    class Parser
+
+      def initialize(handler=nil)
+        @h = handler || Handler.new
+        @buf = ""
+      end
+
+      def log
+        @log ||= Bitcoin::Logger.create("parser")
+      end
+
+      # handles inv/getdata packets
+      #
+      def parse_inv(payload, type=:put)
+        count, payload = Protocol.unpack_var_int(payload)
+        payload.each_byte.each_slice(36){|i|
+          hash = i[4..-1].reverse.pack("C32")
+          case i[0]
+          when 1
+            if type == :put
+              @h.on_inv_transaction(hash)
+            else
+              @h.on_get_transaction(hash)
+            end
+          when 2
+            if type == :put
+              @h.on_inv_block(hash)
+            else
+              @h.on_get_block(hash)
+            end
+          else
+            p ['parse_inv error', i]
+          end
+        }
+      end
+
+      def hth(h); h.unpack("H*")[0]; end
+
+      def parse_addr(payload)
+        count, payload = Protocol.unpack_var_int(payload)
+        payload.each_byte.each_slice(30){|i|
+          begin
+            addr = Addr.new(i.pack("C*"))
+          rescue
+            puts "Error parsing addr: #{i.inspect}"
+          end
+          @h.on_addr( addr )
+        }
+      end
+
+      def parse_headers(payload)
+        count, payload = Protocol.unpack_var_int(payload)
+        idx = 0
+        headers = count.times.map{ Block.new(payload[idx..idx+=81]) }
+        @h.on_headers(headers)
+      end
+
+      def parse_getblocks(payload)
+        version, payload = payload.unpack('a4a*')
+        count,   payload = Protocol.unpack_var_int(payload)
+        buf,     payload = payload.unpack("a#{count*32}a*")
+        hashes    = buf.each_byte.each_slice(32).map{|i| hash = Protocol.hth(i.reverse.pack("C32")) }
+        stop_hash = Protocol.hth(payload[0..32].reverse)
+        [version, hashes, stop_hash]
+      end
+
+      def process_pkt(command, payload)
+        case command
+        when 'tx';       @h.on_tx( Tx.new(payload) )
+        when 'block';    @h.on_block( Block.new(payload) )
+        when 'headers';  parse_headers(payload)
+        when 'inv';      parse_inv(payload, :put)
+        when 'getdata';  parse_inv(payload, :get)
+        when 'addr';     parse_addr(payload)
+        when 'verack';   @h.on_handshake_complete # nop
+        when 'version';  parse_version(payload)
+        when 'alert';    parse_alert(payload)
+        when 'ping';     @h.on_ping(payload.unpack("Q")[0])
+        when 'pong';     @h.on_pong(payload.unpack("Q")[0])
+        when 'getblocks';   @h.on_getblocks(*parse_getblocks(payload))
+        when 'getheaders';  @h.on_getheaders(*parse_getblocks(payload))
+        else
+          p ['unkown-packet', command, payload]
+        end
+      end
+
+      def parse_version(payload)
+        version = Bitcoin::Protocol::Version.parse(payload)
+        @h.on_version(version)
+      end
+
+      def parse_alert(payload)
+        return unless @h.respond_to?(:on_alert)
+        @h.on_alert Bitcoin::Protocol::Alert.parse(payload)
+      end
+
+      def parse(buf)
+        @buf += buf
+        while parse_buffer; end
+        @buf
+      end
+
+      def parse_buffer
+        head_magic = Bitcoin::network[:magic_head]
+        head_size  = 24
+        return false if @buf.size <= head_size
+
+        magic, cmd, length, checksum = @buf.unpack("a4A12Ia4")
+        payload = @buf[head_size...head_size+length]
+
+        unless magic == head_magic
+          handle_error(:close, "head_magic not found")
+          @buf = ''
+        else
+
+          if Digest::SHA256.digest(Digest::SHA256.digest( payload ))[0...4] != checksum
+            if (length < 50000) && (payload.size < length)
+              size_info = [payload.size, length].join('/')
+              handle_error(:debug, "chunked packet stream (#{size_info})")
+            else
+              handle_error(:close, "checksum mismatch")
+            end
+            return
+          end
+          @buf = @buf[head_size+length..-1] || ""
+
+          process_pkt(cmd, payload)
+        end
+
+        # not empty yet? parse more.
+        @buf[0] != nil
+      end
+
+      def handle_error(type, msg)
+        case type
+        when :close
+          log.debug {"closing packet stream (#{msg})"}
+        else
+          log.debug { [type, msg] }
+        end
+      end
+    end # Parser
+
+  end
+end