ciri 0.0.0 → 0.0.1

data/lib/ciri/forks.rb

@@ -0,0 +1,38 @@
+# 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_relative 'forks/frontier'
+
+module Ciri
+  module Forks
+
+    # Fork configure
+    ForkConfig = Struct.new(:cost_of_operation, :cost_of_memory, :intrinsic_gas_of_transaction, keyword_init: true)
+
+    def self.detect_fork(header: nil, number: nil)
+      number ||= header.number
+      Frontier.fork_config
+    end
+
+  end
+end

data/lib/ciri/forks/frontier.rb

@@ -0,0 +1,43 @@
+# 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/evm/forks/frontier'
+
+module Ciri
+  module Forks
+    module Frontier
+
+      class << self
+        def fork_config
+          ForkConfig.new(
+            cost_of_operation: proc {|vm| EVM::Forks::Frontier::Cost.cost_of_operation vm},
+            cost_of_memory: proc {|i| EVM::Forks::Frontier::Cost.cost_of_memory i},
+            intrinsic_gas_of_transaction: proc {|t| EVM::Forks::Frontier::Cost.intrinsic_gas_of_transaction t}
+          # transaction_klass: nil
+          )
+        end
+      end
+
+    end
+  end
+end

data/lib/ciri/key.rb

@@ -74,8 +74,14 @@ module Ciri
     end
 
     private
+
     def secp256k1_key
-      @secp256k1_key ||= Crypto.ensure_secp256k1_key(privkey: ec_key.private_key.to_s(2))
+      privkey = ec_key.private_key.to_s(2)
+      # some times below error will occurs, raise error with more detail
+      unless privkey.instance_of?(String) && privkey.size == 32
+        raise ArgumentError, "privkey must be composed of 32 bytes, #{bytes}: #{privkey.size} privkey: #{Utils.data_to_hex privkey}"
+      end
+      @secp256k1_key ||= Crypto.ensure_secp256k1_key(privkey: privkey)
     end
   end
 end

data/lib/ciri/pow.rb

@@ -0,0 +1,95 @@
+# 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/utils'
+require_relative 'ethash'
+require 'lru_redux'
+require 'concurrent'
+
+module Ciri
+
+  # POW
+  # see py-evm https://github.com/ethereum/py-evm/blob/026553da69bbea314fe26c8c34d453f66bfb4d30/evm/consensus/pow.py
+  module POW
+
+    extend self
+
+    class Error < StandardError
+    end
+    class InvalidError < Error
+    end
+
+    class GivingUpError < Error
+    end
+
+    # thread safe caches
+    @cache_seeds = Concurrent::Array.new(['\x00'.b * 32])
+    @cache_by_seed = LruRedux::ThreadSafeCache.new(10)
+
+    def get_cache(block_number)
+      epoch = block_number / Ethash::EPOCH_LENGTH
+      while @cache_seeds.size <= epoch
+        @cache_seeds.append(Utils.sha3(@cache_seeds[-1]))
+      end
+
+      seed = @cache_seeds[epoch]
+
+      @cache_by_seed.getset(seed) do
+        Ethash.mkcache_bytes(block_number)
+      end
+    end
+
+    def check_pow(block_number, mining_hash, mix_hash, nonce_bytes, difficulty)
+      raise ArgumentError.new "mix_hash.length must equal to 32" if mix_hash.size != 32
+      raise ArgumentError.new "mining_hash.length must equal to 32" if mining_hash.size != 32
+      raise ArgumentError.new "nonce.length must equal to 8" if nonce_bytes.size != 8
+
+      cache = get_cache(block_number)
+      out_mix_hash, out_result = Ethash.hashimoto_light(block_number, cache, mining_hash, Utils.big_endian_decode(nonce_bytes))
+
+      if out_mix_hash != mix_hash
+        raise InvalidError.new("mix hash mismatch; #{Utils.data_to_hex(out_mix_hash)} != #{Utils.data_to_hex(mix_hash)}")
+      end
+
+      result = Utils.big_endian_decode(out_result)
+      unless result < 2 ** 256 / difficulty
+        raise InvalidError.new("difficulty not enough, need difficulty #{difficulty}, but result #{result}")
+      end
+    end
+
+    MAX_TEST_MINE_ATTEMPTS = 1000
+
+    def mine_pow_nonce(block_number, mining_hash, difficulty)
+      cache = get_cache(block_number)
+      MAX_TEST_MINE_ATTEMPTS.times do |nonce|
+        out_mix_hash, out_result = Ethash.hashimoto_light(block_number, cache, mining_hash, nonce)
+        result = Utils.big_endian_decode(out_result)
+        result_cap = 2 ** 256 / difficulty
+        return [out_mix_hash, Utils.big_endian_encode(nonce).rjust(8, "\x00")] if result <= result_cap
+      end
+
+      raise GivingUpError.new("tries too many times, giving up")
+    end
+
+  end
+end

