ruby-ethereum 0.9.0

data/lib/ethereum/spv/proof.rb

@@ -0,0 +1,31 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'set'
+
+module Ethereum
+  module SPV
+    class Proof
+
+      attr :nodes, :exempts
+
+      def initialize(nodes: Set.new, exempts: [])
+        @nodes = nodes
+        @exempts = exempts
+      end
+
+      def decoded_nodes
+        nodes.map {|n| RLP.decode(n) }
+      end
+
+      def add_node(node)
+        node = FastRLP.encode node
+        nodes.add(node) unless exempts.include?(node)
+      end
+
+      def add_exempt(node)
+        exempts.add FastRLP.encode(node)
+      end
+
+    end
+  end
+end

data/lib/ethereum/spv/proof_constructor.rb

@@ -0,0 +1,19 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'set'
+
+module Ethereum
+  module SPV
+    class ProofConstructor < Proof
+
+      def grabbing(node)
+        add_node node.dup
+      end
+
+      def store(node)
+        add_exempt node.dup
+      end
+
+    end
+  end
+end

data/lib/ethereum/spv/proof_verifier.rb

@@ -0,0 +1,24 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'set'
+
+module Ethereum
+  module SPV
+    class ProofVerifier < Proof
+
+      def initialize(nodes, exempts: [])
+        nodes = nodes.map {|n| RLP.encode(n) }.to_set
+        super(nodes: nodes, exempts: exempts)
+      end
+
+      def grabbing(node)
+        raise InvalidSPVProof unless nodes.include?(FastRLP.encode(node))
+      end
+
+      def store(node)
+        add_node node.dup
+      end
+
+    end
+  end
+end

data/lib/ethereum/tester.rb

@@ -0,0 +1,14 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'ethereum/tester/abi_contract'
+require 'ethereum/tester/fixture'
+require 'ethereum/tester/solidity_wrapper'
+require 'ethereum/tester/language'
+require 'ethereum/tester/log_recorder'
+require 'ethereum/tester/state'
+
+module Ethereum
+  module Tester
+
+  end
+end

data/lib/ethereum/tester/abi_contract.rb

@@ -0,0 +1,65 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module Tester
+    class ABIContract
+
+      attr :address, :abi
+
+      def initialize(state, abi, address, listen: true, log_listener: nil)
+        @state = state
+        @abi = abi
+        @address = address
+
+        @translator = 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
+        end
+
+        @translator.function_data.each do |f, _|
+          generate_function f
+        end
+      end
+
+      def listen(x)
+        @translator.listen x
+      end
+
+      private
+
+      def generate_function(f)
+        singleton_class.class_eval <<-EOF
+        def #{f}(*args, **kwargs)
+          sender = kwargs.delete(:sender) || Fixture.keys[0]
+          to = @address
+          value = kwargs.delete(:value) || 0
+          evmdata = @translator.encode('#{f}', args)
+          output = kwargs.delete(:output)
+
+          o = @state._send_tx(sender, to, value, **kwargs.merge(evmdata: evmdata))
+
+          if output == :raw
+            outdata = o[:output]
+          elsif o[:output].false?
+            outdata = nil
+          else
+            outdata = @translator.decode '#{f}', o[:output]
+            outdata = outdata.size == 1 ? outdata[0] : outdata
+          end
+
+          kwargs[:profiling].true? ? o.merge(outdata: outdata) : outdata
+        end
+        EOF
+      end
+
+    end
+  end
+end

data/lib/ethereum/tester/fixture.rb

@@ -0,0 +1,31 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module Tester
+    module Fixture
+
+      NUM_ACCOUNTS = 10
+
+      class <<self
+        def keys
+          @keys ||= NUM_ACCOUNTS.times.map {|i| Utils.keccak256(i.to_s) }
+        end
+
+        def accounts
+          @accounts ||= NUM_ACCOUNTS.times.map {|i| PrivateKey.new(keys[i]).to_address }
+        end
+
+        def gas_limit
+          @gas_limit ||= 3141592
+        end
+        attr_writer :gas_limit
+
+        def gas_price
+          @gas_price ||= 1
+        end
+        attr_writer :gas_price
+      end
+
+    end
+  end
+end

data/lib/ethereum/tester/language.rb

