ruby-ethereum 0.9.0

data/lib/ethereum/abi/contract_translator.rb

@@ -0,0 +1,174 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'json'
+
+module Ethereum
+  module ABI
+    class ContractTranslator
+
+      def initialize(full_signature)
+        @v = {
+          function_data: {},
+          event_data: {}
+        }
+
+        if full_signature.instance_of?(String)
+          full_signature = JSON.parse full_signature
+        end
+
+        full_signature.each do |sig_item|
+          next if sig_item['type'] == 'constructor'
+
+          encode_types = sig_item['inputs'].map {|f| f['type'] }
+          signature = sig_item['inputs'].map {|f| [f['type'], f['name']] }
+          name = sig_item['name']
+
+          if name =~ /\(/
+            name = name[0, name.index('(')]
+          end
+
+          # TODO: removable?
+          #if @v.has_key?(name.to_sym)
+          #  i = 2
+          #  i += 1 while @v.has_key?(:"#{name}#{i}")
+          #  name += i.to_s
+
+          #  logger.warn "multiple methods with the same name. Use #{name} to call #{sig_item['name']} with types #{encode_types}"
+          #end
+
+          if sig_item['type'] == 'function'
+            decode_types = sig_item['outputs'].map {|f| f['type'] }
+            is_unknown_type = sig_item['outputs'].size.true? && sig_item['outputs'][0]['name'] == 'unknown_out'
+            function_data[name.to_sym] = {
+              prefix: method_id(name, encode_types),
+              encode_types: encode_types,
+              decode_types: decode_types,
+              is_unknown_type: is_unknown_type,
+              is_constant: sig_item.fetch('constant', false),
+              signature: signature
+            }
+          elsif sig_item['type'] == 'event'
+            indexed = sig_item['inputs'].map {|f| f['indexed'] }
+            names = sig_item['inputs'].map {|f| f['name'] }
+
+            event_data[event_id(name, encode_types)] = {
+              types: encode_types,
+              name: name,
+              names: names,
+              indexed: indexed,
+              anonymous: sig_item.fetch('anonymous', false)
+            }
+          end
+        end
+      end
+
+      def encode(name, args)
+        fdata = function_data[name.to_sym]
+        id = Utils.zpad(Utils.encode_int(fdata[:prefix]), 4)
+        calldata = ABI.encode_abi fdata[:encode_types], args
+        "#{id}#{calldata}"
+      end
+
+      def decode(name, data)
+        fdata = function_data[name.to_sym]
+
+        if fdata[:is_unknown_type]
+          i = 0
+          o = []
+
+          while i < data.size
+            o.push Utils.to_signed(Utils.big_endian_to_int(data[i,32]))
+            i += 32
+          end
+
+          return 0 if o.empty?
+          o.size == 1 ? o[0] : o
+        else
+          ABI.decode_abi fdata[:decode_types], data
+        end
+      end
+
+      def function_data
+        @v[:function_data]
+      end
+
+      def event_data
+        @v[:event_data]
+      end
+
+      def function(name)
+        function_data[name.to_sym]
+      end
+
+      def event(name, encode_types)
+        event_data[event_id(name, encode_types)]
+      end
+
+      def is_unknown_type(name)
+        function_data[name.to_sym][:is_unknown_type]
+      end
+
+      def listen(log, noprint=false)
+        return if log.topics.size == 0 || !event_data.has_key?(log.topics[0])
+
+        data = event_data[log.topics[0]]
+        types = data[:types]
+        name = data[:name]
+        names = data[:names]
+        indexed = data[:indexed]
+        indexed_types = types.zip(indexed).select {|(t, i)| i.true? }.map(&:first)
+        unindexed_types = types.zip(indexed).select {|(t, i)| i.false? }.map(&:first)
+
+        deserialized_args = ABI.decode_abi unindexed_types, log.data
+
+        o = {}
+        c1, c2 = 0, 0
+        names.each_with_index do |n, i|
+          if indexed[i].true?
+            topic_bytes = Utils.zpad_int log.topics[c1+1]
+            o[n] = ABI.decode_primitive_type ABI::Type.parse(indexed_types[c1]), topic_bytes
+            c1 += 1
+          else
+            o[n] = deserialized_args[c2]
+            c2 += 1
+          end
+        end
+
+        o['_event_type'] = name
+        p o unless noprint
+
+        o
+      end
+
+      private
+
+      def logger
+        @logger ||= Logger.new 'eth.abi.contract_translator'
+      end
+
+      def method_id(name, encode_types)
+        Utils.big_endian_to_int Utils.keccak256(get_sig(name, encode_types))[0,4]
+      end
+
+      def event_id(name, encode_types)
+        Utils.big_endian_to_int Utils.keccak256(get_sig(name, encode_types))
+      end
+
+      def get_sig(name, encode_types)
+        "#{name}(#{encode_types.map {|x| canonical_name(x) }.join(',')})"
+      end
+
+      def canonical_name(x)
+        case x
+        when /\A(uint|int)(\[.*\])?\z/
+          "#{$1}256#{$2}"
+        when /\A(real|ureal|fixed|ufixed)(\[.*\])?\z/
+          "#{$1}128x128#{$2}"
+        else
+          x
+        end
+      end
+
+    end
+  end
+end

data/lib/ethereum/abi/type.rb

@@ -0,0 +1,117 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module ABI
+    class Type
+
+      class ParseError < StandardError; end
+
+      class <<self
+        ##
+        # Crazy regexp to seperate out base type component (eg. uint), size (eg.
+        # 256, 128x128, nil), array component (eg. [], [45], nil)
+        #
+        def parse(type)
+          _, base, sub, dimension = /([a-z]*)([0-9]*x?[0-9]*)((\[[0-9]*\])*)/.match(type).to_a
+
+          dims = dimension.scan(/\[[0-9]*\]/)
+          raise ParseError, "Unknown characters found in array declaration" if dims.join != dimension
+
+          case base
+          when 'string'
+            raise ParseError, "String type must have no suffix or numerical suffix" unless sub.empty?
+          when 'bytes'
+            raise ParseError, "Maximum 32 bytes for fixed-length string or bytes" unless sub.empty? || sub.to_i <= 32
+          when 'uint', 'int'
+            raise ParseError, "Integer type must have numerical suffix" unless sub =~ /\A[0-9]+\z/
+
+            size = sub.to_i
+            raise ParseError, "Integer size out of bounds" unless size >= 8 && size <= 256
+            raise ParseError, "Integer size must be multiple of 8" unless size % 8 == 0
+          when 'ureal', 'real', 'fixed', 'ufixed'
+            raise ParseError, "Real type must have suffix of form <high>x<low>, e.g. 128x128" unless sub =~ /\A[0-9]+x[0-9]+\z/
+
+            high, low = sub.split('x').map(&:to_i)
+            total = high + low
+
+            raise ParseError, "Real size out of bounds (max 32 bytes)" unless total >= 8 && total <= 256
+            raise ParseError, "Real high/low sizes must be multiples of 8" unless high % 8 == 0 && low % 8 == 0
+          when 'hash'
+            raise ParseError, "Hash type must have numerical suffix" unless sub =~ /\A[0-9]+\z/
+          when 'address'
+            raise ParseError, "Address cannot have suffix" unless sub.empty?
+          when 'bool'
+            raise ParseError, "Bool cannot have suffix" unless sub.empty?
+          else
+            raise ParseError, "Unrecognized type base: #{base}"
+          end
+
+          new(base, sub, dims.map {|x| x[1...-1].to_i })
+        end
+
+        def size_type
+          @size_type ||= new('uint', 256, [])
+        end
+      end
+
+      attr :base, :sub, :dims
+
+      ##
+      # @param base [String] base name of type, e.g. uint for uint256[4]
+      # @param sub  [String] subscript of type, e.g. 256 for uint256[4]
+      # @param dims [Array[Integer]] dimensions of array type, e.g. [1,2,0]
+      #   for uint256[1][2][], [] for non-array type
+      #
+      def initialize(base, sub, dims)
+        @base = base
+        @sub  = sub
+        @dims = dims
+      end
+
+      def ==(another_type)
+        base == another_type.base &&
+          sub == another_type.sub &&
+          dims == another_type.dims
+      end
+
+      ##
+      # Get the static size of a type, or nil if dynamic.
+      #
+      # @return [Integer, NilClass]  size of static type, or nil for dynamic
+      #   type
+      #
+      def size
+        @size ||= if dims.empty?
+                    if %w(string bytes).include?(base) && sub.empty?
+                      nil
+                    else
+                      32
+                    end
+                  else
+                    if dims.last == 0 # 0 for dynamic array []
+                      nil
+                    else
+                      subtype.dynamic? ? nil : dims.last * subtype.size
+                    end
+                  end
+      end
+
+      def dynamic?
+        size.nil?
+      end
+
+      ##
+      # Type with one dimension lesser.
+      #
+      # @example
+      #   Type.parse("uint256[2][]").subtype # => Type.new('uint', 256, [2])
+      #
+      # @return [Ethereum::ABI::Type]
+      #
+      def subtype
+        @subtype ||= self.class.new(base, sub, dims[0...-1])
+      end
+
+    end
+  end
+end

data/lib/ethereum/account.rb

@@ -0,0 +1,72 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+
+  ##
+  # An Ethereum account.
+  #
+  # * `@nonce`: the account's nonce (the number of transactions sent by the
+  #   account)
+  # * `@balance`: the account's balance in wei
+  # * `@storage`: the root of the account's storage trie
+  # * `@code_hash`: the SHA3 hash of the code associated with the account
+  # * `@db`: the database in which the account's code is stored
+  #
+  class Account
+    include RLP::Sedes::Serializable
+
+    set_serializable_fields(
+      nonce: Sedes.big_endian_int,
+      balance: Sedes.big_endian_int,
+      storage: Sedes.trie_root,
+      code_hash: Sedes.hash32
+    )
+
+    class <<self
+      ##
+      # Create a blank account.
+      #
+      # The returned account will have zero nonce and balance, a blank storage
+      # trie and empty code.
+      #
+      # @param db [BaseDB] the db in which the account will store its code
+      #
+      # @return [Account] the created blank account
+      #
+      def build_blank(db, initial_nonce=0)
+        code_hash = Utils.keccak256 Constant::BYTE_EMPTY
+        db.put code_hash, Constant::BYTE_EMPTY
+
+        new initial_nonce, 0, Trie::BLANK_ROOT, code_hash, db
+      end
+    end
+
+    def initialize(*args)
+      @db = args.pop if args.size == 5 # (nonce, balance, storage, code_hash, db)
+      @db = args.last.delete(:db) if args.last.is_a?(Hash)
+      raise ArgumentError, "No database object given" unless @db.is_a?(DB::BaseDB)
+
+      super(*args)
+    end
+
+    ##
+    # The EVM code of the account.
+    #
+    # This property will be read from or written to the db at each access, with
+    # `code_hash` used as key.
+    #
+    def code
+      @db.get code_hash
+    end
+
+    def code=(value)
+      self.code_hash = Utils.keccak256 value
+
+      # Technically a db storage leak, but doesn't really matter; the only
+      # thing that fails to get garbage collected is when code disappears due
+      # to a suicide.
+      @db.inc_refcount(code_hash, value)
+    end
+
+  end
+end

data/lib/ethereum/address.rb

@@ -0,0 +1,60 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  class Address
+
+    BLANK = ''.freeze
+    ZERO = ("\x00"*20).freeze
+
+    CREATE_CONTRACT = BLANK
+
+    def initialize(s)
+      @bytes = parse s
+    end
+
+    def to_bytes(extended=false)
+      extended ? "#{@bytes}#{checksum}" : @bytes
+    end
+
+    def to_hex(extended=false)
+      Utils.encode_hex to_bytes(extended)
+    end
+
+    def checksum(bytes=nil)
+      Utils.keccak256(bytes||@bytes)[0,4]
+    end
+
+    def blank?
+      @bytes == BLANK
+    end
+
+    private
+
+    def parse(s)
+      case s.size
+      when 0
+        s
+      when 40
+        Utils.decode_hex s
+      when 42
+        raise FormatError, "Invalid address format!" unless s[0,2] == '0x'
+        parse s[2..-1]
+      when 48
+        bytes = Utils.decode_hex s
+        parse bytes
+      when 50
+        raise FormatError, "Invalid address format!" unless s[0,2] == '0x'
+        parse s[2..-1]
+      when 20
+        s
+      when 24
+        bytes = s[0...-4]
+        raise ChecksumError, "Invalid address checksum!" unless s[-4..-1] == checksum(bytes)
+        bytes
+      else
+        raise FormatError, "Invalid address format!"
+      end
+    end
+
+  end
+end

data/lib/ethereum/base_convert.rb

@@ -0,0 +1,53 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module BaseConvert
+
+    BaseSymbols = {
+      2   => '01'.freeze,
+      10  => '0123456789'.freeze,
+      16  => '0123456789abcdef'.freeze,
+      32  => 'abcdefghijklmnopqrstuvwxyz234567'.freeze,
+      58  => '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'.freeze,
+      256 => 256.times.map {|i| i.chr }.join.freeze
+    }.freeze
+
+    extend self
+
+    def symbols(base)
+      BaseSymbols[base] or raise ArgumentError, "invalid base!"
+    end
+
+    def convert(s, from, to, minlen=0)
+      return Utils.lpad(s, symbols(from)[0], minlen) if from == to
+      encode decode(s, from), to, minlen
+    end
+
+    def encode(v, base, minlen)
+      syms = symbols(base)
+
+      result = ''
+      while v > 0
+        result = syms[v % base] + result
+        v /= base
+      end
+
+      Utils.lpad result, syms[0], minlen
+    end
+
+    def decode(s, base)
+      syms = symbols(base)
+      s = s.downcase if base == 16
+
+      result = 0
+      while s.size > 0
+        result *= base
+        result += syms.index(s[0])
+        s = s[1..-1]
+      end
+
+      result
+    end
+
+  end
+end