data/lib/ciri/rlp.rb

@@ -27,62 +27,12 @@ require_relative 'rlp/serializable'
 
 module Ciri
   module RLP
+
     class InvalidValueError < StandardError
     end
 
-    class << self
-
-      # Decode input from rlp encoding, only produce string or array
-      #
-      # Examples:
-      #
-      #   Ciri::RLP.decode(input)
-      #
-      def decode(input, type = nil)
-        output = Decode.decode(input)
-        if type
-          output = decode_with_type(output, type)
-        end
-        output
-      end
-
-      # Encode input to rlp encoding, only allow string or array
-      #
-      # Examples:
-      #
-      #   Ciri::RLP.encode("hello world")
-      #
-      def encode(input, type = nil)
-        if type
-          input = encode_with_type(input, type)
-        end
-        Encode.encode(input)
-      end
+    extend Encode
+    extend Decode
 
-      # Use this method before RLP.encode, this method encode ruby objects to rlp friendly format, string or array.
-      # see Ciri::RLP::Serializable::TYPES for supported types
-      #
-      # Examples:
-      #
-      #   item = Ciri::RLP.encode_with_type(number, :int, zero: "\x00".b)
-      #   encoded_text = Ciri::RLP.encode(item)
-      #
-      def encode_with_type(item, type, zero: '')
-        Serializable.encode_with_type(item, type, zero: zero)
-      end
-
-      # Use this method after RLP.decode, decode values from string or array to specific types
-      # see Ciri::RLP::Serializable::TYPES for supported types
-      #
-      # Examples:
-      #
-      #   item = Ciri::RLP.decode(encoded_text)
-      #   number = Ciri::RLP.decode_with_type(item, :int)
-      #
-      def decode_with_type(item, type)
-        Serializable.decode_with_type(item, type)
-      end
-
-    end
   end
 end

data/lib/ciri/rlp/decode.rb

@@ -27,55 +27,115 @@ module Ciri
   module RLP
     module Decode
 
-      class InvalidInput < StandardError
+      # Decode input from rlp encoding, only produce string or array
+      #
+      # Examples:
+      #
+      #   Ciri::RLP.decode(input)
+      #
+      def decode(input, type = Raw)
+        decode_with_type(input, type)
       end
 
-      class << self
-        def decode(input)
-          s = StringIO.new(input).binmode
+      # Use this method after RLP.decode, decode values from string or array to specific types
+      # see Ciri::RLP::Serializable::TYPES for supported types
+      #
+      # Examples:
+      #
+      #   item = Ciri::RLP.decode(encoded_text)
+      #   decode_with_type(item, Integer)
+      #
+      def decode_with_type(s, type)
+        s = StringIO.new(s) if s.is_a?(String)
+        if type == Integer
+          item = s.read(1)
+          if item.nil?
+            raise InvalidValueError.new "invalid bool value nil"
+          elsif item == "\x80".b || item.empty?
+            0
+          elsif item.ord < 0x80
+            item.ord
+          else
+            size = item[0].ord - 0x80
+            Ciri::Utils.big_endian_decode(s.read(size))
+          end
+        elsif type == Bool
+          item = s.read(1)
+          if item == Bool::ENCODED_TRUE
+            true
+          elsif item == Bool::ENCODED_FALSE
+            false
+          else
+            raise InvalidValueError.new "invalid bool value #{item}"
+          end
+        elsif type.is_a?(Class) && type < Serializable
+          type.rlp_decode!(s)
+        elsif type.is_a?(Array)
+          decode_list(s) do |list, s2|
+            until s2.eof?
+              list << decode_with_type(s2, type[0])
+            end
+          end
+        elsif type == Raw
           decode_stream(s)
