def verify_dc_sig(self, sig, msghash, msgsize, from_addr, data): # data comes in as array of byte array (bytes as ints, from js) tohash = byte_arrays_to_string(data) assert (msghash == utils.sha3(tohash)) X, Y = ecdsa_raw_recover(msghash, sig) pX = utils.int_to_big_endian(X).encode('hex') pY = utils.int_to_big_endian(Y).encode('hex') pub = '04'+pX+pY return ecdsa_raw_verify(msghash, sig, pub.decode('hex'))
def verify_dc_sig(self, sig, msghash, msgsize, from_addr, data): # data comes in as array of byte array (bytes as ints, from js) tohash = byte_arrays_to_string(data) assert (msghash == utils.sha3(tohash)) X, Y = ecdsa_raw_recover(msghash, sig) pX = utils.int_to_big_endian(X).encode('hex') pY = utils.int_to_big_endian(Y).encode('hex') pub = '04' + pX + pY return ecdsa_raw_verify(msghash, sig, pub.decode('hex'))
def account_to_dict(self, address, with_storage_root=False): if with_storage_root: assert len(self.journal) == 0 med_dict = {} for i, val in enumerate(self.get_acct(address)): name, typ, default = acct_structure[i] key = acct_structure[i][0] if name == 'storage': strie = trie.Trie(utils.get_db_path(), val) if with_storage_root: med_dict['storage_root'] = strie.get_root_hash().encode( 'hex') else: med_dict[key] = self.caches[key].get(address, utils.printers[typ](val)) med_dict['storage'] = {} d = strie.to_dict() for k in d.keys() + self.caches['all'].keys(): v = d.get(k, None) subcache = self.caches.get('storage:' + address, {}) v2 = subcache.get(utils.big_endian_to_int(k), None) hexkey = '0x' + k.encode('hex') if v2 is not None: if v2 != 0: med_dict['storage'][ hexkey] = '0x' + utils.int_to_big_endian(v2).encode( 'hex') elif v is not None: med_dict['storage'][hexkey] = '0x' + rlp.decode(v).encode( 'hex') return med_dict
def commit_state(self): changes = [] if not len(self.journal): # log_state.trace('delta', changes=[]) return for address in self.caches['all']: acct = rlp.decode(self.state.get(address.decode('hex'))) \ or self.mk_blank_acct() for i, (key, typ, default) in enumerate(acct_structure): if key == 'storage': t = trie.Trie(self.db, acct[i]) for k, v in self.caches.get('storage:' + address, {}).iteritems(): enckey = utils.zpad(utils.coerce_to_bytes(k), 32) val = rlp.encode(utils.int_to_big_endian(v)) changes.append(['storage', address, k, v]) if v: t.update(enckey, val) else: t.delete(enckey) acct[i] = t.root_hash else: if address in self.caches[key]: v = self.caches[key].get(address, default) changes.append([key, address, v]) acct[i] = self.encoders[acct_structure[i][1]](v) self.state.update(address.decode('hex'), rlp.encode(acct)) log_state.trace('delta', changes=changes) self.reset_cache()
def to_dict(self): return dict(address=self.address, topics=[ utils.zpad(utils.int_to_big_endian(x), 32).encode('hex') for x in self.topics ], data='0x' + self.data.encode('hex'))
def account_to_dict(self, address, with_storage_root=False, with_storage=True, for_vmtest=False): if with_storage_root: assert len(self.journal) == 0 med_dict = {} for i, val in enumerate(self.get_acct(address)): name, typ, default = acct_structure[i] key = acct_structure[i][0] if name == 'storage': strie = trie.Trie(self.db, val) if with_storage_root: med_dict['storage_root'] = strie.get_root_hash().encode('hex') else: med_dict[key] = utils.printers[typ](self.caches[key].get(address, val)) if with_storage: med_dict['storage'] = {} d = strie.to_dict() subcache = self.caches.get('storage:' + address, {}) subkeys = [utils.zpad(utils.coerce_to_bytes(kk), 32) for kk in subcache.keys()] for k in d.keys() + subkeys: v = d.get(k, None) v2 = subcache.get(utils.big_endian_to_int(k), None) hexkey = '0x' + utils.zunpad(k).encode('hex') if v2 is not None: if v2 != 0: med_dict['storage'][hexkey] = \ '0x' + utils.int_to_big_endian(v2).encode('hex') elif v is not None: med_dict['storage'][hexkey] = '0x' + rlp.decode(v).encode('hex') return med_dict
def account_to_dict(self, address, with_storage_root=False): if with_storage_root: assert len(self.journal) == 0 med_dict = {} for i, val in enumerate(self.get_acct(address)): name, typ, default = acct_structure[i] key = acct_structure[i][0] if name == 'storage': strie = trie.Trie(utils.get_db_path(), val) if with_storage_root: med_dict['storage_root'] = strie.get_root_hash().encode('hex') else: med_dict[key] = self.caches[key].get(address, utils.printers[typ](val)) med_dict['storage'] = {} d = strie.to_dict() for k in d.keys() + self.caches['all'].keys(): v = d.get(k, None) subcache = self.caches.get('storage:'+address, {}) v2 = subcache.get(utils.big_endian_to_int(k), None) hexkey = '0x'+k.encode('hex') if v2 is not None: if v2 != 0: med_dict['storage'][hexkey] = '0x'+utils.int_to_big_endian(v2).encode('hex') elif v is not None: med_dict['storage'][hexkey] = '0x'+rlp.decode(v).encode('hex') return med_dict
def add_block(self, block): blockhash = block.hash() if blockhash == GENESIS_H: parent_score = 0 else: try: parent = rlp.decode(self.blockchain.get(block.prevhash)) except: raise Exception("Parent of block not found") parent_score = utils.big_endian_to_int(parent[1]) total_score = utils.int_to_big_endian(block.difficulty + parent_score) self.blockchain.put( blockhash, rlp.encode([block.serialize(), total_score])) try: head = self.blockchain.get('head') head_data = rlp.decode(self.blockchain.get(head)) head_score = utils.big_endian_to_int(head_data[1]) except: head_score = 0 if total_score > head_score: self.head = blockhash self.blockchain.put('head', blockhash) return True return False
def commit_state(self): if not len(self.journal): return for address in self.caches['all']: acct = rlp.decode(self.state.get(address.decode('hex'))) \ or self.mk_blank_acct() for i, (key, typ, default) in enumerate(acct_structure): if key == 'storage': t = trie.Trie(utils.get_db_path(), acct[i]) t.proof_mode = self.proof_mode t.proof_nodes = self.proof_nodes for k, v in self.caches.get('storage:'+address, {}).iteritems(): enckey = utils.zpad(utils.coerce_to_bytes(k), 32) val = rlp.encode(utils.int_to_big_endian(v)) if v: t.update(enckey, val) else: t.delete(enckey) acct[i] = t.root_hash if self.proof_mode == RECORDING: self.proof_nodes.extend(t.proof_nodes) else: if address in self.caches[key]: v = self.caches[key].get(address, default) acct[i] = utils.encoders[acct_structure[i][1]](v) self.state.update(address.decode('hex'), rlp.encode(acct)) if self.proof_mode == RECORDING: self.proof_nodes.extend(self.state.proof_nodes) self.state.proof_nodes = [] self.reset_cache()
def commit_state(self): if not len(self.journal): return for address in self.caches['all']: acct = rlp.decode(self.state.get(address.decode('hex'))) \ or self.mk_blank_acct() for i, (key, typ, default) in enumerate(acct_structure): if key == 'storage': t = trie.Trie(utils.get_db_path(), acct[i]) t.proof_mode = self.proof_mode t.proof_nodes = self.proof_nodes for k, v in self.caches.get('storage:' + address, {}).iteritems(): enckey = utils.zpad(utils.coerce_to_bytes(k), 32) val = rlp.encode(utils.int_to_big_endian(v)) if v: t.update(enckey, val) else: t.delete(enckey) acct[i] = t.root_hash if self.proof_mode == RECORDING: self.proof_nodes.extend(t.proof_nodes) else: if address in self.caches[key]: v = self.caches[key].get(address, default) acct[i] = utils.encoders[acct_structure[i][1]](v) self.state.update(address.decode('hex'), rlp.encode(acct)) if self.proof_mode == RECORDING: self.proof_nodes.extend(self.state.proof_nodes) self.state.proof_nodes = [] self.reset_cache()
def encode_length(L, offset): if L < 56: return chr(L + offset) elif L < 256**8: BL = int_to_big_endian(L) return chr(len(BL) + offset + 55) + BL else: raise Exception("input too long")
def encode_length(L, offset): if L < 56: return chr(L + offset) elif L < 256 ** 8: BL = int_to_big_endian(L) return chr(len(BL) + offset + 55) + BL else: raise Exception("input too long")
def quickcontract(self, gasprice, startgas, value, code, pkey_hex): sender = privtoaddr(pkey_hex) nonce = self.getnonce(sender) tx = contract(nonce, gasprice, startgas, value, code) formatted_rlp = [sender.decode('hex'), utils.int_to_big_endian(nonce)] addr = utils.sha3(rlp.encode(formatted_rlp))[12:].encode('hex') o = self.applytx(sign(tx, pkey_hex)) o['addr'] = addr return o
def length_prefix(length, offset): """Construct the prefix to lists or strings denoting their length. :param length: the length of the item in bytes :param offset: ``0x80`` when encoding raw bytes, ``0xc0`` when encoding a list """ if length < 56: return chr(offset + length) else: length_string = int_to_big_endian(length) return chr(offset + 56 - 1 + len(length_string)) + length_string
def contract_address(self): """For contract creation transactions, return the address of the new account. :raises `ValueError`: if the transaction is not signed :raises `ValueError`: if the transaction is not a contract creation """ if self.sender == 0: raise ValueError('Transaction is not signed') if bool(self.to): raise ValueError('Transaction is not a contract creation') formatted_rlp = [self.sender.decode('hex'), utils.int_to_big_endian(self.nonce)] address = utils.sha3(rlp.encode(formatted_rlp))[12:].encode('hex') return address
def contract_address(self): """For contract creation transactions, return the address of the new account. :raises `ValueError`: if the transaction is not signed :raises `ValueError`: if the transaction is not a contract creation """ if self.sender == 0: raise ValueError('Transaction is not signed') if bool(self.to): raise ValueError('Transaction is not a contract creation') formatted_rlp = [ self.sender.decode('hex'), utils.int_to_big_endian(self.nonce) ] address = utils.sha3(rlp.encode(formatted_rlp))[12:].encode('hex') return address
def commit_state(self): for address in self.caches['all']: acct = rlp.decode(self.state.get(address.decode('hex'))) \ or self.mk_blank_acct() for i, (key, typ, default) in enumerate(acct_structure): if key == 'storage': t = trie.Trie(utils.get_db_path(), acct[i]) for k, v in self.caches[key].get(address, {}).iteritems(): enckey = utils.zpad(utils.coerce_to_bytes(k), 32) val = rlp.encode(utils.int_to_big_endian(v)) if v: t.update(enckey, val) else: t.delete(enckey) acct[i] = t.root_hash else: if address in self.caches[key]: v = self.caches[key].get(address, default) acct[i] = utils.encoders[acct_structure[i][1]](v) self.state.update(address.decode('hex'), rlp.encode(acct)) self.reset_cache()
def account_to_dict(self, address, with_storage_root=False): if with_storage_root: assert len(self.journal) == 0 med_dict = {} for i, val in enumerate(self.get_acct(address)): name, typ, default = acct_structure[i] key = acct_structure[i][0] if name == "storage": strie = trie.Trie(utils.get_db_path(), val) if with_storage_root: med_dict["storage_root"] = strie.get_root_hash().encode("hex") else: med_dict[key] = self.caches[key].get(address, utils.printers[typ](val)) med_dict["storage"] = {} for k, v in strie.to_dict().iteritems(): subcache = self.caches.get("storage:" + address, {}) v2 = subcache.get(utils.big_endian_to_int(k), None) hexkey = "0x" + k.encode("hex") if v2 is not None: med_dict["storage"][hexkey] = "0x" + utils.int_to_big_endian(v2).encode("hex") else: med_dict["storage"][hexkey] = "0x" + v.encode("hex") return med_dict
def to_dict(self): return dict(address=self.address, topics=[utils.zpad(utils.int_to_big_endian(x), 32).encode('hex') for x in self.topics], data='0x' + self.data.encode('hex'))
def b64(int_bloom): "returns b64" return utils.zpad(utils.int_to_big_endian(int_bloom), 64)
def length_prefix(length, offset): if length < 56: return chr(offset + length) else: length_string = utils.int_to_big_endian(length) return chr(offset + 56 - 1 + len(length_string)) + length_string
def apply_op(block, tx, msg, code, compustate): op, in_args, out_args = get_op_data(code, compustate.pc) # empty stack error if in_args > len(compustate.stack): return [] # out of gas error fee = calcfee(block, tx, msg, compustate, op) if fee > compustate.gas: if debug: print("Out of gas", compustate.gas, "need", fee) print(op, list(reversed(compustate.stack))) return OUT_OF_GAS stackargs = [] for i in range(in_args): stackargs.append(compustate.stack.pop()) if debug: import serpent if op[:4] == 'PUSH': start, n = compustate.pc + 1, int(op[4:]) print(op, utils.big_endian_to_int(code[start:start + n])) else: print(op, ' '.join(map(str, stackargs)), serpent.decode_datalist(compustate.memory)) # Apply operation oldgas = compustate.gas oldpc = compustate.pc compustate.gas -= fee compustate.pc += 1 stk = compustate.stack mem = compustate.memory if op == 'STOP': return [] elif op == 'ADD': stk.append((stackargs[0] + stackargs[1]) % 2 ** 256) elif op == 'SUB': stk.append((stackargs[0] - stackargs[1]) % 2 ** 256) elif op == 'MUL': stk.append((stackargs[0] * stackargs[1]) % 2 ** 256) elif op == 'DIV': if stackargs[1] == 0: return [] stk.append(stackargs[0] / stackargs[1]) elif op == 'MOD': if stackargs[1] == 0: return [] stk.append(stackargs[0] % stackargs[1]) elif op == 'SDIV': if stackargs[1] == 0: return [] if stackargs[0] >= 2 ** 255: stackargs[0] -= 2 ** 256 if stackargs[1] >= 2 ** 255: stackargs[1] -= 2 ** 256 stk.append((stackargs[0] / stackargs[1]) % 2 ** 256) elif op == 'SMOD': if stackargs[1] == 0: return [] if stackargs[0] >= 2 ** 255: stackargs[0] -= 2 ** 256 if stackargs[1] >= 2 ** 255: stackargs[1] -= 2 ** 256 stk.append((stackargs[0] % stackargs[1]) % 2 ** 256) elif op == 'EXP': stk.append(pow(stackargs[0], stackargs[1], 2 ** 256)) elif op == 'NEG': stk.append(2 ** 256 - stackargs[0]) elif op == 'LT': stk.append(1 if stackargs[0] < stackargs[1] else 0) elif op == 'GT': stk.append(1 if stackargs[0] > stackargs[1] else 0) elif op == 'SLT': if stackargs[0] >= 2 ** 255: stackargs[0] -= 2 ** 256 if stackargs[1] >= 2 ** 255: stackargs[1] -= 2 ** 256 stk.append(1 if stackargs[0] < stackargs[1] else 0) elif op == 'SGT': if stackargs[0] >= 2 ** 255: stackargs[0] -= 2 ** 256 if stackargs[1] >= 2 ** 255: stackargs[1] -= 2 ** 256 stk.append(1 if stackargs[0] > stackargs[1] else 0) elif op == 'EQ': stk.append(1 if stackargs[0] == stackargs[1] else 0) elif op == 'NOT': stk.append(0 if stackargs[0] else 1) elif op == 'AND': stk.append(stackargs[0] & stackargs[1]) elif op == 'OR': stk.append(stackargs[0] | stackargs[1]) elif op == 'XOR': stk.append(stackargs[0] ^ stackargs[1]) elif op == 'BYTE': if stackargs[0] >= 32: stk.append(0) else: stk.append((stackargs[1] / 256 ** stackargs[0]) % 256) elif op == 'SHA3': if len(mem) < ceil32(stackargs[0] + stackargs[1]): mem.extend([0] * (ceil32(stackargs[0] + stackargs[1]) - len(mem))) data = ''.join(map(chr, mem[stackargs[0]:stackargs[0] + stackargs[1]])) print 'data time!' print data print data.encode('hex') stk.append(int(utils.sha3(data).encode('hex'), 16)) elif op == 'ECVERIFY': # parameters: msg_hash (32), v (32), r (32), s (32), pubX (32), pubY (32) # stack should have all args msg_hash, v, r, s, pubX, pubY = stackargs pubX = utils.int_to_big_endian(pubX).encode('hex') pubY = utils.int_to_big_endian(pubY).encode('hex') msg_hash = utils.int_to_big_endian(msg_hash) pub = ('04' + pubX + pubY).decode('hex') verified = ecdsa_raw_verify(msg_hash, (v, r, s), pub) print 'verified: ', verified stk.append(verified) elif op == 'ECRECOVER': # parameters: msg_hash (32), v (32), r (32), s (32), p (64 - empty array to hold pubkey) # stack should have all args msg_hash, v, r, s = stackargs msg_hash = utils.int_to_big_endian(msg_hash) pubX, pubY = ecdsa_raw_recover(msg_hash, (v, r, s)) stk.append(pubX) stk.append(pubY) elif op == 'PUB2ADDR': pubX, pubY = stackargs pubX = utils.int_to_big_endian(pubX).encode('hex') pubY = utils.int_to_big_endian(pubY).encode('hex') pub = pubX + pubY pub = pub.decode('hex') addr = utils.sha3(pub)[12:] stk.append(addr) elif op == 'ADDRESS': stk.append(msg.to) elif op == 'BALANCE': stk.append(block.get_balance(msg.to)) elif op == 'ORIGIN': stk.append(tx.sender) elif op == 'CALLER': stk.append(utils.coerce_to_int(msg.sender)) elif op == 'CALLVALUE': stk.append(msg.value) elif op == 'CALLDATALOAD': if stackargs[0] >= len(msg.data): stk.append(0) else: dat = msg.data[stackargs[0]:stackargs[0] + 32] stk.append(utils.big_endian_to_int(dat + '\x00' * (32 - len(dat)))) elif op == 'CALLDATASIZE': stk.append(len(msg.data)) elif op == 'CALLDATACOPY': if len(mem) < ceil32(stackargs[1] + stackargs[2]): mem.extend([0] * (ceil32(stackargs[1] + stackargs[2]) - len(mem))) for i in range(stackargs[2]): if stackargs[0] + i < len(msg.data): mem[stackargs[1] + i] = ord(msg.data[stackargs[0] + i]) else: mem[stackargs[1] + i] = 0 elif op == 'GASPRICE': stk.append(tx.gasprice) elif op == 'CODECOPY': if len(mem) < ceil32(stackargs[1] + stackargs[2]): mem.extend([0] * (ceil32(stackargs[1] + stackargs[2]) - len(mem))) for i in range(stackargs[2]): if stackargs[0] + i < len(code): mem[stackargs[1] + i] = ord(code[stackargs[0] + i]) else: mem[stackargs[1] + i] = 0 elif op == 'PREVHASH': stk.append(utils.big_endian_to_int(block.prevhash)) elif op == 'COINBASE': stk.append(utils.big_endian_to_int(block.coinbase.decode('hex'))) elif op == 'TIMESTAMP': stk.append(block.timestamp) elif op == 'NUMBER': stk.append(block.number) elif op == 'DIFFICULTY': stk.append(block.difficulty) elif op == 'GASLIMIT': stk.append(block.gaslimit) elif op == 'POP': pass elif op == 'DUP': stk.append(stackargs[0]) stk.append(stackargs[0]) elif op == 'SWAP': stk.append(stackargs[0]) stk.append(stackargs[1]) elif op == 'MLOAD': if len(mem) < ceil32(stackargs[0] + 32): mem.extend([0] * (ceil32(stackargs[0] + 32) - len(mem))) data = ''.join(map(chr, mem[stackargs[0]:stackargs[0] + 32])) stk.append(utils.big_endian_to_int(data)) elif op == 'MSTORE': if len(mem) < ceil32(stackargs[0] + 32): mem.extend([0] * (ceil32(stackargs[0] + 32) - len(mem))) v = stackargs[1] #if isinstance(v, str): # v = int(v.encode('hex'), 16) for i in range(31, -1, -1): mem[stackargs[0] + i] = v % 256 v /= 256 elif op == 'MSTORE8': if len(mem) < ceil32(stackargs[0] + 1): mem.extend([0] * (ceil32(stackargs[0] + 1) - len(mem))) mem[stackargs[0]] = stackargs[1] % 256 elif op == 'SLOAD': stk.append(block.get_storage_data(msg.to, stackargs[0])) elif op == 'SSTORE': block.set_storage_data(msg.to, stackargs[0], stackargs[1]) elif op == 'JUMP': compustate.pc = stackargs[0] elif op == 'JUMPI': if stackargs[1]: compustate.pc = stackargs[0] elif op == 'PC': stk.append(compustate.pc) elif op == 'MSIZE': stk.append(len(mem)) elif op == 'GAS': stk.append(oldgas) elif op[:4] == 'PUSH': pushnum = int(op[4:]) compustate.pc = oldpc + 1 + pushnum dat = code[oldpc + 1: oldpc + 1 + pushnum] stk.append(utils.big_endian_to_int(dat)) elif op == 'CREATE': if len(mem) < ceil32(stackargs[2] + stackargs[3]): mem.extend([0] * (ceil32(stackargs[2] + stackargs[3]) - len(mem))) gas = stackargs[0] value = stackargs[1] data = ''.join(map(chr, mem[stackargs[2]:stackargs[2] + stackargs[3]])) if debug: print("Sub-contract:", msg.to, value, gas, data) addr, gas, code = create_contract( block, tx, Message(msg.to, '', value, gas, data)) if debug: print("Output of contract creation:", addr, code) if addr: stk.append(utils.coerce_to_int(addr)) else: stk.append(0) elif op == 'CALL': if len(mem) < ceil32(stackargs[3] + stackargs[4]): mem.extend([0] * (ceil32(stackargs[3] + stackargs[4]) - len(mem))) if len(mem) < ceil32(stackargs[5] + stackargs[6]): mem.extend([0] * (ceil32(stackargs[5] + stackargs[6]) - len(mem))) gas = stackargs[0] to = utils.encode_int(stackargs[1]) to = (('\x00' * (32 - len(to))) + to)[12:] value = stackargs[2] data = ''.join(map(chr, mem[stackargs[3]:stackargs[3] + stackargs[4]])) if debug: print("Sub-call:", utils.coerce_addr_to_hex(msg.to), utils.coerce_addr_to_hex(to), value, gas, data) result, gas, data = apply_msg( block, tx, Message(msg.to, to, value, gas, data)) if debug: print("Output of sub-call:", result, data, "length", len(data), "expected", stackargs[6]) for i in range(stackargs[6]): mem[stackargs[5] + i] = 0 if result == 0: stk.append(0) else: stk.append(1) compustate.gas += gas for i in range(len(data)): mem[stackargs[5] + i] = data[i] elif op == 'RETURN': if len(mem) < ceil32(stackargs[0] + stackargs[1]): mem.extend([0] * (ceil32(stackargs[0] + stackargs[1]) - len(mem))) return mem[stackargs[0]:stackargs[0] + stackargs[1]] elif op == 'SUICIDE': to = utils.encode_int(stackargs[0]) to = (('\x00' * (32 - len(to))) + to)[12:] block.delta_balance(to, block.get_balance(msg.to)) block.state.update(msg.to, '') return []
def serialize(cls, i): return int_to_big_endian(i)
def _parse_payload(self): return ''.join(int_to_big_endian(i) for i in self._payload)
def __str__(self): body = '{0}{1}'.format(self._encoded_id(), self.string) strlen = int_to_big_endian(len(body)) msg = '{0}{1}'.format(strlen, body) print 'This {0} is {1} characters long.'.format(type(self), len(msg)) return msg