Python utils.encode_int函数代码示例

def apply_tx(block,tx):
    fee = tx.gasprice * tx.startgas
    addrstate = block.state.get(tx.sender.decode('hex'))
    if not addrstate:
        raise Exception("Sending from a not-yet-existent account!")
    if decode_int(addrstate[NONCE_INDEX]) != tx.nonce:
        print decode_int(addrstate[NONCE_INDEX]), tx.nonce
        raise Exception("Invalid nonce!")
    if decode_int(addrstate[BALANCE_INDEX]) < fee:
        raise Exception("Not enough in account to pay fee!")
    addrstate[NONCE_INDEX] = encode_int(decode_int(addrstate[NONCE_INDEX])+1)
    addrstate[BALANCE_INDEX] = encode_int(decode_int(addrstate[BALANCE_INDEX])-fee)
    block.state.update(tx.sender.decode('hex'),addrstate)
    block.gas_consumed += fee
    medroot = block.state.root
    message_gas = tx.startgas - GTXDATA * len(tx.data)
    message = Message(tx.sender,tx.to,tx.value,message_gas,tx.data)
    if tx.to:
        s,g,d = apply_msg(block,tx,message)
    else:
        s,g = create_contract(block,tx,message)
    if not s:
        block.state.root = medroot
        minerstate = block.state.get(block.coinbase)
        minerstate[BALANCE_INDEX] = encode_int(decode_int(minerstate[BALANCE_INDEX])+fee)
        block.state.update(block.coinbase,minerstate)
    else:
        addrstate[BALANCE_INDEX] = encode_int(decode_int(addrstate[BALANCE_INDEX])+tx.gasprice * g)
        block.state.update(tx.sender.decode('hex'),addrstate)
        minerstate = block.state.get(block.coinbase.decode('hex')) or ['','','','']
        minerstate[BALANCE_INDEX] = encode_int(decode_int(minerstate[BALANCE_INDEX])+(fee - g * tx.gasprice))
        block.state.update(block.coinbase.decode('hex'),minerstate)

def verify(block, parent):
    def must_equal(what, a, b):
        if not a == b: raise VerificationFailed(what, a, '==', b)

    if not block.timestamp >= parent.timestamp:
        raise VerificationFailed('timestamp', block.timestamp, '>=', parent.timestamp)
    if not block.timestamp <= time.time() + 900:
        raise VerificationFailed('timestamps', block.timestamp, '<=', time.time() + 900)

    block2 = blocks.Block.init_from_parent(parent,
                                           block.coinbase,
                                           extra_data=block.extra_data,
                                           timestamp=block.timestamp,
                                           uncles=block.uncles)
    must_equal('difficulty', block2.difficulty, block.difficulty)
    must_equal('gas limit', block2.gas_limit, block.gas_limit)
    for i in range(block.transaction_count):
        tx, s, g = rlp.decode(
            block.transactions.get(rlp.encode(utils.encode_int(i))))
        tx = transactions.Transaction.create(tx)
        if not tx.startgas + block2.gas_used <= block.gas_limit:
            raise VerificationFailed('gas_limit', tx.startgas + block2.gas_used, '<=', block.gas_limit)
        apply_transaction(block2, tx)
        must_equal('tx state root', s, block2.state.root_hash)
        must_equal('tx gas used', g, utils.encode_int(block2.gas_used))
    block2.finalize()
    must_equal('block state root', block2.state.root_hash, block.state.root_hash)
    must_equal('block gas used', block2.gas_used, block.gas_used)
    return True