+        else
+          raise RLP::InvalidValueError.new "unknown type #{type}"
         end
+      rescue
+        STDERR.puts "when decoding #{s} into #{type}"
+        raise
+      end
 
-        private
-        def decode_stream(s)
-          c = s.read(1)
-          case c.ord
-            when 0x00..0x7f
-              c
-            when 0x80..0xb7
-              length = c.ord - 0x80
-              s.read(length)
-            when 0xb8..0xbf
-              length_binary = s.read(c.ord - 0xb7)
-              length = int_from_binary(length_binary)
-              s.read(length)
-            when 0xc0..0xf7
-              length = c.ord - 0xc0
-              s2 = StringIO.new s.read(length)
-              list = []
-              until s2.eof?
-                list << decode_stream(s2)
-              end
-              list
-            when 0xf8..0xff
-              length_binary = s.read(c.ord - 0xf7)
-              length = int_from_binary(length_binary)
-              s2 = StringIO.new s.read(length)
-              list = []
-              until s2.eof?
-                list << decode_stream(s2)
-              end
-              list
-            else
-              raise InvalidInput.new("invalid char #{c}")
-          end
-        end
+      protected
+
+      def decode_list(s, first_char = nil, &decoder)
+        s = StringIO.new(s) if s.is_a?(String)
+        c = first_char || s.read(1)
+        list = []
 
-        def int_from_binary(input)
-          Ciri::Utils.big_endian_decode(input)
+        sub_s = case c.ord
+                when 0xc0..0xf7
+                  length = c.ord - 0xc0
+                  s.read(length)
+                when 0xf8..0xff
+                  length_binary = s.read(c.ord - 0xf7)
+                  length = int_from_binary(length_binary)
+                  s.read(length)
+                else
+                  raise InvalidValueError.new("invalid char #{c}")
+                end
+
+        decoder.call(list, StringIO.new(sub_s))
+        list
+      end
+
+      private
+
+      def decode_stream(s)
+        c = s.read(1)
+        case c.ord
+        when 0x00..0x7f
+          c
+        when 0x80..0xb7
+          length = c.ord - 0x80
+          s.read(length)
+        when 0xb8..0xbf
+          length_binary = s.read(c.ord - 0xb7)
+          length = int_from_binary(length_binary)
+          s.read(length)
+        else
+          decode_list(s, c) do |list, s2|
+            until s2.eof?
+              list << decode_stream(s2)
+            end
+          end
         end
+      end
 
+      def int_from_binary(input)
+        Ciri::Utils.big_endian_decode(input)
       end
+
     end
   end
 end

data/lib/ciri/rlp/encode.rb

@@ -28,52 +28,113 @@ module Ciri
       class InputOverflow < StandardError
       end
 
-      class << self
+      # Encode input to rlp encoding, only allow string or array
+      #
+      # Examples:
+      #
+      #   Ciri::RLP.encode("hello world")
+      #
+      def encode(input, type = Raw)
+        encode_with_type(input, type)
+      end
 
-        def encode(input)
-          result = if input.is_a?(String)
-                     encode_string(input)
-                   elsif input.is_a?(Array)
-                     encode_list(input)
-                   else
-                     raise ArgumentError.new('input must be a String or Array')
-                   end
-          result.b
+      def encode_simple(input)
+        if input.is_a?(Array)
+          encode_list(input) {|i| encode_simple(i)}
+        elsif input.is_a?(Integer)
+          encode(input, Integer)
+        elsif input.is_a?(Serializable)
+          input.rlp_encode!
+        else
+          encode(input)
         end
