ruby-ethereum 0.9.3 → 0.9.4

data/lib/ethereum/abi/type.rb

@@ -28,14 +28,14 @@ module Ethereum
             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/
+          when 'fixed', 'ufixed'
+            raise ParseError, "Fixed 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
+            raise ParseError, "Fixed size out of bounds (max 32 bytes)" unless total >= 8 && total <= 256
+            raise ParseError, "Fixed 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'

data/lib/ethereum/address.rb

@@ -31,6 +31,8 @@ module Ethereum
     private
 
     def parse(s)
+      return Utils.int_to_addr(s) if s.is_a?(Integer)
+
       case s.size
       when 0
         s

data/lib/ethereum/block.rb

@@ -104,7 +104,9 @@ module Ethereum
         config = parent.config
         offset = parent.difficulty / config[:block_diff_factor]
 
-        if parent.number >= (config[:homestead_fork_blknum] - 1)
+        if parent.number >= (config[:metropolis_fork_blknum] - 1)
+          sign = [parent.uncles.size - ((ts - parent.timestamp) / config[:metropolis_diff_adjustment_cutoff]), -99].max
+        elsif parent.number >= (config[:homestead_fork_blknum] - 1)
           sign = [1 - ((ts - parent.timestamp) / config[:homestead_diff_adjustment_cutoff]), -99].max
         else
           sign = (ts - parent.timestamp) < config[:diff_adjustment_cutoff] ? 1 : -1
@@ -368,6 +370,8 @@ module Ethereum
       uncles.each do |uncle|
         parent = Block.find env, uncle.prevhash
         return false if uncle.difficulty != Block.calc_difficulty(parent, uncle.timestamp)
+        return false if uncle.number != parent.number + 1
+        return false if uncle.timestamp < parent.timestamp
         return false unless uncle.check_pow
 
         unless eligible_ancestor_hashes.include?(uncle.prevhash)
@@ -1116,7 +1120,13 @@ module Ethereum
     alias :inspect :to_s
 
     def validate_transaction(tx)
-      raise UnsignedTransactionError.new(tx) unless tx.sender
+      unless tx.sender
+        if number >= config[:metropolis_fork_blknum]
+          tx.sender = Utils.normalize_address(config[:metropolis_entry_point])
+        else
+          raise UnsignedTransactionError.new(tx)
+        end
+      end
 
       acct_nonce = get_nonce tx.sender
       raise InvalidNonce, "#{tx}: nonce actual: #{tx.nonce} target: #{acct_nonce}" if acct_nonce != tx.nonce
@@ -1158,6 +1168,8 @@ module Ethereum
         @transaction_count = 0 # TODO - should always equal @transactions.size
         self.gas_used = 0
 
+        hard_fork_initialize(parent)
+
         transaction_list.each {|tx| apply_transaction tx }
 
         finalize
@@ -1174,6 +1186,24 @@ module Ethereum
       end
     end
 
+    def hard_fork_initialize(parent)
+      if number == @config[:metropolis_fork_blknum]
+        set_code Utils.normalize_address(@config[:metropolis_stateroot_store]), @config[:metropolis_getter_code]
+        set_code Utils.normalize_address(@config[:metropolis_blockhash_store]), @config[:metropolis_getter_code]
+      end
+
+      if number >= @config[:metropolis_fork_blknum]
+        set_storage_data Utils.normalize_address(@config[:metropolis_stateroot_store]), (number % @config[:metropolis_wrapround]), parent.state_root
+        set_storage_data Utils.normalize_address(@config[:metropolis_blockhash_store]), (number % @config[:metropolis_wrapround]), prevhash
+      end
+
+      if number == @config[:dao_fork_blknum]
+        @config[:child_dao_list].each do |acct|
+          transfer_value acct, @config[:dao_withdrawer], get_balance(acct)
+        end
+      end
+    end
+
     ##
     # Validate block (header) against previous block.
     #
@@ -1184,6 +1214,7 @@ module Ethereum
       raise ValidationError, "Block's gaslimit is inconsistent with its parent's gaslimit" unless Block.check_gaslimit(parent, gas_limit)
       raise ValidationError, "Block's difficulty is inconsistent with its parent's difficulty" if difficulty != Block.calc_difficulty(parent, timestamp)
       raise ValidationError, "Gas used exceeds gas limit" if gas_used > gas_limit
