ciri 0.0.0 → 0.0.1

data/lib/ciri/eth/protocol_messages.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require 'ciri/chain'
+require 'ciri/rlp'
+require 'stringio'
+
+module Ciri
+  module Eth
+
+    # represent a hash or a number
+    class HashOrNumber
+      include Ciri::RLP::Serializable
+
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def rlp_encode!
+        if value.is_a? Integer
+          RLP.encode(value, Integer)
+        else
+          RLP.encode(value)
+        end
+      end
+
+      def self.rlp_decode!(s)
+        s = StringIO.new(s) if s.is_a?(String)
+        # start with 0xA0, represent s is a 32 length hash bytes
+        c = s.getc
+        s.ungetc(c)
+        if c.ord == 0xa0
+          RLP.decode(s)
+        else
+          RLP.decode(s, Integer)
+        end
+      end
+    end
+
+    # Ethereum Sub-protocol Messages
+    #
+    #
+
+
+    class Status
+      include Ciri::RLP::Serializable
+
+      CODE = 0x00
+
+      schema [
+               {protocol_version: Integer},
+               {network_id: Integer},
+               {total_difficulty: Integer},
+               :current_block,
+               :genesis_block,
+             ]
+    end
+
+    class GetBlockHeaders
+      include Ciri::RLP::Serializable
+
+      CODE = 0x03
+
+      schema [
+               {hash_or_number: HashOrNumber},
+               {amount: Integer},
+               {skip: Integer},
+               {reverse: Ciri::RLP::Bool},
+             ]
+    end
+
+    class BlockHeaders
+      CODE = 0x04
+
+      attr_reader :headers
+
+      def initialize(headers:)
+        @headers = headers
+      end
+
+      def rlp_encode!
+        Ciri::RLP.encode(@headers, [Chain::Header])
+      end
+
+      def self.rlp_decode!(payload)
+        new headers: Ciri::RLP.decode(payload, [Chain::Header])
+      end
+    end
+
+    class GetBlockBodies
+      CODE = 0x05
+
+      attr_reader :hashes
+
+      def initialize(hashes:)
+        @hashes = hashes
+      end
+
+      def rlp_encode!
+        Ciri::RLP.encode(@hashes)
+      end
+
+      def self.rlp_decode!(payload)
+        new hashes: Ciri::RLP.decode(payload)
+      end
+    end
+
+    class BlockBodies
+      CODE = 0x06
+
+      class Bodies
+        include RLP::Serializable
+
+        schema [
+                 {transactions: [Chain::Transaction]},
+                 {ommers: [Chain::Header]},
+               ]
+      end
+
+      attr_reader :bodies
+
+      def initialize(bodies:)
+        @bodies = bodies
+      end
+
+      def rlp_encode!
+        Ciri::RLP.encode(@bodies, [Bodies])
+      end
+
+      def self.rlp_decode!(bodies)
+        new bodies: Ciri::RLP.decode(bodies, [Bodies])
+      end
+    end
+
+  end
+end

data/lib/ciri/eth/synchronizer.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require 'lru_redux'
+require 'ciri/utils/logger'
+
+module Ciri
+  module Eth
+
+    # Synchronizer sync blocks with peers
+    class Synchronizer
+      include Ciri::Actor
+      include Ciri::Utils::Logger
+
+      HEADER_FETCH_COUNT = 10
+
+      class PeerEntry
+        attr_reader :header_queue, :body_queue, :peer
+        attr_accessor :syncing
+
+        def initialize(peer)
+          @peer = peer
+          @header_queue = Queue.new
+          @body_queue = Queue.new
+          @lru_cache = LruRedux::Cache.new(HEADER_FETCH_COUNT * 2)
+        end
+
+        def receive_header
+          header_queue.pop
+        end
+
+        def receive_header_in(timeout)
+          wait_seconds = 0
+          while header_queue.empty?
+            sleep(0.1)
+            wait_seconds += 0.1
+            raise Timeout::Error.new("can't receive body in #{timeout}") if wait_seconds > timeout
+          end
+          header_queue.pop(true)
+        end
+
+        def receive_body
+          body_queue.pop
+        end
+
+        def receive_body_in(timeout)
+          wait_seconds = 0
+          while body_queue.empty?
+            sleep(0.1)
+            wait_seconds += 0.1
+            raise Timeout::Error.new("can't receive body in #{timeout}") if wait_seconds > timeout
+          end
+          body_queue.pop(true)
+        end
+
+        def fetch_peer_header(hash_or_number)
+          cached = @lru_cache[hash_or_number]
+          return cached if cached
+
+          until header_queue.empty?
+            header = receive_header
+            @lru_cache[header.number] = header
+            @lru_cache[header.get_hash] = header
+            return header if header.number == hash_or_number || header.get_hash == hash_or_number
+          end
+          peer.send_msg(GetBlockHeaders, hash_or_number: HashOrNumber.new(hash_or_number), amount: HEADER_FETCH_COUNT,
+                        skip: 0, reverse: false)
+          while (header = receive_header_in(10))
+            @lru_cache[header.number] = header
+            @lru_cache[header.get_hash] = header
+            return header if header.number == hash_or_number || header.get_hash == hash_or_number
+          end
+          raise 'should not touch here'
+        end
+
+        def fetch_peer_body(hashes)
+          # clear body queue for receive
+          body_queue.clear
+          peer.send_msg(GetBlockBodies, hashes: hashes)
+          receive_body_in(10)
+        end
+      end
+
+      attr_reader :chain
+
+      def initialize(chain:)
+        @chain = chain
+        @peers = {}
+        super()
+      end
+
+      def receive_headers(peer, headers)
+        headers.each {|header| @peers[peer].header_queue << header}
+      end
+
+      def receive_bodies(peer, bodies)
+        @peers[peer].body_queue << bodies
+      end
+
+      def register_peer(peer)
+        @peers[peer] = PeerEntry.new(peer)
+
+        # request block headers if chain td less than peer
+        return unless peer.total_difficulty > chain.total_difficulty
+        peer.send_msg(GetBlockHeaders, hash_or_number: HashOrNumber.new(peer.status.current_block),
+                      amount: 1, skip: 0, reverse: true)
+
+        start_syncing best_peer
+      end
+
+      MAX_BLOCKS_SYNCING = 50
+
+      # check and start syncing peer
+      def start_syncing(peer)
+        peer_entry = @peers[peer]
+        return if peer_entry.syncing
+
+        peer_entry.syncing = true
+
+        executor.post do
+          peer_max_header = peer_header = peer_entry.receive_header
+          local_header = chain.head
+          start_height = [peer_header.number, local_header.number].min
+
+          # find common height
+          while local_header.get_hash != peer_header.get_hash
+            local_header = chain.get_block_by_number start_height
+            peer_header = peer_entry.fetch_peer_header start_height
+            start_height -= 1
+          end
+
+          loop do
+
+            # start from common + 1 block
+            start_height = local_header.number + 1
+
+            end_height = [start_height + MAX_BLOCKS_SYNCING, peer_max_header.number].min
+
+            if start_height < 1 || start_height > end_height
+              raise 'peer is incorrect'
+            end
+
+            info "Start syncing with Peer##{peer}, from #{start_height} to #{end_height}"
+
+            (start_height..end_height).each do |height|
+              header = peer_entry.fetch_peer_header height
+              bodies = peer_entry.fetch_peer_body([header.get_hash])
+              block = Chain::Block.new(header: header, transactions: bodies[0].transactions, ommers: bodies[0].ommers)
+              # insert to chain....
+              chain.write_block(block)
+              local_header = header
+            end
+            start_height = end_height + 1
+
+            break if end_height >= peer_max_header.number
+          end
+
+        end
+      end
+
+      def best_peer
+        @peers.keys.sort_by(&:total_difficulty).last
+      end
+
+    end
+
+  end
+end