+      end
 
-        private
-        def encode_string(input)
-          length = input.length
-          if length == 1 && input.ord < 0x80
-            input
-          elsif length < 56
-            to_binary(0x80 + length) + input
-          elsif length < 256 ** 8
-            binary_length = to_binary(length)
-            to_binary(0xb7 + binary_length.size) + binary_length + input
+      # Use this method before RLP.encode, this method encode ruby objects to rlp friendly format, string or array.
+      # see Ciri::RLP::Serializable::TYPES for supported types
+      #
+      # Examples:
+      #
+      #   item = Ciri::RLP.encode_with_type(number, :int, zero: "\x00".b)
+      #   encoded_text = Ciri::RLP.encode(item)
+      #
+      def encode_with_type(item, type, zero: '')
+        if type == Integer
+          if item == 0
+            "\x80".b
+          elsif item < 0x80
+            Ciri::Utils.big_endian_encode(item, zero)
           else
-            raise InputOverflow.new("input length #{input.size} is too long")
+            buf = Ciri::Utils.big_endian_encode(item, zero)
+            [0x80 + buf.size].pack("c*") + buf
           end
+        elsif type == Bool
+          item ? Bool::ENCODED_TRUE : Bool::ENCODED_FALSE
+        elsif type.is_a?(Class) && type < Serializable
+          item.rlp_encode!
+        elsif type.is_a?(Array)
+          if type.size == 1 # array type
+            encode_list(item) {|i| encode_with_type(i, type[0])}
+          else # unknown
+            raise RLP::InvalidValueError.new "type size should be 1, got #{type}"
+          end
+        elsif type == Raw
+          encode_raw(item)
+        else
+          raise RLP::InvalidValueError.new "unknown type #{type}"
         end
+      rescue
+        STDERR.puts "when encoding #{Utils.data_to_hex item.to_s} into #{type}"
+        raise
+      end
 
-        def encode_list(input)
-          output = input.map {|item| encode(item)}.join
-          length = output.length
-          if length < 56
-            to_binary(0xc0 + length) + output
-          elsif length < 256 ** 8
-            binary_length = to_binary(length)
-            to_binary(0xf7 + binary_length.size) + binary_length + output
-          else
-            raise InputOverflow.new("input length #{input.size} is too long")
-          end
+      protected
+
+      def encode_raw(input)
+        result = if input.is_a?(String)
+                   encode_string(input)
+                 elsif input.is_a?(Array)
+                   encode_list(input) {|item| encode(item)}
+                 else
+                   raise ArgumentError.new("input must be a String or Array, #{input.inspect}")
+                 end
+        result.b
+      end
+
+      def encode_string(input)
+        length = input.length
+        if length == 1 && input.ord < 0x80
+          input
+        elsif length < 56
+          to_binary(0x80 + length) + input
+        elsif length < 256 ** 8
+          binary_length = to_binary(length)
+          to_binary(0xb7 + binary_length.size) + binary_length + input
+        else
+          raise InputOverflow.new("input length #{input.size} is too long")
         end
+      end
 
-        def to_binary(n)
-          Ciri::Utils.big_endian_encode(n)
+      def encode_list(input, &encoder)
+        input ||= [] # allow nil list
+        output = encoder ? input.map {|item| encoder.call(item)}.join : input.join
+        length = output.length
+        if length < 56
+          to_binary(0xc0 + length) + output
+        elsif length < 256 ** 8
+          binary_length = to_binary(length)
+          to_binary(0xf7 + binary_length.size) + binary_length + output
+        else
+          raise InputOverflow.new("input length #{input.size} is too long")
         end
+      end
+
+      private
 
+      def to_binary(n)
+        Ciri::Utils.big_endian_encode(n)
       end
+
     end
   end
 end