+      raise ValidationError, "Block's gaslimit went too high!" if gas_limit > @config[:max_gas_limit]
       raise ValidationError, "Timestamp equal to or before parent" if timestamp <= parent.timestamp
       raise ValidationError, "Timestamp way too large" if timestamp > Constant::UINT_MAX
     end
@@ -1314,7 +1345,11 @@ module Ethereum
     end
 
     def mk_transaction_receipt(tx)
-      Receipt.new state_root, gas_used, logs
+      if number >= @config[:metropolis_fork_blknum]
+        Receipt.new Constant::HASH_ZERO, gas_used, logs
+      else
+        Receipt.new state_root, gas_used, logs
+      end
     end
 
   end

data/lib/ethereum/constant.rb

@@ -4,17 +4,19 @@ module Ethereum
   module Constant
 
     BYTE_EMPTY = "".freeze
-    BYTE_ZERO = "\x00".freeze
-    BYTE_ONE  = "\x01".freeze
+    BYTE_ZERO  = "\x00".freeze
+    BYTE_ONE   = "\x01".freeze
 
-    TT32  = 2**32
-    TT256 = 2**256
+    TT32   = 2**32
+    TT40   = 2**40
+    TT160  = 2**160
+    TT256  = 2**256
     TT64M1 = 2**64 - 1
 
     UINT_MAX = 2**256 - 1
     UINT_MIN = 0
-    INT_MAX = 2**255 - 1
-    INT_MIN = -2**255
+    INT_MAX  = 2**255 - 1
+    INT_MIN  = -2**255
 
     HASH_ZERO = ("\x00"*32).freeze
 

data/lib/ethereum/env.rb

@@ -20,6 +20,7 @@ module Ethereum
       # block.gas_limit = block.parent.gas_limit * 1023/1024 +
       #                     (block.gas.used * 6/5) / 1024
       min_gas_limit: 5000,
+      max_gas_limit: 2**63 - 1,
       gaslimit_ema_factor: 1024,
       gaslimit_adjmax_factor: 1024,
       blklim_factor_nom: 3,
@@ -46,8 +47,21 @@ module Ethereum
 
       account_initial_nonce: 0,
 
+      # Milestones
       homestead_fork_blknum: 1150000,
-      homestead_diff_adjustment_cutoff: 10
+      homestead_diff_adjustment_cutoff: 10,
+
+      metropolis_fork_blknum: 2**100,
+      metropolis_entry_point: 2**160-1,
+      metropolis_stateroot_store: 0x10,
+      metropolis_blockhash_store: 0x20,
+      metropolis_wrapround: 65536,
+      metropolis_getter_code: Utils.decode_hex('6000355460205260206020f3'),
+      metropolis_diff_adjustment_cutoff: 9,
+
+      dao_fork_blknum: 1920000,
+      child_dao_list: Utils.child_dao_list.map {|addr| Utils.normalize_address addr },
+      dao_withdrawer: Utils.normalize_address('0xbf4ed7b27f1d666546e30d74d50d173d20bca754')
     }.freeze
 
     attr :db, :config, :global_config

data/lib/ethereum/external_call.rb

@@ -12,7 +12,10 @@ module Ethereum
   class ExternalCall
 
     extend Forwardable
-    def_delegators :@block, :get_code, :get_balance, :set_balance, :get_storage_data, :set_storage_data, :add_refund, :account_exists
+    def_delegators :@block, :get_code, :set_code, :get_balance, :set_balance,
+      :delta_balance, :get_nonce, :set_nonce, :increment_nonce,
+      :get_storage_data, :set_storage_data, :get_storage_bytes, :reset_storage,
+      :add_refund, :account_exists, :snapshot, :revert, :transfer_value
 
     def initialize(block, tx)
       @block = block
@@ -28,11 +31,16 @@ module Ethereum
     end
 
     def block_hash(x)
-      d = @block.number - x
-      if d > 0 && d <= 256
-        @block.get_ancestor_hash d
+      if post_metropolis_hardfork
+        get_storage_data @block.config[:metropolis_blockhash_store], x
       else
-        Constant::BYTE_EMPTY
+        d = @block.number - x
+        hash = if d > 0 && d <= 256
+                 @block.get_ancestor_hash d
+               else
+                 Constant::BYTE_EMPTY
+               end
+        Utils.big_endian_to_int hash
       end
     end
 
@@ -72,30 +80,45 @@ module Ethereum
       @block.number >= @block.config[:homestead_fork_blknum]
     end
 
