def event_abi_to_log_topic(event_abi: Dict[str, Any], vmtype=None) -> bytes: if vmtype: event_signature = event_abi['name'] temp = stringtohex(bytes(event_signature, 'utf-8')) if len(temp) < 32: data1 = tostring_hex(temp) data1 = data1.rjust(64, '0') data = HexBytes('0x' + data1) elif len(temp) > 32: data1 = [] for i in range(len(temp)): data1.append(int(event_signature[i], 16)) data = keccak_256(bytes(data1)) else: data = tostring_hex(temp) data = HexBytes('0x' + data) return data # event_signature = rlp_encode(temp) # event_signature1 = [] # for i in range(len(event_signature)): # event_signature1.append(int(event_signature[i], 16)) # keccak_256(bytes(event_signature1)) # return keccak_256(bytes(event_signature1)) else: event_signature = _abi_to_signature(event_abi) return event_signature_to_log_topic(event_signature)
def get_bloom_bits(value): #value is in hex transactionHash = keccak_256(bytearray.fromhex(value)) mask1 = 0b11111111 mask2 = 0b111 res = [] for i in range(3): res.append(((mask2 & transactionHash[i]) << 8) + (mask1 & transactionHash[i + 1])) return res
def keccak( primitive: Union[bytes, int, bool] = None, hexstr: str = None, text: str = None ) -> bytes: global CRYPTO_TYPE global CRYPTO_TYPE_GM # print("hashtype",CRYPTO_TYPE) if CRYPTO_TYPE == CRYPTO_TYPE_GM: return gmhash(primitive, hexstr, text) return keccak_256(to_bytes(primitive, hexstr, text))
def pubkey_to_address(pubkey, prefix=None): """This implements the algorithm described here https://github.com/iotexproject/iotex-address""" if prefix is None: prefix = DEFAULT_ADDRESS_PREFIX if pubkey is None or len(pubkey) < 1: return None pubkey_hash = keccak_256(pubkey[1:]) if pubkey_hash is None or len(pubkey_hash) < 12: return None payload = pubkey_hash[12:] return bech32_encode(prefix, payload)
def verify_message(self, message, signed_message=None, address=None, use_tron: bool = True, is_message_hex=False): """ Get the address of the account that signed the message with the given hash. You must specify exactly one of: vrs or signature Args: message (str): The message in the format "hex" signed_message (AttributeDict): Signature address (str): is Address use_tron (bool): is Tron header """ if address is None: address = self.tron.default_address.base58 if not is_hex(message): raise TronError('Expected hex message input') # Determine which header to attach to the message # before encrypting or decrypting header = TRX_MESSAGE_HEADER if use_tron else ETH_MESSAGE_HEADER header += str(len(message)) if is_message_hex: from eth_hash.auto import keccak as keccak_256 message_hash = keccak_256( header.encode('utf-8') + bytes.fromhex(message)) else: message_hash = self.tron.keccak(text=header + message) recovered = Account.recover_hash(self.tron.toHex(message_hash), signed_message.signature) tron_address = '41' + recovered[2:] base58address = self.tron.address.from_hex(tron_address).decode() if base58address == address: return True raise ValueError('Signature does not match')
def keccak(primitive: Union[bytes, int, bool] = None, hexstr: str = None, text: str = None) -> bytes: return keccak_256(to_bytes(primitive, hexstr, text))
def get_bloom_bits(value): value_hash = keccak_256(value) for chunk in get_chunks_for_bloom(value_hash): bloom_bits = chunk_to_bloom_bits(chunk) yield bloom_bits
def get_bloom_bits(value: bytes) -> Iterable[int]: value_hash = keccak_256(value) for chunk in get_chunks_for_bloom(value_hash): bloom_bits = chunk_to_bloom_bits(chunk) yield bloom_bits
def keccak(primitive=None, hexstr=None, text=None): return keccak_256(to_bytes(primitive, hexstr, text))
def verifying_key_to_addr(key): pub_key = key.to_string() primitive_addr = b'\x41' + keccak_256(pub_key)[-20:] addr = base58.b58encode_check(primitive_addr) return addr
def sign(self, transaction: Any, private_key=None, use_tron: bool = True, multisig: bool = False, is_message_hex=False): """Safe method for signing your transaction Warnings: method: online_sign() - Use only in extreme cases. Args: transaction (Any): transaction details use_tron (bool): is Tron header multisig (bool): multi sign """ if is_string(transaction): if not is_hex(transaction): raise TronError('Expected hex message input') # Determine which header to attach to the message # before encrypting or decrypting header = TRX_MESSAGE_HEADER if use_tron else ETH_MESSAGE_HEADER header += str(len(transaction)) if is_message_hex: from eth_hash.auto import keccak as keccak_256 message_hash = keccak_256( header.encode('utf-8') + bytes.fromhex(transaction)) else: message_hash = self.tron.keccak(text=header + transaction) signed_message = Account.sign_hash( self.tron.toHex(message_hash), private_key or self.tron.private_key) return signed_message if not multisig and 'signature' in transaction: raise TronError('Transaction is already signed') try: if not multisig: address = self.tron.address.from_private_key( private_key or self.tron.private_key).hex.lower() owner_address = transaction['raw_data']['contract'][0][ 'parameter']['value']['owner_address'] if address != owner_address: raise ValueError( 'Private key does not match address in transaction') # This option deals with signing of transactions, and writing to the array signed_tx = Account.sign_hash(transaction['txID'], private_key or self.tron.private_key) signature = signed_tx['signature'].hex()[2:] # support multi sign if 'signature' in transaction and is_list( transaction['signature']): if not transaction['signature'].index(signature): transaction['signature'].append(signature) else: transaction['signature'] = [signature] return transaction except ValueError as err: raise InvalidTronError(err)
from eth_hash.auto import keccak as keccak_256 # secp256k1 # 32bytes, 256bits # key = ecdsa.SigningKey.from_string(bytes.fromhex('1' * 64), curve=ecdsa.SECP256k1) # x = key.privkey.public_key.point.x() # y = key.privkey.public_key.point.y() # '%064s' % hex(x)[2:] + '%064s' % hex(y)[2:] # generate address priv_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1) pub_key = priv_key.get_verifying_key().to_string() primitive_addr = b'\x41' + keccak_256(pub_key)[-20:] addr = base58.b58encode_check(primitive_addr) def verifying_key_to_addr(key): pub_key = key.to_string() primitive_addr = b'\x41' + keccak_256(pub_key)[-20:] addr = base58.b58encode_check(primitive_addr) return addr #def ecdsa_pub_key_to_addr(pub_key): # # pub_key = priv_key.get_verifying_key().to_string() # primitive_addr = b'\x41' + keccak_256(pub_key)[-20:] print(addr)
raise SystemExit print("-" * 80) raw_data = bytes.fromhex( '0a1541b5f8a2ab78bfb1afea17558f8a32d1c988283019121541e42d76d15b7ecd27a92cc9551738c2635c63b71c1880ab8f122244a3082be900000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000001' ) trigger = contract_pb.TriggerSmartContract.FromString(raw_data) print(trigger) print(trigger.data[:4]) print(trigger.data[:4].hex()) from eth_hash.auto import keccak as keccak_256 print(keccak_256(b'GoodLuck(uint256,uint256)')[:4]) raw_data = bytes.fromhex( '''0a154146a23e25df9a0f6c18729dda9ad1af3b6a1311601080dac40922c2070a20720476792dd2f01b5ff441cb38d4b29d10b52c1c8e6dfeea13f89d547e3c14d1122004a631b9ac0e0da0891f459f6a881164a4fd76ad48e5 a77268de8fd104975a5f1a20c54db69e4f1de8c66237cc0f1074c6b4096ef7323a65633af221948eea1c095822c404f1522886257a4a35e386ebf608f15470188e9bf5c956ec5c5a708a3b030fb05469dd68244c3c3f56b452d75bed7374c111a275b7 de7fa6a6ce424fcec87357f2a2eb97ac3dd1e90b184b35b4aee25507d306b6fe438e8c5128579d15f30301dde60e8506d36dc7788f01e7d5f94cc96be2efd1e70c1c25baccaf62f8d90610c1eb921f5058a1daa275c446e7bc3f1e2cf499c463abb21b 062452d3273dc90a00b690604e4eef6e665fb63ab4294d0404cca203dc6105e840b034684790dd71de8a99116ce576ebe1e9a39cc7076eb05384275f43c19b04928897f4ef7082302e4ec7879e46fa788c9aade675ded4b4c1acc756eb7b20418f5c0c ac1f32f7021baee5e6961c02236afffa880bb24a33f575983389b5ea86dd25497f1b8427abc548a0ce7d499d544ddf69f181a6474e3dc2d1e24a5291c287864c13fd3be17b455f35fd510422e853bd19f068c3cfab69a06d4d5260406bac13ab950cf7 e6ed211521664b7acdd10288c785962690663b8fa194b9d0e86fd10643c09cb2c2ef11e9e66c612f2cca89c67dc2f16781c13a2f08bcf6e49fd80e0a852b1c38ebae2677825ba18e5a4b70050ad333fd182260d0d40ca314ccbc1981569c6e9642fee5 b507c9933969dd704a741a3c2ce225b3afa06ee4bea0e333193a3a06df1cb8eda396bf7d950b70a7f1fb1d47998508f628e658af3bdbbb5cdb97251a1264be0d8e0dd43711f3cefa4ea5f45f609e7d7403a0ffcad717cd1453d25120a0ae8c0adfe893 5371608046d5d3579b6ef719a5fc5ab95ccdb6adc23b3ebeeab8a6905a140377e92a5062d197aa06f0d9bca9885256ddd0e100b2b6f7fd260e062e04bc40371d193d967dec04df56bbcb8af9d2fd95c742619f13fdafeb08629d18e219261e67b9dd32 ef4c5906acc8cc2e78cb399584ec8f6132c00198b11ac7cc6e38ff358863e5d68f50178f023b7e12c241977e4d24e934db8d68ef40df5adb7bdaa260372364c380644f948c086f54c4e86f5b70f74c9662b5441bfe53375bfc29c9e7fae2d7e1bde0ca d75d6043f34454bb198152ab40632d781961985e799713bb6585f256ed8b324d7f63a0f513052058bea3d71c074e13d0f14343d8072d054f47ba913e02229c6493b00b98c82cb9d2a98d4c479ffb965a853e6a654af659ddefe424ea774eb8267bf6fb 0a925a77febfd8dd8fc1be392d2a40f2d69df9ce92abd5a0c424a03842a0997fb56b8159b81f85684fe9d001aa9e48f6e7d3c9488e13a187e248deeb7dac76adf63f2ee82f271a6035b13e59c52306''' )