def create_contract(block,tx,msg):
    oldroot = block.state.root
    senderstate = block.state.get(msg.sender) or ['','','','']
    recvstate = ['','',sha3(msg.data),'']
    recvaddr = sha3(rlp.encode([msg.sender,senderstate[NONCE_INDEX]]))[12:]
    code = msg.data
    statedb.put(sha3(msg.data),msg.data)
    compustate = Compustate(gas=msg.gas)
    # Not enough vaue to send, instaquit
    if decode_int(senderstate[BALANCE_INDEX]) < msg.value:
        recvstate[2] = []
        block.state.update(recvaddr,recvstate)
        return recvaddr, compustate.gas
    # Transfer value and update nonce
    senderstate[BALANCE_INDEX] = encode_int(decode_int(senderstate[BALANCE_INDEX])-msg.value)
    senderstate[NONCE_INDEX] = encode_int(decode_int(senderstate[NONCE_INDEX])+1)
    recvstate[BALANCE_INDEX] = encode_int(decode_int(senderstate[BALANCE_INDEX])+msg.value)
    block.state.update(msg.sender.decode('hex'),senderstate)
    block.state.update(recvaddr,recvstate)
    # Temporary pre-POC5: don't do the code/init thing
    return recvaddr, compustate.gas
    # Main loop
    while 1:
        o = apply_op(block,tx,msg,msg.data,compustate.op)
        if o is not None:
            if o == OUT_OF_GAS:
                block.state.root = oldroot
                return 0, 0
            else:
                recvstate = block.state.get(recvaddr)
                recvstate[CODE_INDEX] = sha3(map(chr,o))
                statedb.put(sha3(map(chr,o)),map(chr,o))
                block.state.update(recvaddr,recvstate)
                return recvaddr, recvstate

 def mk_blank_acct(self):
     if not hasattr(self, '_blank_acct'):
         codehash = utils.sha3('')
         self.state.db.put(codehash, '')
         self._blank_acct = [utils.encode_int(0),
                             utils.encode_int(0),
                             trie.BLANK_ROOT,
                             codehash]
     return self._blank_acct[:]

 def serialize(self):
     txlist = [x.serialize() for x in self.transactions]
     header = [encode_int(self.number),
               self.prevhash,
               sha3(rlp.encode(self.uncles)),
               self.coinbase.decode('hex'),
               self.state.root,
               sha3(rlp.encode(txlist)),
               encode_int(self.difficulty),
               encode_int(self.timestamp),
               self.extradata,
               encode_int(self.nonce)]
     return rlp.encode([header, txlist, self.uncles])

 def to_dict(self, with_state=False, full_transactions=False, with_storage_roots=False):
     """
     serializes the block
     with_state:             include state for all accounts
     full_transactions:      include serialized tx (hashes otherwise)
     """
     b = {}
     for name, typ, default in block_structure:
         b[name] = utils.printers[typ](getattr(self, name))
     txlist = []
     for i in range(self.transaction_count):
         tx_rlp = self.transactions.get(rlp.encode(utils.encode_int(i)))
         tx, msr, gas = rlp.decode(tx_rlp)
         if full_transactions:
             txjson = transactions.Transaction.create(tx).to_dict()
         else:
             txjson = utils.sha3(rlp.descend(tx_rlp, 0)).encode('hex')  # tx hash
         txlist.append({
             "tx": txjson,
             "medstate": msr.encode('hex'),
             "gas": str(utils.decode_int(gas))
         })
     b["transactions"] = txlist
     if with_state:
         state_dump = {}
         for address, v in self.state.to_dict().iteritems():
             state_dump[address.encode('hex')] = \
                 self.account_to_dict(address, with_storage_roots)
         b['state'] = state_dump
     return b

def create_contract(block,tx,msg):
    snapshot = block.snapshot()
    sender = msg.sender.decode('hex') if len(msg.sender) == 40 else msg.sender
    nonce = encode_int(block.get_nonce(msg.sender))
    recvaddr = sha3(rlp.encode([sender,nonce]))[12:]
    code = msg.data
    # Transfer value, instaquit if not enough
    block.delta_balance(recvaddr,msg.value)
    o = block.delta_balance(msg.sender,msg.value)
    if not o:
        return 0, msg.gas
    block.set_code(recvaddr,msg.data)
    compustate = Compustate(gas=msg.gas)
    # Temporary pre-POC5: don't do the code/init thing
    return recvaddr, compustate.gas
    # Main loop
    while 1:
        o = apply_op(block,tx,msg,msg.data,compustate.op)
        if o is not None:
            if o == OUT_OF_GAS:
                block.state.root = oldroot
                return 0, 0
            else:
                block.set_code(''.join(map(chr,o)))
                return recvaddr, compustate.gas