+    def post_metropolis_hardfork
+      @block.number >= @block.config[:metropolis_fork_blknum]
+    end
+
     def create(msg)
       log_msg.debug 'CONTRACT CREATION'
 
       sender = Utils.normalize_address(msg.sender, allow_blank: true)
 
-      @block.increment_nonce msg.sender if tx_origin != msg.sender
+      code = msg.data.extract_all
+      if post_metropolis_hardfork
+        msg.to = Utils.mk_metropolis_contract_address msg.sender, code
+        if get_code(msg.to)
+          n1 = get_nonce msg.to
+          n2 = n1 >= Constant::TT40 ?
+            (n + 1) :
+            (Utils.big_endian_to_int(msg.to) + 2)
+          set_nonce msg.to, (n2 % Constant::TT160)
+          msg.to = Utils.normalize_address((get_nonce(msg.to) - 1) % Constant::TT160)
+        end
+      else
+        increment_nonce msg.sender if tx_origin != msg.sender
 
-      nonce = Utils.encode_int(@block.get_nonce(msg.sender) - 1)
-      msg.to = Utils.mk_contract_address sender, nonce
+        nonce = Utils.encode_int(get_nonce(msg.sender) - 1)
+        msg.to = Utils.mk_contract_address sender, nonce
+      end
 
       balance = get_balance(msg.to)
       if balance > 0
         set_balance msg.to, balance
-        @block.set_nonce msg.to, 0
-        @block.set_code msg.to, Constant::BYTE_EMPTY
-        @block.reset_storage msg.to
+        set_nonce msg.to, 0
+        set_code msg.to, Constant::BYTE_EMPTY
+        reset_storage msg.to
       end
 
       msg.is_create = true
-
-      code = msg.data.extract_all
       msg.data = VM::CallData.new [], 0, 0
-      snapshot = @block.snapshot
 
+      snapshot = self.snapshot
       res, gas, dat = apply_msg msg, code
 
       if res.true?
@@ -108,13 +131,13 @@ module Ethereum
           dat = []
           log_msg.debug "CONTRACT CREATION OOG", have: gas, want: gcost, block_number: @block.number
 
-          if @block.number >= @block.config[:homestead_fork_blknum]
-            @block.revert snapshot
+          if post_homestead_hardfork
+            revert snapshot
             return 0, 0, Constant::BYTE_EMPTY
           end
         end
 
-        @block.set_code msg.to, Utils.int_array_to_bytes(dat)
+        set_code msg.to, Utils.int_array_to_bytes(dat)
         return 1, gas, msg.to
       else
         return 0, gas, Constant::BYTE_EMPTY
@@ -129,11 +152,11 @@ module Ethereum
       log_state.trace "MSG PRE STATE RECIPIENT", account: Utils.encode_hex(msg.to), balance: get_balance(msg.to), state: log_storage(msg.to)
 
       # snapshot before execution
-      snapshot = @block.snapshot
+      snapshot = self.snapshot
 
       # transfer value
       if msg.transfers_value
-        unless @block.transfer_value(msg.sender, msg.to, msg.value)
+        unless transfer_value(msg.sender, msg.to, msg.value)
           log_msg.debug "MSG TRANSFER FAILED", have: get_balance(msg.to), want: msg.value
           return [1, msg.gas, []]
         end
@@ -152,7 +175,7 @@ module Ethereum
 
       if res == 0
         log_msg.debug 'REVERTING'
-        @block.revert snapshot
+        revert snapshot
       end
 
       return res, gas, dat

data/lib/ethereum/tester/abi_contract.rb

@@ -6,26 +6,23 @@ module Ethereum
 
       attr :address, :abi
 
-      def initialize(state, abi, address, listen: true, log_listener: nil)
+      def initialize(state, abi, address, listen: true, log_listener: nil, default_key: nil)
         @state = state
-        @abi = abi
         @address = address
+        @default_key = default_key || Fixture.keys.first
 
-        @translator = ABI::ContractTranslator.new abi
+        @translator = abi.instance_of?(ABI::ContractTranslator) ? abi : ABI::ContractTranslator.new(abi)
 
         if listen
-          if log_listener
-            listener = lambda do |log|
-              r = @translator.listen(log, noprint: true)
-              log_listener.call r if r.true?
-            end
-          else
-            listener = ->(log) { @translator.listen(log, noprint: false) }
-          end
+          listener = ->(log) {
+            result = @translator.listen log, noprint: false
+            log_listener(result) if result && log_listener
+          }
+          @state.block.log_listeners.push listener
         end
 
