ciri 0.0.0 → 0.0.1

data/lib/ciri/rlp/serializable.rb

@@ -29,7 +29,11 @@ module Ciri
     # represent bool types: true | false
     class Bool
       ENCODED_TRUE = Ciri::Utils.big_endian_encode(0x01)
-      ENCODED_FALSE = Ciri::Utils.big_endian_encode(0x00)
+      ENCODED_FALSE = Ciri::Utils.big_endian_encode(0x80)
+    end
+
+    # represent RLP raw types, binary or array
+    class Raw
     end
 
     # Serializable module allow ruby objects serialize/deserialize to or from RLP encoding.
@@ -71,26 +75,38 @@ module Ciri
     #
     module Serializable
       # nil represent RLP raw value(string or array of string)
-      TYPES = [nil, Integer, Bool].map {|key| [key, true]}.to_h.freeze
+      TYPES = [Raw, Integer, Bool].map {|key| [key, true]}.to_h.freeze
 
       # Schema specific columns types of classes, normally you should not use Serializable::Schema directly
       #
       class Schema
+        include Encode
+        include Decode
+
         class InvalidSchemaError < StandardError
         end
 
         # keys return data columns array
         attr_reader :keys
 
+        KeySchema = Struct.new(:type, :options, keyword_init: true)
+
         def initialize(schema)
           keys = []
           @_schema = {}
 
           schema.each do |key|
-            key, type = key.is_a?(Hash) ? key.to_a[0] : [key, nil]
+            if key.is_a?(Hash)
+              options = [:optional].map {|o| [o, key.delete(o)]}.to_h
+              raise InvalidSchemaError.new("include unknown options #{key}") unless key.size == 1
+              key, type = key.to_a[0]
+            else
+              options = {}
+              type = Raw
+            end
             raise InvalidSchemaError.new("missing type #{type} for key #{key}") unless check_key_type(type)
             keys << key
-            @_schema[key] = type
+            @_schema[key] = KeySchema.new(type: type, options: options)
           end
 
           @_schema.freeze
@@ -109,25 +125,38 @@ module Ciri
           end
         end
 
-        def rlp_encode!(data, raw: true)
+        def rlp_encode!(data, skip_keys: nil, white_list_keys: nil)
           # pre-encode, encode data to rlp compatible format(only string or array)
-          data_list = keys.map do |key|
-            Serializable.encode_with_type(data[key], self[key])
+          used_keys = if white_list_keys
+                        white_list_keys
+                      elsif skip_keys
+                        keys - skip_keys
+                      else
+                        keys
+                      end
+          data_list = []
+          used_keys.each do |key|
+            value = data[key]
+            next if value.nil? && self[key].options[:optional]
+            data_list << encode_with_type(value, self[key].type)
           end
-          raw ? RLP.encode(data_list) : data_list
+          encode_list(data_list)
         end
 
-        def rlp_decode!(input, raw: true)
-          data = raw ? RLP.decode(input) : input
-          keys.each_with_index.map do |key, i|
-            # decode data by type
-            decoded_item = Serializable.decode_with_type(data[i], self[key])
-            [key, decoded_item]
-          end.to_h
+        def rlp_decode!(input)
+          values = decode_list(input) do |list, stream|
+            keys.each do |key|
+              # decode data by type
+              next if stream.eof? && self[key].options[:optional]
+              list << decode_with_type(stream, self[key].type)
+            end
+          end
+          # convert to key value hash
+          keys.zip(values).to_h
         end
 
-
         private
+
         def check_key_type(type)
           return true if TYPES.key?(type)
           return true if type.is_a?(Class) && type < Serializable
@@ -142,8 +171,8 @@ module Ciri
 
       module ClassMethods
         # Decode object from input
-        def rlp_decode(input, raw: true)
-          data = schema.rlp_decode!(input, raw: raw)
+        def rlp_decode(input)
+          data = schema.rlp_decode!(input)
           self.new(data)
         end
 
@@ -161,15 +190,16 @@ module Ciri
         end
 
         private
+
         def define_attributes(schema)
           schema.keys.each do |attribute|
             module_eval <<-ATTR_METHODS
             def #{attribute}
-              data[:"#{attribute}"]
+              serializable_attributes[:"#{attribute}"]
             end
 
             def #{attribute}=(value)
-              data[:"#{attribute}"] = value 
+              serializable_attributes[:"#{attribute}"] = value 
             end
             ATTR_METHODS
           end
@@ -180,87 +210,27 @@ module Ciri
         def included(base)
           base.send :extend, ClassMethods
         end
-
-        # use this method before RLP.encode
-        # encode item to string or array
-        def encode_with_type(item, type, zero: '')
-          if type == Integer
-            if item == 0
-              "\x80".b
-            elsif item < 128
-              Ciri::Utils.big_endian_encode(item, zero)
-            else
-              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!(raw: false)
-          elsif type.is_a?(Array)
-            if type.size == 1 # array type
-              item.map {|i| encode_with_type(i, type[0])}
-            else # unknown
-              raise InvalidValueError.new "type size should be 1, got #{type}"
-            end
-          else
-            raise InvalidValueError.new "unknown type #{type}" unless TYPES.key?(type)
-            item
-          end
-        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)
-        #   decode_with_type(item, Integer)
-        #
-        def decode_with_type(item, type)
-          if type == Integer
-            if item == "\x80".b || item.empty?
-              0
-            elsif item[0].ord < 0x80
-              Ciri::Utils.big_endian_decode(item)
-            else
-              size = item[0].ord - 0x80
-              Ciri::Utils.big_endian_decode(item[1..size])
-            end
-          elsif type == Bool
-            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
-            # already decoded from RLP encoding
-            type.rlp_decode!(item, raw: false)
-          elsif type.is_a?(Array)
-            item.map {|i| decode_with_type(i, type[0])}
-          else
-            raise InvalidValueError.new "unknown type #{type}" unless TYPES.key?(type)
-            item
-          end
-        end
       end
 
