Simplified transactions.py

Author: vub

ethereum/state_transition.py

@@ -237,7 +237,7 @@ def rp(what, actual, target):
             if tx.startgas < intrinsic_gas:
                 raise InsufficientStartGas(rp('startgas', tx.startgas, intrinsic_gas))
 
-    log_tx.debug('TX NEW', tx_dict=tx.log_dict(abbrev=True))
+    log_tx.debug('TX NEW', tx_dict=tx.to_dict())
     # start transacting #################
     state.increment_nonce(tx.sender)
 

ethereum/transactions.py

@@ -9,7 +9,7 @@
 from ethereum import opcodes
 from ethereum import utils
 from ethereum.slogging import get_logger
-from ethereum.utils import TT256, mk_contract_address, zpad, int_to_32bytearray, big_endian_to_int, ecsign, ecrecover_to_pub
+from ethereum.utils import TT256, mk_contract_address, zpad, int_to_32bytearray, big_endian_to_int, ecsign, ecrecover_to_pub, normalize_key
 
 
 log = get_logger('eth.chain.tx')
@@ -57,18 +57,13 @@ def __init__(self, nonce, gasprice, startgas, to, value, data, v=0, r=0, s=0):
         self.data = None
 
         to = utils.normalize_address(to, allow_blank=True)
-        assert len(to) == 20 or len(to) == 0
+
         super(Transaction, self).__init__(nonce, gasprice, startgas, to, value, data, v, r, s)
-        self.logs = []
         self.network_id = None
 
         if self.gasprice >= TT256 or self.startgas >= TT256 or \
                 self.value >= TT256 or self.nonce >= TT256:
             raise InvalidTransaction("Values way too high!")
-        if self.startgas < self.intrinsic_gas_used:
-            raise InvalidTransaction("Startgas too low")
-
-        log.debug('deserialized tx', tx=encode_hex(self.hash)[:8])
 
     @property
     def sender(self):
@@ -108,59 +103,42 @@ def sign(self, key, network_id=None):
 
         A potentially already existing signature would be overridden.
         """
-        if key in (0, '', b'\x00' * 32, '0' * 64):
-            raise InvalidTransaction("Zero privkey cannot sign")
         if network_id is None:
             rawhash = utils.sha3(rlp.encode(self, UnsignedTransaction))
         else:
             assert 1 <= network_id < 2**63 - 18
-            rlpdata = rlp.encode(rlp.infer_sedes(self).serialize(self)[:-3] + [big_endian_to_int(network_id), '', ''])
+            rlpdata = rlp.encode(rlp.infer_sedes(self).serialize(self)[:-3] + [big_endian_to_int(network_id), b'', b''])
             rawhash = utils.sha3(rlpdata)
 
-        if len(key) == 64:
-            # we need a binary key
-            key = encode_privkey(key, 'bin')
+        key = normalize_key(key)
 
         self.v, self.r, self.s = ecsign(rawhash, key)
         if network_id is not None:
             self.v += 8 + network_id * 2
 
-        self.sender = utils.privtoaddr(key)
+        self._sender = utils.privtoaddr(key)
         return self
 
     @property
     def hash(self):
         return utils.sha3(rlp.encode(self))
 
-    def log_bloom(self):
-        "returns int"
-        bloomables = [x.bloomables() for x in self.logs]
-        return bloom.bloom_from_list(utils.flatten(bloomables))
-
-    def log_bloom_b64(self):
-        return bloom.b64(self.log_bloom())
-
     def to_dict(self):
-        # TODO: previous version used printers
         d = {}
         for name, _ in self.__class__.fields:
             d[name] = getattr(self, name)
-        d['sender'] = self.sender
-        d['hash'] = encode_hex(self.hash)
-        return d
-
-    def log_dict(self, abbrev=False):
-        d = self.to_dict()
-        d['sender'] = encode_hex(d['sender'] or '')
-        d['to'] = encode_hex(d['to'])
-        d['data'] = encode_hex(d['data']) if len(d['data']) < 2500 or not abbrev else "data<%d>" % len(d['data'])
+            if name in ('to', 'data'):
+                d[name] = '0x' + encode_hex(d[name])
+        d['sender'] = '0x' + encode_hex(self.sender)
+        d['hash'] = '0x' + encode_hex(self.hash)
         return d
 
     @property
     def intrinsic_gas_used(self):
         num_zero_bytes = str_to_bytes(self.data).count(ascii_chr(0))
         num_non_zero_bytes = len(self.data) - num_zero_bytes
         return (opcodes.GTXCOST
+                + (0 if self.to else opcodes.CREATE[3])
                 + opcodes.GTXDATAZERO * num_zero_bytes
                 + opcodes.GTXDATANONZERO * num_non_zero_bytes)
 
@@ -198,9 +176,3 @@ def check_low_s_homestead(self):
 
 
 UnsignedTransaction = Transaction.exclude(['v', 'r', 's'])
-
-
-def contract(nonce, gasprice, startgas, endowment, code, v=0, r=0, s=0):
-    """A contract is a special transaction without the `to` argument."""
-    tx = Transaction(nonce, gasprice, startgas, '', endowment, code, v, r, s)
-    return tx

ethereum/utils.py

@@ -207,6 +207,20 @@ def normalize_address(x, allow_blank=False):
         raise Exception("Invalid address format: %r" % x)
     return x
 
+def normalize_key(key):
+    if len(key) == 32:
+        o = key
+    elif len(key) == 64:
+        o = decode_hex(key)
+    elif len(key) == 66 and key[:2] == '0x':
+        o = decode_hex(key[2:])
+    elif is_numeric(key):
+        o = encode_int32(key)
+    else:
+        raise Exception("Invalid key format: %r" % key)
+    if o == b'\x00' * 32:
+        raise Exception("Zero privkey invalid")
+    return o
 
 def zpad(x, l):
     return b'\x00' * max(0, l - len(x)) + x