-        @translator.function_data.each do |f, _|
-          generate_function f
+        @translator.function_data.each do |fn, _|
+          generate_function fn
         end
       end
 
@@ -38,7 +35,7 @@ module Ethereum
       def generate_function(f)
         singleton_class.class_eval <<-EOF
         def #{f}(*args, **kwargs)
-          sender = kwargs.delete(:sender) || Fixture.keys[0]
+          sender = kwargs.delete(:sender) || @default_key
           to = @address
           value = kwargs.delete(:value) || 0
           evmdata = @translator.encode('#{f}', args)
@@ -55,7 +52,7 @@ module Ethereum
             outdata = outdata.size == 1 ? outdata[0] : outdata
           end
 
-          kwargs[:profiling].true? ? o.merge(outdata: outdata) : outdata
+          kwargs[:profiling].true? ? o.merge(output: outdata) : outdata
         end
         EOF
       end

data/lib/ethereum/tester/solidity_wrapper.rb

@@ -8,125 +8,293 @@ module Ethereum
       class CompileError < StandardError; end
 
       class <<self
-        def split_contracts(code)
-          contracts = []
-          contract = nil
-
-          code.split("\n").each do |line|
-            if line =~ /\Acontract /
-              contracts.push(contract.join("\n")) if contract
-              contract = [line]
-            elsif contract
-              contract.push line
-            end
-          end
 
-          contracts.push(contract.join("\n")) if contract
+        def compile_code_or_path(code, path, contract_name, libraries, combined)
+          raise ValueError, 'code and path are mutually exclusive' if code && path
+
+          return compile_contract(path, contract_name, libraries: libraries, combined: combined) if path && contract_name.true?
+          return compile_last_contract(path, libraries: libraries, combined: combined) if path
+
+          all_names = solidity_names code
+          all_contract_names = all_names.map(&:last)
 
-          contracts
+          result = compile_code(code, libraries: libraries, combined: combined)
+          result[all_contract_names.last]
         end
 
-        def contract_names(code)
-          names = []
+        ##
+        # Returns binary of last contract in code.
+        #
+        def compile(code, contract_name: '', libraries: nil, path: nil)
+          result = compile_code_or_path code, path, contract_name, libraries, 'bin'
+          result['bin']
+        end
+
+        ##
+        # Returns signature of last contract in code.
+        #
+        def mk_full_signature(code, contract_name: '', libraries: nil, path: nil)
+          result = compile_code_or_path code, path, contract_name, libraries, 'abi'
+          result['abi']
+        end
+
+        ##
+        # Compile combined-json with abi,bin,devdoc,userdoc.
+        #
+        def combined(code, path: nil)
+          raise ValueError, "code and path are mutually exclusive." if code && path
 
-          split_contracts(code).each do |contract|
-            keyword, name, _ = contract.split(/\s+/, 3)
-            raise AssertError, 'keyword must be contract' unless keyword == 'contract' && !name.empty?
-            names.push name
+          if path
+            contracts = compile_file path
+            code = File.read(path)
+          elsif code
+            contracts = compile_code code
+          else
+            raise ValueError, 'either code or path needs to be supplied.'
           end
 
-          names
+          solidity_names(code).map do |(kind, name)|
+            [name, contracts[name]]
+          end
         end
 
-        def combined(code, format='bin')
-          out = Tempfile.new 'solc_output_'
+        ##
+        # Full format as returned by jsonrpc.
+        #
+        def compile_rich(code, path: nil)
+          combined(code, path: path).map do |(name, contract)|
+            [
+              name,
+              {
+                'code' => "0x#{contract['bin_hex']}",
+                'info' => {
+                  'abiDefinition' => contract['abi'],
+                  'compilerVersion' => compiler_version,
+                  'developerDoc' => contract['devdoc'],
+                  'language' => 'Solidity',
+                  'languageVersion' => '0',
+                  'source' => code,
+                  'userDoc' => contract['userdoc']
+                }
+              }
+            ]
+          end.to_h
+        end
 