-      attr_reader :data
+      attr_reader :serializable_attributes
 
       def initialize(**data)
-        @data = (self.class.default_data || {}).merge(data)
-        self.class.schema.validate!(@data)
+        @serializable_attributes = (self.class.default_data || {}).merge(data)
+        self.class.schema.validate!(@serializable_attributes)
+      end
+
+      def initialize_copy(orig)
+        super
+        @serializable_attributes = orig.serializable_attributes.dup
       end
 
       # Encode object to rlp encoding string
-      def rlp_encode!(raw: true)
-        self.class.schema.rlp_encode!(data, raw: raw)
+      def rlp_encode!(skip_keys: nil, white_list_keys: nil)
+        self.class.schema.rlp_encode!(serializable_attributes, skip_keys: skip_keys, white_list_keys: white_list_keys)
       end
 
       def ==(other)
-        self.class == other.class && data == other.data
+        self.class == other.class && serializable_attributes == other.serializable_attributes
       end
 
     end

data/lib/ciri/types/address.rb

@@ -0,0 +1,70 @@
+# 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 'errors'
+require 'ciri/rlp'
+
+module Ciri
+  module Types
+    class Address
+
+      include RLP::Serializable
+      include Errors
+
+      def initialize(address)
+        @address = address.to_s
+      end
+
+      def rlp_encode!
+        RLP.encode(@address)
+      end
+
+      def self.rlp_decode!(data)
+        address = self.new(RLP.decode(data))
+        address.validate
+        address
+      end
+
+      def to_s
+        @address
+      end
+
+      alias to_str to_s
+
+      def to_hex
+        Utils.data_to_hex to_s
+      end
+
+      def empty?
+        @address.empty?
+      end
+
+      def validate
+        # empty address is valid
+        return if empty?
+        raise InvalidError.new("address must be 20 size, got #{@address.size}") unless @address.size == 20
+      end
+
+    end
+  end
+end

data/lib/ciri/types/errors.rb

@@ -0,0 +1,36 @@
+# 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.
+
+
+module Ciri
+  module Types
+    module Errors
+
+      class Error < StandardError
+      end
+
+      class InvalidError < Error
+      end
+
+    end
+  end
+end

data/lib/ciri/utils.rb

@@ -22,11 +22,15 @@
 
 
 require 'digest/sha3'
+require_relative 'utils/number'
 
 module Ciri
   module Utils
 
     class << self
+      include Utils::Number
+
+
       def sha3(*data)
         s = Digest::SHA3.new(256)
         data.each {|i| s.update(i)}
@@ -37,24 +41,24 @@ module Ciri
         s1.size == s2.size && s1.each_byte.each_with_index.map {|b, i| b ^ s2[i].ord}.reduce(0, :+) == 0
       end
 
-      def big_endian_encode(n, zero = '')
-        if n == 0
-          zero
-        else
-          big_endian_encode(n / 256) + (n % 256).chr
-        end
+      def hex_to_data(hex)
+        data = [hex].pack("H*")
+        data = data[1..-1] if data.size > 0 && data[0].ord == 1
+        data
       end
 
-      def big_endian_decode(input)
-        input.each_byte.reduce(0) {|s, i| s * 256 + i}
+      def hex_to_number(hex)
+        big_endian_decode hex_to_data(hex)
       end
 
-      def hex_to_data(hex)
-        [hex].pack("H*")
+      def data_to_hex(data)
+        hex = data.to_s.unpack("H*").first
+        hex[0..1] = '0x' if hex.start_with?('01')
+        hex
       end
 
-      def data_to_hex(data)
-        data.unpack("H*").first
+      def number_to_hex(number)
+        data_to_hex big_endian_encode(number)
       end
 
       def create_ec_pk(raw_pubkey: nil, raw_privkey: nil)
@@ -69,7 +73,35 @@ module Ciri
           key.private_key = OpenSSL::BN.new(raw_privkey, 2) if raw_privkey
         end
       end
+
+      def to_underscore(str)
+        str.gsub(/[A-Z]/) {|a| "_" + a.downcase}
+      end
+
+      def blank_binary?(item)
+        return true if item.is_a?(String) && item.each_byte.all?(&:zero?)
+        blank?(item)
+      end
+
+      def blank?(item)
+        if item.nil?
+          true
+        elsif item.is_a? Integer
+          item.zero?
+        elsif item.is_a? String
+          item.empty?
+        else
+          false
+        end
+      end
+
+      def present?(item)
+        !blank?(item)
+      end
+
     end
 
+    BLANK_SHA3 = Utils.sha3(''.b).freeze
+
   end
-end
+end

data/lib/ciri/utils/lib_c.rb

@@ -0,0 +1,46 @@
+# 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'
+
+module Ciri
+  module Utils
+
+    module LibC
+      extend FFI::Library
+      ffi_lib FFI::Library::LIBC
+
+      # memory allocators
+      attach_function :malloc, [:size_t], :pointer
+      attach_function :calloc, [:size_t], :pointer
+      attach_function :valloc, [:size_t], :pointer
+      attach_function :realloc, [:pointer, :size_t], :pointer
+      attach_function :free, [:pointer], :void
+
+      # memory movers
+      attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
+      attach_function :bcopy, [:pointer, :pointer, :size_t], :void
+    end
+
+  end
+end