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'''
)