-          pipe = IO.popen([solc_path, '--add-std', '--optimize', '--combined-json', "abi,#{format},devdoc,userdoc"], 'w', [:out, :err] => out)
+        def compile_code(code, libraries: nil, combined:'bin,abi', optimize: true)
+          args = solc_arguments libraries: libraries, combined: combined, optimize: optimize
+          args.unshift solc_path
+
+          out = Tempfile.new 'solc_output_'
+          pipe = IO.popen(args, 'w', [:out, :err] => out)
           pipe.write code
           pipe.close_write
           raise CompileError, 'compilation failed' unless $?.success?
 
           out.rewind
-          contracts = JSON.parse(out.read)['contracts']
-
-          contracts.each do |name, data|
-            data['abi'] = JSON.parse data['abi']
-            data['devdoc'] = JSON.parse data['devdoc']
-            data['userdoc'] = JSON.parse data['userdoc']
-          end
+          solc_parse_output out.read
+        end
 
-          names = contract_names code
-          raise AssertError unless names.size <= contracts.size
+        def compile_last_contract(path, libraries: nil, combined: 'bin,abi', optimize: true)
+          all_names = solidity_names File.read(path)
+          all_contract_names = all_names.map(&:last) # don't filter libraries
+          compile_contract path, all_contract_names.last, libraries: libraries, combined: combined, optimize: optimize
+        end
 
-          names.map {|n| [n, contracts[n]] }
-        ensure
-          out.close
+        def compile_contract(path, contract_name, libraries: nil, combined: 'bin,abi', optimize: true)
+          all_contracts = compile_file path, libraries: libraries, combined: combined, optimize: optimize
+          all_contracts[contract_name]
         end
 
         ##
-        # Returns binary of last contract in code.
+        # Return the compiled contract code.
         #
-        def compile(code, contract_name='', format='bin')
-          sorted_contracts = combined code, format
-          if contract_name.true?
-            idx = sorted_contracts.map(&:first).index(contract_name)
-          else
-            idx = -1
+        # @param path [String] Path to the contract source code.
+        # @param libraries [Hash] A hash mapping library name to its address.
+        # @param combined [Array[String]] The argument for solc's --combined-json.
+        # @param optimize [Bool] Enable/disables compiler optimization.
+        #
+        # @return [Hash] A mapping from the contract name to it's bytecode.
+        #
+        def compile_file(path, libraries: nil, combined: 'bin,abi', optimize: true)
+          workdir = File.dirname path
+          filename = File.basename path
+
+          args = solc_arguments libraries: libraries, combined: combined, optimize: optimize
+          args.unshift solc_path
+          args.push filename
+
+          out = Tempfile.new 'solc_output_'
+          Dir.chdir(workdir) do
+            pipe = IO.popen(args, 'w', [:out, :err] => out)
+            pipe.close_write
           end
 
