Merge branch 'develop' of https://github.com/ethereum/pyethereum into develop

Author: jnnk

ethereum/_solidity.py

@@ -0,0 +1,134 @@
+import subprocess
+import os
+
+
+class CompileError(Exception):
+    pass
+
+
+class solc_wrapper(object):
+
+    "wraps solc binary"
+
+    @classmethod
+    def compiler_available(cls):
+        program = 'solc'
+
+        def is_exe(fpath):
+            return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
+
+        fpath, fname = os.path.split(program)
+        if fpath:
+            if is_exe(program):
+                return program
+        else:
+            for path in os.environ["PATH"].split(os.pathsep):
+                path = path.strip('"')
+                exe_file = os.path.join(path, program)
+                if is_exe(exe_file):
+                    return exe_file
+
+        return None
+
+    @classmethod
+    def split_contracts(cls, code):
+        contracts = []
+        contract = None
+        for line in code.split('\n'):
+            if line.lstrip().startswith('contract '):  # FIXME
+                if contract:
+                    contracts.append('\n'.join(contract))
+                contract = [line]
+            elif contract:
+                contract.append(line)
+        if contract:
+            contracts.append('\n'.join(contract))
+        return contracts
+
+    @classmethod
+    def compile(cls, code):
+        p = subprocess.Popen(['solc', '--binary', 'stdout'],
+                             stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+        stdoutdata, stderrdata = p.communicate(input=code)
+        if p.returncode:
+            raise CompileError('compilation failed')
+
+        hex_code = stdoutdata.rsplit('Binary: \n')[-1].strip()
+        return hex_code.decode('hex')
+
+    @classmethod
+    def mk_full_signature(cls, code):
+        p = subprocess.Popen(['solc', '--json-abi', 'stdout'],
+                             stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+        stdoutdata, stderrdata = p.communicate(input=code)
+        if p.returncode:
+            raise CompileError('compilation failed')
+        jsonabi = stdoutdata.rsplit('Contract JSON ABI\n')[-1].strip()
+        return jsonabi
+
+
+def get_solidity():
+    try:
+        import solidity
+        tester.languages['solidity'] = solidity
+    except ImportError:
+        if not solc_wrapper.compiler_available():
+            return None
+        return solc_wrapper
+
+
+if __name__ == '__main__':
+    import tester
+    assert 'solidity' in tester.languages
+
+    one_contract = """
+
+    contract foo {
+        function seven() returns (int256 y) {
+            y = 7;
+        }
+        function mul2(int256 x) returns (int256 y) {
+            y = x * 2;
+        }
+    }
+    """
+
+    two_contracts = one_contract + """
+    contract baz {
+        function echo(address a) returns (address b) {
+            b = a;
+            return b;
+        }
+        function eight() returns (int256 y) {
+            y = 8;
+        }
+    }
+    """
+
+    # test
+    assert 'solidity' in tester.languages
+
+    s = tester.state()
+
+    c1 = s.abi_contract(one_contract, language='solidity')
+    assert c1.seven() == 7
+    assert c1.mul2(2) == 4
+    assert c1.mul2(-2) == -4
+
+    two_codes = solc_wrapper.split_contracts(two_contracts)
+    assert len(two_codes) == 2
+
+    for code in two_codes:
+        bytecode = solc_wrapper.compile(code)
+        jsonabi = solc_wrapper.mk_full_signature(code)
+        c = s.abi_contract(code, language='solidity')
+
+    c1 = s.abi_contract(two_codes[0], language='solidity')
+    assert c1.seven() == 7
+    assert c1.mul2(2) == 4
+    assert c1.mul2(-2) == -4
+
+    c2 = s.abi_contract(two_codes[1], language='solidity')
+    a = '\0' * 20
+    assert c2.echo(a).decode('hex') == a
+    assert c2.eight() == 8

ethereum/blocks.py

@@ -1240,7 +1240,7 @@ def chain_difficulty(self):
             return utils.decode_int(encoded)
         else:
             o = self.difficulty + self.get_parent().chain_difficulty()
-            o += sum([uncle.difficulty for uncle in self.uncles])
+            # o += sum([uncle.difficulty for uncle in self.uncles])
             self.state.db.put(b'difficulty:' + encode_hex(self.hash),
                               utils.encode_int(o))
             return o

ethereum/chain.py

@@ -270,8 +270,6 @@ def add_transaction(self, transaction):
                   if the transaction was invalid
         """
         assert self.head_candidate is not None
-        _log = log.bind(tx_hash=transaction)
-        _log.debug("add transaction")
         old_state_root = self.head_candidate.state_root
         # revert finalization
         self.head_candidate.state_root = self.pre_finalize_state_root
@@ -283,20 +281,18 @@ def add_transaction(self, transaction):
             log.debug('invalid tx', tx_hash=transaction, errors=e)
             success = False
 
-        # finalize
-        self.pre_finalize_state_root = self.head_candidate.state_root
-        self.head_candidate.finalize()
-
-        if not success:
-            log.debug('tx not applied', tx_hash=transaction)
-            assert old_state_root == self.head_candidate.state_root
-            return False
-        else:
+        if success:
             assert transaction in self.get_transactions()
-            log.debug('transaction applied', tx_hash=transaction,
+            self.pre_finalize_state_root = self.head_candidate.state_root
+            self.head_candidate.finalize()
+            log.debug('tx applied', tx_hash=transaction,
                       block_hash=self.head_candidate, result=output)
             assert old_state_root != self.head_candidate.state_root
             return True
+        else:
+            log.debug('tx not applied', tx_hash=transaction)
+            self.head_candidate.state_root = old_state_root  # reset
+            return False
 
     def get_transactions(self):
         """Get a list of new transactions not yet included in a mined block

ethereum/tester.py

@@ -8,6 +8,7 @@
 import ethereum.abi as abi
 from ethereum.slogging import LogRecorder, configure_logging, set_level
 from ethereum.utils import to_string
+from ethereum._solidity import get_solidity
 import rlp
 from rlp.utils import decode_hex, encode_hex, ascii_chr
 
@@ -31,6 +32,11 @@
 
 languages = {}
 
+_solidity = get_solidity()
+if _solidity:
+    languages['solidity'] = _solidity
+
+
 seed = 3 ** 160
 
 

ethereum/tests/test_solidity.py

@@ -35,3 +35,60 @@ def test_interop():
     # assert c2.sub2() == 7
     # assert c1.main(c2.address) == 14
     # assert c2.main(c1.address) == 10
+
+
+if __name__ == '__main__':
+
+    import subprocess
+
+    one_solidity_contract = """
+
+    contract foo {
+        function main(address a) returns (address b) {
+            b = a;
+            return b;
+        }
+        function sub2() returns (int256 y) {
+            y = 7;
+        }
+    }
+
+    """
+
+    class CompileError(Exception):
+        pass
+
+    class solc_wrapper(object):
+
+        @classmethod
+        def compile(cls, code):
+            p = subprocess.Popen(['solc', '--binary', 'stdout'],
+                                 stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+            stdoutdata, stderrdata = p.communicate(input=code)
+            if p.returncode:
+                raise CompileError('compilation failed')
+
+            hex_code = stdoutdata.rsplit('Binary: \n')[-1].strip()
+            return hex_code.decode('hex')
+
+        @classmethod
+        def mk_full_signature(cls, code):
+            p = subprocess.Popen(['solc', '--json-abi', 'stdout'],
+                                 stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+            stdoutdata, stderrdata = p.communicate(input=code)
+            if p.returncode:
+                raise CompileError('compilation failed')
+            jsonabi = stdoutdata.rsplit('Contract JSON ABI\n')[-1].strip()
+            return jsonabi
+
+    tester.languages['solidity'] = solc_wrapper
+
+    bytecode = solc_wrapper.compile(one_solidity_contract)
+    jsonabi = solc_wrapper.mk_full_signature(one_solidity_contract)
+
+    # test
+    s = tester.state()
+    c2 = s.abi_contract(one_solidity_contract, language='solidity')
+    a = '\0' * 20
+    assert c2.main(a).decode('hex') == a
+    assert c2.sub2() == 7

setup.py

@@ -32,7 +32,7 @@ def run_tests(self):
 # requirements
 install_requires = set(x.strip() for x in open('requirements.txt'))
 install_requires_replacements = {
-    'https://github.com/ethereum/pyrlp/tarball/develop': 'rlp>=0.3.7',
+    'https://github.com/ethereum/pyrlp/tarball/develop': 'rlp>=0.3.8',
     'https://github.com/ethereum/ethash/tarball/master': 'pyethash'}
 install_requires = [install_requires_replacements.get(r, r) for r in install_requires]
 
@@ -51,6 +51,6 @@ def run_tests(self):
       install_requires=install_requires,
       tests_require=tests_require,
       entry_points=dict(console_scripts=console_scripts),
-      version='0.9.64',
+      version='0.9.65',
       cmdclass=cmdclass
       )