def apply_tx(block, tx):
    if not tx.sender:
        raise Exception("Trying to apply unsigned transaction!")
    acctnonce = block.get_nonce(tx.sender)
    if acctnonce != tx.nonce:
        raise Exception("Invalid nonce! Sender %s tx %s" %
                        (acctnonce, tx.nonce))
    o = block.delta_balance(tx.sender, -tx.gasprice * tx.startgas)
    if not o:
        raise Exception("Insufficient balance to pay fee!")
    block.increment_nonce(tx.sender)
    snapshot = block.snapshot()
    message_gas = tx.startgas - GTXDATA * len(tx.serialize()) - GTXCOST
    message = Message(tx.sender, tx.to, tx.value, message_gas, tx.data)
    if tx.to:
        result, gas, data = apply_msg(block, tx, message)
    else:
        result, gas = create_contract(block, tx, message)
    if not result:  # 0 = OOG failure in both cases
        block.revert(snapshot)
        block.gas_used += tx.startgas
        block.delta_balance(block.coinbase, tx.gasprice * tx.startgas)
        output = OUT_OF_GAS
    else:
        block.delta_balance(tx.sender, tx.gasprice * gas)
        block.delta_balance(block.coinbase, tx.gasprice * (tx.startgas - gas))
        block.gas_used += tx.startgas - gas
        output = ''.join(map(chr, data)) if tx.to else result.encode('hex')
    tx_data = [tx.serialize(), block.state.root, encode_int(block.gas_used)]
    block.add_transaction_to_list(tx_data)
    success = output is not OUT_OF_GAS
    return success, output if success else ''

 def listen(self, log, noprint=True):
     if not len(log.topics) or log.topics[0] not in self.event_data:
         return
     types = self.event_data[log.topics[0]]['types']
     name = self.event_data[log.topics[0]]['name']
     names = self.event_data[log.topics[0]]['names']
     indexed = self.event_data[log.topics[0]]['indexed']
     indexed_types = [types[i] for i in range(len(types))
                      if indexed[i]]
     unindexed_types = [types[i] for i in range(len(types))
                        if not indexed[i]]
     # print('listen', encode_hex(log.data), log.topics)
     deserialized_args = decode_abi(unindexed_types, log.data)
     o = {}
     c1, c2 = 0, 0
     for i in range(len(names)):
         if indexed[i]:
             topic_bytes = utils.zpad(utils.encode_int(log.topics[c1 + 1]), 32)
             o[names[i]] = decode_single(process_type(indexed_types[c1]),
                                         topic_bytes)
             c1 += 1
         else:
             o[names[i]] = deserialized_args[c2]
             c2 += 1
     o["_event_type"] = utils.to_string(name)
     if not noprint:
         print(o)
     return o

def create_contract(block, tx, msg):
    snapshot = block.snapshot()

    sender = msg.sender.decode('hex') if len(msg.sender) == 40 else msg.sender
    nonce = utils.encode_int(block.get_nonce(msg.sender))
    recvaddr = utils.sha3(rlp.encode([sender, nonce]))[12:]
    assert not block.get_code(recvaddr)
    msg.to = recvaddr
    block.increment_nonce(msg.sender)
    # Transfer value, instaquit if not enough
    o = block.transfer_value(msg.sender, msg.to, msg.value)
    if not o:
        return 0, msg.gas
    compustate = Compustate(gas=msg.gas)
    # Main loop
    while 1:
        o = apply_op(block, tx, msg, msg.data, compustate)
        if o is not None:
            if o == OUT_OF_GAS:
                block.revert(snapshot)
                return 0, 0, []
            else:
                for s in block.suicides:
                    block.state.delete(utils.encode_addr(s))
                block.set_code(recvaddr, ''.join(map(chr, o)))
                return recvaddr, compustate.gas, o

 def _list_transactions(self):
     # returns [[tx_lst_serialized, state_root, gas_used_encoded],...]
     txlist = []
     for i in range(self.transaction_count):
         txlist.append(rlp.decode(
             self.transactions.get(utils.encode_int(i))))
     return txlist

 def set_storage_data(self,address,index,val):
     t = self.get_storage(address)
     if val:
         t.update(utils.coerce_to_bytes(index),encode_int(val))
     else:
         t.delete(utils.coerce_to_bytes(index))
     self.set_index(address,STORAGE_INDEX,t.root)

 def set_storage_data(self, address, index, val):
     t = self.get_storage(address)
     if val:
         t.update(utils.coerce_to_bytes(index), utils.encode_int(val))
     else:
         t.delete(utils.coerce_to_bytes(index))
     self._set_acct_item(address, 'storage', t.root_hash)

 def delta_index(self,address,index,value):
     if len(address) == 40: address = address.decode('hex')
     acct = self.state.get(address) or ['','','','']
     if decode_int(acct[index]) + value < 0:
         return False
     acct[index] = encode_int(decode_int(acct[index])+value)
     self.state.update(address,acct)
     return True

def mk_independent_transaction_spv_proof(block, index):
    print block, index, block._list_transactions()
    block = blocks.Block.init_from_header(block.list_header())
    tx = transactions.Transaction.create(block.get_transaction(index)[0])
    if index > 0:
        _, pre_med, pre_gas = block.get_transaction(index - 1)
    else:
        pre_med, pre_gas = block.get_parent().state_root, 0
    block.state_root = pre_med
    block.gas_used = pre_gas
    nodes = mk_transaction_spv_proof(block, tx)
    nodes.extend(block.transactions.produce_spv_proof(rlp.encode(utils.encode_int(index))))
    if index > 0:
        nodes.extend(block.transactions.produce_spv_proof(rlp.encode(utils.encode_int(index - 1))))
    nodes = map(rlp.decode, list(set(map(rlp.encode, nodes))))
    return rlp.encode([utils.encode_int(64), block.get_parent().list_header(),
                       block.list_header(), utils.encode_int(index), nodes])