-          output = sorted_contracts[idx][1][format]
-          case format
-          when 'bin'
-            Utils.decode_hex output
-          when 'asm'
-            output['.code']
-          when 'opcodes'
-            output
-          else
-            raise ArgumentError
+          out.rewind
+          solc_parse_output out.read
+        end
+
+        ##
+        # Return the library and contract names in order of appearence.
+        #
+        def solidity_names(code)
+          names = []
+          in_string = nil
+          backslash = false
+          comment = nil
+
+          # "parse" the code by hand to handle the corner cases:
+          #
+          # - the contract or library can be inside a comment or string
+          # - multiline comments
+          # - the contract and library keywords could not be at the start of the line
+          code.each_char.with_index do |char, pos|
+            if in_string
+              if !backslash && in_string == char
+                in_string = nil
+                backslash = false
+              end
+
+              backslash = char == "\\"
+            elsif comment == "//"
+              comment = nil if ["\n", "\r"].include?(char)
+            elsif comment == "/*"
+              comment = nil if char == "*" && code[pos + 1] == "/"
+            else
+              in_string = char if %w(' ").include?(char)
+
+              if char == "/"
+                char2 = code[pos + 1]
+                comment = char + char2 if %w(/ *).include?(char2)
+              end
+
+              if char == 'c' && code[pos, 8] == 'contract'
+                result = code[pos..-1] =~ /^contract[^_$a-zA-Z]+([_$a-zA-Z][_$a-zA-Z0-9]*)/
+                names.push ['contract', $1] if result
+              end
+
+              if char == 'l' && code[pos, 7] == 'library'
+                result = code[pos..-1] =~ /^library[^_$a-zA-Z]+([_$a-zA-Z][_$a-zA-Z0-9]*)/
+                names.push ['library', $1] if result
+              end
+            end
           end
+
+          names
         end
 
         ##
-        # Returns signature of last contract in code.
+        # Return the symbol used in the bytecode to represent the
+        # `library_name`.
         #
-        def mk_full_signature(code, contract_name='')
-          sorted_contracts = combined code
-          if contract_name.true?
-            idx = sorted_contracts.map(&:first).index(contract_name)
-          else
-            idx = -1
+        # The symbol is always 40 characters in length with the minimum of two
+        # leading and trailing underscores.
+        #
+        def solidity_library_symbol(library_name)
+          len = [library_name.size, 36].min
+          lib_piece = library_name[0,len]
+          hold_piece = '_' * (36 - len)
+          "__#{lib_piece}#{hold_piece}__"
+        end
+
+        ##
+        # Change the bytecode to use the given library address.
+        #
+        # @param hex_code [String] The bytecode encoded in hex.
+        # @param library_name [String] The library that will be resolved.
+        # @param library_address [String] The address of the library.
+        #
+        # @return [String] The bytecode encoded in hex with the library
+        #   references.
+        #
+        def solidity_resolve_address(hex_code, library_symbol, library_address)
+          raise ValueError, "Address should not contain the 0x prefix" if library_address =~ /\A0x/
+          raise ValueError, "Address with wrong length" if library_symbol.size != 40 || library_address.size != 40
+
+          begin
+            Utils.decode_hex library_address
+          rescue TypeError
+            raise ValueError, "library_address contains invalid characters, it must be hex encoded."
+          end
+
+          hex_code.gsub library_symbol, library_address
+        end
+
+        def solidity_resolve_symbols(hex_code, libraries)
+          symbol_address = libraries
+            .map {|name, addr| [solidity_library_symbol(name), addr] }
+            .to_h
+
+          solidity_unresolved_symbols(hex_code).each do |unresolved|
+            address = symbol_address[unresolved]
+            hex_code = solidity_resolve_address(hex_code, unresolved, address)
           end
 
-          sorted_contracts[idx][1]['abi']
+          hex_code
+        end
+
+        ##
+        # Return the unresolved symbols contained in the `hex_code`.
+        #
+        # Note: the binary representation should not be provided since this
+        # function relies on the fact that the '_' is invalid in hex encoding.
+        #
+        # @param hex_code [String] The bytecode encoded as hex.
+        #
+        def solidity_unresolved_symbols(hex_code)
+          hex_code.scan(/_.{39}/).uniq
         end
 
         def compiler_version
           output = `#{solc_path} --version`.strip
-          output =~ /^Version: ([0-9a-z.-]+)\// ? $1 : nil
+          output =~ /^Version: ([0-9a-z.-]+)\///m ? $1 : nil
         end
 
         ##
-        # Full format as returned by jsonrpc.
+        # Parse compiler output.
         #
-        def compile_rich(code)
-          combined(code).map do |(name, contract)|
-            [
-              name,
-              {
-                'code' => "0x#{contract['bin']}",
-                'info' => {
-                  'abiDefinition' => contract['abi'],
-                  'compilerVersion' => compiler_version,
-                  'developerDoc' => contract['devdoc'],
-                  'language' => 'Solidity',
-                  'languageVersion' => '0',
-                  'source' => code,
-                  'userDoc' => contract['userdoc']
-                }
-              }
-            ]
-          end.to_h
+        def solc_parse_output(compiler_output)
+          result = JSON.parse(compiler_output)['contracts']
+
+          if result.values.first.has_key?('bin')
+            result.each_value do |v|
+              v['bin_hex'] = v['bin']
+
+              # decoding can fail if the compiled contract has unresolved symbols
+              begin
+                v['bin'] = Utils.decode_hex v['bin']
+              rescue TypeError
+                # do nothing
+              end
+            end
+          end
+
+          %w(abi devdoc userdoc).each do |json_data|
+            next unless result.values.first.has_key?(json_data)
+
+            result.each_value do |v|
+              v[json_data] = JSON.parse v[json_data]
+            end
+          end
+
+          result
+        end
+
+        def solc_arguments(libraries: nil, combined: 'bin,abi', optimize: true)
+          args = [
+            '--combined-json', combined,
+            '--add-std'
+          ]
+
+          args.push '--optimize' if optimize
+
+          if libraries && !libraries.empty?
+            addresses = libraries.map {|name, addr| "#{name}:#{addr}" }
+            args.push '--libraries'
+            args.push addresses.join(',')
+          end
+
+          args
         end
 
         def solc_path