data/lib/ciri/ethash.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require 'ffi'
+require 'ciri/utils/lib_c'
+
+module Ciri
+
+  # Ethash Algorithm
+  # from https://github.com/ethereum/ethash/blob/master/src/python/core.c
+  module Ethash
+
+    module Lib
+      extend FFI::Library
+      ffi_lib 'libethash'
+
+      # struct ethash_light {
+      #   void* cache;
+      #   uint64_t cache_size;
+      #   uint64_t block_number;
+      # };
+      class Light < FFI::Struct
+        layout :cache, :pointer,
+               :cache_size, :uint64,
+               :block_number, :uint64
+      end
+
+      # struct ethash_h256 { uint8_t b[32]; }
+      class H256 < FFI::Struct
+        layout :b, [:uint8, 32]
+
+        def put_bytes(s)
+          self[:b].to_ptr.put_array_of_uint8(0, s.each_byte.to_a)
+        end
+
+        def get_bytes
+          self[:b].to_ptr.get_array_of_uint8(0, 32).pack("c*")
+        end
+      end
+
+      # struct ethash_return_value {
+      #   ethash_h256_t result;
+      #   ethash_h256_t mix_hash;
+      #   bool success;
+      # }
+      class ReturnValue < FFI::Struct
+        layout :result, H256,
+               :mix_hash, H256,
+               :success, :bool
+      end
+
+      attach_function :ethash_light_new, [:int], Light
+      attach_function :ethash_light_delete, [Light], :void
+      attach_function :ethash_light_compute, [Light, H256.by_value, :uint64], ReturnValue.by_value
+    end
+
+    EPOCH_LENGTH = 30000
+
+    class Error < StandardError
+    end
+
+    # use methods as module methods
+    extend self
+
+    # return [mix_hash, result]
+    def hashimoto_light(block_number, cache_bytes, header, nonce)
+      header_size = header.size
+      cache_size = cache_bytes.size
+      raise Error.new("seed must be 32 bytes long, (was #{header_size})") if header_size != 32
+
+      cache_ptr = Utils::LibC.malloc(cache_size)
+      cache_ptr.write_string_length(cache_bytes, cache_size)
+
+      light = Lib::Light.new
+      light[:cache] = cache_ptr
+      light[:cache_size] = cache_size
+      light[:block_number] = block_number
+
+      h = Lib::H256.new
+      h.put_bytes(header[0..32])
+
+      value = Lib.ethash_light_compute(light, h, nonce)
+      raise Error.new "compute not success, return: #{value[:success]}" unless value[:success]
+
+      result = [value[:mix_hash].get_bytes, value[:result].get_bytes]
+
+      # release memory *_*
+      Utils::LibC.free cache_ptr
+
+      result
+    end
+
+    def mkcache_bytes(block_number)
+      ptr = Lib.ethash_light_new(block_number)
+      light = Lib::Light.new(ptr)
+      cache_ptr = light[:cache]
+      bytes = cache_ptr.read_string(light[:cache_size])
+      Lib.ethash_light_delete(light)
+      bytes
+    end
+
+  end
+end