@@ -0,0 +1,30 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module Tester
+    module Language
+
+      class <<self
+        def all
+          return @all if @all
+
+          @all = {
+            serpent: Serpent,
+            solidity: SolidityWrapper.solc_path && SolidityWrapper
+          }
+
+          @all
+        end
+
+        def get(name)
+          all[name]
+        end
+
+        def format_spaces(code)
+          code =~ /\A(\s+)/ ? code.gsub(/^#{$1}/, '') : code
+        end
+      end
+
+    end
+  end
+end

data/lib/ethereum/tester/log_recorder.rb

@@ -0,0 +1,13 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module Tester
+    module LogRecorder
+
+      def initialize
+        @records = []
+      end
+
+    end
+  end
+end

data/lib/ethereum/tester/solidity_wrapper.rb

@@ -0,0 +1,144 @@
+# -*- encoding : ascii-8bit -*-
+
+module Ethereum
+  module Tester
+
+    module SolidityWrapper
+
+      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
+
+          contracts
+        end
+
+        def contract_names(code)
+          names = []
+
+          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
+          end
+
+          names
+        end
+
+        def combined(code)
+          out = Tempfile.new 'solc_output_'
+
+          pipe = IO.popen([solc_path, '--add-std', '--optimize', '--combined-json', 'abi,bin,devdoc,userdoc'], '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
+
+          names = contract_names code
+          raise AssertError unless names.size <= contracts.size
+
+          names.map {|n| [n, contracts[n]] }
+        ensure
+          out.close
+        end
+
+        ##
+        # Returns binary of last contract in code.
+        #
+        def compile(code, contract_name='')
+          sorted_contracts = combined code
+          if contract_name.true?
+            idx = sorted_contracts.map(&:first).index(contract_name)
+          else
+            idx = -1
+          end
+
+          Utils.decode_hex sorted_contracts[idx][1]['bin']
+        end
+
+        ##
+        # Returns signature of last contract in code.
+        #
+        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
+          end
+
+          sorted_contracts[idx][1]['abi']
+        end
+
+        def compiler_version
+          output = `#{solc_path} --version`.strip
+          output =~ /^Version: ([0-9a-z.-]+)\// ? $1 : nil
+        end
+
+        ##
+        # Full format as returned by jsonrpc.
+        #
+        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
+        end
+
+        def solc_path
+          @solc_path ||= which('solc')
+        end
+
+        def solc_path=(v)
+          @solc_path = v
+        end
+
+        def which(cmd)
+          exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+          ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+            exts.each { |ext|
+              exe = File.join(path, "#{cmd}#{ext}")
+              return exe if File.executable?(exe) && !File.directory?(exe)
+            }
+          end
+          return nil
+        end
+      end
+    end
+
+  end
+end

data/lib/ethereum/tester/state.rb

@@ -0,0 +1,194 @@
+# -*- encoding : ascii-8bit -*-
+
+require 'fileutils'
+
+module Ethereum
+  module Tester
+    class State
+
+      TMP_DIR_PREFIX = 'eth-tester-'.freeze
+
+      attr :block, :blocks
+
+      def initialize(num_accounts=Fixture::NUM_ACCOUNTS)
+        @temp_data_dir = Dir.mktmpdir TMP_DIR_PREFIX
+
+        @db = DB::EphemDB.new
+        @env = Env.new @db
+
+        @block = Block.genesis @env, start_alloc: get_start_alloc(num_accounts)
+        @block.timestamp = 1410973349
+        @block.coinbase = Fixture.accounts[0]
+        @block.gas_limit = 10**9
+
+        @blocks = [@block]
+        @last_tx = nil
+
+        ObjectSpace.define_finalizer(self) {|id| FileUtils.rm_rf(@temp_data_dir) }
+      end
+
+      def contract(code, sender: Fixture.keys[0], endowment: 0, language: :serpent, gas: nil)
+        code = Language.format_spaces code
+        opcodes = Language.get(language).compile(code)
+        addr = evm(opcodes, sender: sender, endowment: endowment)
+        raise AssertError, "Contract code empty" if @block.get_code(addr).empty?
+        addr
+      end
+
+      def abi_contract(code, **kwargs)
+        sender        = kwargs.delete(:sender) || Fixture.keys[0]
+        endowment     = kwargs.delete(:endowment) || 0
+        language      = kwargs.delete(:language) || :serpent
+        contract_name = kwargs.delete(:contract_name) || ''
+        gas           = kwargs.delete(:gas) || nil
+        log_listener  = kwargs.delete(:log_listener) || nil
+        listen        = kwargs.delete(:listen) || true
+
+        code = Language.format_spaces code
+
+        if contract_name.true?
+          raise ArgumentError, "language must be solidity when contract name is given" unless language == :solidity
+          cn_args = {contract_name: contract_name}
+        else
+          cn_args = kwargs
+        end
+
+        lang = Language.get language
+        opcodes = lang.compile code, **cn_args
+        addr = evm(opcodes, sender: sender, endowment: endowment, gas: gas)
+        raise AssertError, "Contract code empty" if @block.get_code(addr).empty?
+
+        abi = lang.mk_full_signature(code, **cn_args)
+        ABIContract.new(self, abi, addr, listen: listen, log_listener: log_listener)
+      end
+
+      def evm(opcodes, sender: Fixture.keys[0], endowment: 0, gas: nil)
+        sendnonce = @block.get_nonce PrivateKey.new(sender).to_address
+
+        tx = Transaction.contract sendnonce, Fixture.gas_price, Fixture.gas_limit, endowment, opcodes
+        tx.sign sender
+        tx.startgas = gas if gas
+
+        success, output = @block.apply_transaction tx
+        raise ContractCreationFailed if success.false?
+
+        output
+      end
+
+      def call(*args, **kwargs)
+        raise DeprecatedError, "Call deprecated. Please use the abi_contract mechanism or message(sender, to, value, data) directly, using the ABI module to generate data if needed."
+      end
+
+      def send_tx(*args, **kwargs)
+        _send_tx(*args, **kwargs)[:output]
+      end
+
+      def _send_tx(sender, to, value, evmdata: '', output: nil, funid: nil, abi: nil, profiling: 0)
+        if funid || abi
+          raise ArgumentError, "Send with funid+abi is deprecated. Please use the abi_contract mechanism."
+        end
+
+        t1, g1 = Time.now, @block.gas_used
+        sendnonce = @block.get_nonce PrivateKey.new(sender).to_address
+        tx = Transaction.new(sendnonce, Fixture.gas_price, Fixture.gas_limit, to, value, evmdata)
+        @last_tx = tx
+        tx.sign(sender)
+
+        recorder = profiling > 1 ? LogRecorder.new : nil
+
+        success, output = @block.apply_transaction(tx)
+        raise TransactionFailed if success.false?
+        out = {output: output}
+
+        if profiling > 0
+          zero_bytes = tx.data.count Constant::BYTE_ZERO
+          none_zero_bytes = tx.data.size - zero_bytes
+          intrinsic_gas_used = Opcodes::GTXCOST +
+            Opcodes::GTXDATAZERO * zero_bytes +
+            Opcodes::GTXDATANONZERO * none_zero_bytes
+          t2, g2 = Time.now, @block.gas_used
+          output[:time] = t2 - t1
+          output[:gas] = g2 - g1 - intrinsic_gas_used
+        end
+
+        if profiling > 1
+          # TODO: collect all traced ops use LogRecorder
+        end
+
+        out
+      end
+
+      def profile(*args, **kwargs)
+        kwargs[:profiling] = true
+        _send_tx(*args, **kwargs)
+      end
+
+      def mkspv(sender, to, value, data: [], funid: nil, abi: nil)
+        sendnonce = @block.get_nonce PrivateKey.new(sender).to_address
+        evmdata = funid ? Serpent.encode_abi(funid, *abi) : Serpent.encode_datalist(*data)
+
+        tx = Transaction.new(sendnonce, Fixture.gas_price, Fixture.gas_limit, to, value, evmdata)
+        @last_tx = tx
+        tx.sign(sender)
+
+        SPV.make_transaction_proof(@block, tx)
+      end
+
+      def verifyspv(sender, to, value, data: [], funid: nil, abi: nil, proof: [])
+        sendnonce = @block.get_nonce PrivateKey.new(sender).to_address
+        evmdata = funid ? Serpent.encode_abi(funid, *abi) : Serpent.encode_datalist(*data)
+
+        tx = Transaction.new(sendnonce, Fixture.gas_price, Fixture.gas_limit, to, value, evmdata)
+        @last_tx = tx
+        tx.sign(sender)
+
+        SPV.verify_transaction_proof(@block, tx, proof)
+      end
+
+      def trace(sender, to, value, data=[])
+        recorder = LogRecorder.new
+        send_tx sender, to, value, data
+        recorder.pop_records # TODO: implement recorder
+      end
+
+      def mine(n=1, coinbase: Fixture.accounts[0])
+        n.times do |i|
+          @block.finalize
+          @block.commit_state
+
+          @db.put @block.full_hash, RLP.encode(@block)
+
+          t = @block.timestamp + 6 + rand(12)
+          x = Block.build_from_parent @block, coinbase, timestamp: t
+          @block = x
+
+          @blocks.push @block
+        end
+      end
+
+      def snapshot
+        RLP.encode @block
+      end
+
+      def revert(data)
+        @block = RLP.decode data, sedes: Block, env: @env
+
+        @block.make_mutable!
+        @block._cached_rlp = nil
+
+        @block.header.make_mutable!
+        @block.header._cached_rlp = nil
+      end
+
+      private
+
+      def get_start_alloc(num_accounts)
+        o = {}
+        num_accounts.times {|i| o[Fixture.accounts[i]] = {wei: 10**24} }
+        (1...5).each {|i| o[Utils.int_to_addr(i)] = {wei: 1} }
+        o
+      end
+
+    end
+  end
+end