def test_get_x_coordinate(message, domain):
x_coordinate = _get_x_coordinate(message, domain)
domain_in_bytes = domain.to_bytes(8, 'big')
assert x_coordinate == FQ2(
[
big_endian_to_int(hash_eth2(message + domain_in_bytes + b'\x01')),
big_endian_to_int(hash_eth2(message + domain_in_bytes + b'\x02')),
]
)
def _get_x_coordinate(message_hash: Hash32, domain: int) -> FQ2:
domain_in_bytes = domain.to_bytes(8, 'big')
# Initial candidate x coordinate
x_re = big_endian_to_int(hash_eth2(message_hash + domain_in_bytes + b'\x01'))
x_im = big_endian_to_int(hash_eth2(message_hash + domain_in_bytes + b'\x02'))
x_coordinate = FQ2([x_re, x_im]) # x_re + x_im * i
return x_coordinate
def compress_public_key_bytes(
self, uncompressed_public_key_bytes: bytes) -> bytes:
validate_uncompressed_public_key_bytes(uncompressed_public_key_bytes)
point = (
big_endian_to_int(uncompressed_public_key_bytes[:32]),
big_endian_to_int(uncompressed_public_key_bytes[32:]),
)
public_key = self.keys.PublicKey.from_point(*point)
return public_key.format(compressed=True)
def ecsign(rawhash, key):
if coincurve and hasattr(coincurve, 'PrivateKey'):
pk = coincurve.PrivateKey(key)
signature = pk.sign_recoverable(rawhash, hasher=None)
v = safe_ord(signature[64]) + 27
r = big_endian_to_int(signature[0:32])
s = big_endian_to_int(signature[32:64])
else:
v, r, s = ecdsa_raw_sign(rawhash, key)
return v, r, s
def pubkey_to_g2(pub: Pubkey) -> G2Point:
g2 = (
FQ2([big_endian_to_int(pub[:32]),
big_endian_to_int(pub[32:64])]),
FQ2([big_endian_to_int(pub[64:96]),
big_endian_to_int(pub[96:])]),
FQ2.one(),
)
assert is_valid_g2_point(g2)
return g2
def get_publickey_from_address(web3, address):
_hash = Web3.sha3(text='verify signature.')
signature = split_signature(web3, web3.eth.sign(address, _hash))
signature_vrs = Signature(signature.v % 27, big_endian_to_int(signature.r),
big_endian_to_int(signature.s))
prefixed_hash = prepare_prefixed_hash(_hash)
pub_key = KeyAPI.PublicKey.recover_from_msg_hash(
prefixed_hash, KeyAPI.Signature(vrs=signature_vrs))
assert pub_key.to_checksum_address(
) == address, 'recovered address does not match signing address.'
return pub_key
def parse_collation_added_log(log):
# `shard_id` is the first indexed entry,hence the second entry in topics
shard_id_bytes32 = log['topics'][1]
data_bytes = decode_hex(log['data'])
header_bytes = shard_id_bytes32 + data_bytes[:-64]
is_new_head = bool(big_endian_to_int(data_bytes[-64:-32]))
score = big_endian_to_int(data_bytes[-32:])
collation_header = CollationHeader.from_bytes(header_bytes)
yield 'header', collation_header
yield 'is_new_head', is_new_head
yield 'score', score
def test_delete_ranges(blank_state, mock_accts):
state = make_simple_state(blank_state, mock_accts)
assert [0, 0] == [
big_endian_to_int(r[8:40]) for r in state.get_ranges(0, 0, 9)
]
ranges_to_delete = state.get_ranges(0, 10, 29)
assert [10, 10, 20,
20] == [big_endian_to_int(r[8:40]) for r in ranges_to_delete]
state.delete_ranges(ranges_to_delete)
new_ranges = state.get_ranges(0, 10, 29)
assert [0, 0] == [big_endian_to_int(r[8:40]) for r in new_ranges]
def ecdsa_raw_sign(msg_hash, private_key_bytes):
z = big_endian_to_int(msg_hash)
k = deterministic_generate_k(msg_hash, private_key_bytes)
r, y = fast_multiply(G, k)
s_raw = inv(k, N) * (z + r * big_endian_to_int(private_key_bytes)) % N
v = 27 + ((y % 2) ^ (0 if s_raw * 2 < N else 1))
s = s_raw if s_raw * 2 < N else N - s_raw
return v - 27, r, s
def get_trx_receipts(self, unsigned_msg, signature):
trx = rlp.decode(unsigned_msg, EthTrx)
v = int(signature[64]) + 35 + 2 * trx[6]
r = big_endian_to_int(signature[0:32])
s = big_endian_to_int(signature[32:64])
trx_raw = rlp.encode(EthTrx(trx[0], trx[1], trx[2], trx[3], trx[4], trx[5], v, r, s), EthTrx)
eth_signature = '0x' + sha3(trx_raw).hex()
from_address = w3.eth.account.recover_transaction(trx_raw).lower()
return (trx_raw.hex(), eth_signature, from_address)
def mk_transaction():
return BaseTransactionFields(
nonce=0,
gas=21000,
gas_price=1,
to=os.urandom(20),
value=random.randint(0, 100),
data=b'',
v=27,
r=big_endian_to_int(os.urandom(32)),
s=big_endian_to_int(os.urandom(32)),
)
def _compute_adjusted_exponent_length(exponent_length: int,
first_32_exponent_bytes: bytes) -> int:
exponent = big_endian_to_int(first_32_exponent_bytes)
if exponent_length <= 32 and exponent == 0:
return 0
elif exponent_length <= 32:
return get_highest_bit_index(exponent)
else:
first_32_bytes_as_int = big_endian_to_int(first_32_exponent_bytes)
return (8 * (exponent_length - 32) +
get_highest_bit_index(first_32_bytes_as_int))
def _extract_lengths(data: bytes) -> Tuple[int, int, int]:
# extract argument lengths
base_length_bytes = pad32r(data[:32])
base_length = big_endian_to_int(base_length_bytes)
exponent_length_bytes = pad32r(data[32:64])
exponent_length = big_endian_to_int(exponent_length_bytes)
modulus_length_bytes = pad32r(data[64:96])
modulus_length = big_endian_to_int(modulus_length_bytes)
return base_length, exponent_length, modulus_length
def decode_receipt_event(data):
data = to_bytes(data)
# Fixed position parameters
success = big_endian_to_int(data[:32]) != 0
result_start = big_endian_to_int(data[32:64])
result_size = big_endian_to_int(data[result_start:result_start + 32])
# Dynamic position parameters
result = from_bytes(data[result_start + 32:result_start + 32 +
result_size])
return {"success": success, "result": result}
def _ecmull(data: bytes) -> Tuple[bn128.FQ, bn128.FQ]:
x_bytes = pad32r(data[:32])
y_bytes = pad32r(data[32:64])
m_bytes = pad32r(data[64:96])
x = big_endian_to_int(x_bytes)
y = big_endian_to_int(y_bytes)
m = big_endian_to_int(m_bytes)
p = validate_point(x, y)
result = bn128.normalize(bn128.multiply(p, m))
return result
def sign(self, message):
msg_hash = bytes(bytearray.fromhex(remove_0x_prefix(message)))
signature_bytes = self.private_key.sign_recoverable(msg_hash,
hasher=None)
assert len(signature_bytes) == 65
r = "0x" + format(big_endian_to_int(signature_bytes[0:32]), "x")
s = "0x" + format(big_endian_to_int(signature_bytes[32:64]), "x")
v = hex(ord(signature_bytes[64:65]) + 27)
return {"r": r, "s": s, "v": v}
def check_pow(block_number: int, mining_hash: Hash32, mix_hash: Hash32,
nonce: bytes, difficulty: int) -> None:
validate_length(mix_hash, 32, title="Mix Hash")
validate_length(mining_hash, 32, title="Mining Hash")
validate_length(nonce, 8, title="POW Nonce")
cache = get_cache(block_number)
mining_output = hashimoto_light(block_number, cache, mining_hash,
big_endian_to_int(nonce))
if mining_output[b'mix digest'] != mix_hash:
raise ValidationError("mix hash mismatch; {0} != {1}".format(
encode_hex(mining_output[b'mix digest']), encode_hex(mix_hash)))
result = big_endian_to_int(mining_output[b'result'])
validate_lte(result, 2**256 // difficulty, title="POW Difficulty")
def mk_transaction():
return LegacyTransactionFactory(
nonce=0,
gas=21000,
gas_price=1,
to=os.urandom(20),
value=random.randint(0, 100),
data=b'',
vrs=(
27,
big_endian_to_int(os.urandom(32)),
big_endian_to_int(os.urandom(32)),
),
)
def _parse_perpetual_update_position_event_logs(self, block_number):
event_filter_params = {
'topics': [self._perpetual_position_topic],
'address': [self._perpetual_address],
'fromBlock': block_number,
'toBlock': block_number,
}
event_data = []
logs = self._perpetual.web3.eth.getLogs(event_filter_params)
for log in logs:
parsed = {}
parsed['blockNumber'] = log['blockNumber']
parsed['blockHash'] = log['blockHash']
parsed['transactionIndex'] = log['transactionIndex']
parsed['logIndex'] = log['logIndex']
parsed['transactionHash'] = log['transactionHash'].hex()
parsed['trader'] = '0x' + log['topics'][1].hex()[26:].lower()
data = HexBytes(log['data'])
if len(data) != 32 * 8:
raise Exception(f'malformed event: {parsed}')
parsed['side'] = big_endian_to_int(data[32*0:32*1])
parsed['size'] = big_endian_to_int(data[32*1:32*2])
parsed['entryValue'] = big_endian_to_int(data[32*2:32*3])
parsed['entrySocialLoss'] = big_endian_to_int(data[32*3:32*4])
parsed['entryFundingLoss'] = big_endian_to_int(data[32*4:32*5])
parsed['cashBalance'] = big_endian_to_int(data[32*5:32*6])
parsed['perpetualTotalSize'] = big_endian_to_int(data[32*6:32*7])
parsed['price'] = big_endian_to_int(data[32*7:32*8])
event_data.append(parsed)
return event_data
def test_get_ranges(blank_state, mock_accts):
state = make_simple_state(blank_state, mock_accts)
assert [0, 0] == [
big_endian_to_int(r[8:40]) for r in state.get_ranges(0, 0, 9)
]
assert [10, 10, 20, 20] == [
big_endian_to_int(r[8:40]) for r in state.get_ranges(0, 10, 29)
]
assert [0, 0, 10, 10] == [
big_endian_to_int(r[8:40]) for r in state.get_ranges(0, 5, 19)
]
assert [0, 0, 10, 10, 20, 20] == [
big_endian_to_int(r[8:40]) for r in state.get_ranges(0, 5, 29)
]
def add_transfer(self, transfer, affected_ranges):
sender, recipient, token_id, start, offset = self.get_converted_parameters(
addresses=(transfer.sender, transfer.recipient),
bytes8s=(transfer.token_id, ),
bytes32s=(transfer.start, transfer.offset))
end = token_id + int_to_big_endian32(
big_endian_to_int(start) +
big_endian_to_int(offset)) + OFFSET_SUFFIX
# Shorten first range if needed
if get_start_to_offset_key(token_id, start) != affected_ranges[0]:
# TODO: Add
self.db.put(
affected_ranges[0],
int_to_big_endian32(
big_endian_to_int(start) -
big_endian_to_int(affected_ranges[0][8:40])))
print(
'setting new end offset to:',
big_endian_to_int(start) -
big_endian_to_int(affected_ranges[0][8:40]))
del affected_ranges[0:2]
# Shorten last range if needed
if len(affected_ranges) != 0 and end != affected_ranges[-1]:
self.db.put(affected_ranges[-2], start + offset)
print('setting new start to:',
big_endian_to_int(start) + big_endian_to_int(offset))
del affected_ranges[-2:]
def verify(public_key: str,
signature: str,
message: Optional[str] = None,
message_hash: Optional[str] = None) -> bool:
"""
Verify XinFin signature by public key.
:param public_key: XinFin public key.
:type public_key: str.
:param signature: Signed message data.
:type signature: str.
:param message: Message data, default to ``None``.
:type message: str.
:param message_hash: Message data hash, default to ``None``.
:type message_hash: str.
:return: bool -- Verified signature.
>>> from pyxdc.signature import verify
>>> verify(public_key="03d8799336beacc6b2e7f86f46bce4ad5cabf1ec7a0d6241416985e3b29fe1cc85", message="meherett", signature="74ad07a84b87fa3efa2f0e825506fb8bbee41021ca77a30e8ffa2bd66d47d99917d4a0587185e78a051a9cb80ebf65c7d62dbeedb7f9a029f961d70b52a10dc001")
True
>>> verify(public_key="03d8799336beacc6b2e7f86f46bce4ad5cabf1ec7a0d6241416985e3b29fe1cc85", message_hash="4bbbfd0c33fea618f4a9aa75c02fe76e50fa59798af021bc34f7856f3259c685", signature="74ad07a84b87fa3efa2f0e825506fb8bbee41021ca77a30e8ffa2bd66d47d99917d4a0587185e78a051a9cb80ebf65c7d62dbeedb7f9a029f961d70b52a10dc001")
True
"""
if message:
message_bytes = curried.to_bytes(primitive=None,
hexstr=None,
text=message)
msg_length = str(len(message_bytes)).encode('utf-8')
joined = b'\x19' + b'E' + b'thereum Signed Message:\n' + msg_length + message_bytes
keccak_256_message = keccak_256()
keccak_256_message.update(joined)
message_hash = keccak_256_message.digest()
elif message_hash:
message_hash = unhexlify(message_hash)
else:
raise ValueError("Message data or hash is required to sign.")
signature = unhexlify(signature)
validate_recoverable_signature_bytes(signature)
r = big_endian_to_int(signature[0:32])
s = big_endian_to_int(signature[32:64])
v = ord(signature[64:65])
validate_compressed_public_key_bytes(unhexlify(public_key))
uncompressed_public_key = decompress_public_key(unhexlify(public_key))
return ecdsa_raw_verify(msg_hash=message_hash,
rs=(r, s),
public_key_bytes=uncompressed_public_key)
def _parse_value(self, *, val_type: str,
val: bytes) -> Union[bool, Address, bytes, int]:
if val_type == 'bool':
return bool(big_endian_to_int(val))
elif val_type == 'address':
return to_canonical_address(val[-20:])
elif val_type == 'bytes32':
return val
elif 'int' in val_type:
return big_endian_to_int(val)
else:
raise LogParsingError(
"Error parsing the type of given value. Expect bool/address/bytes32/int*"
"but get {}.".format(val_type))
def signature_to_G2(signature: Signature) -> G2Point:
g2 = (
FQ2([
big_endian_to_int(signature[:32]),
big_endian_to_int(signature[32:64])
]),
FQ2([
big_endian_to_int(signature[64:96]),
big_endian_to_int(signature[96:])
]),
FQ2.one(),
)
assert is_g2_on_curve(g2)
return g2
def public_key_from_signature(message: str, signature: str) -> PublicKey:
if signature.startswith("0x"):
signature = signature[2:]
bytes_sig = bytes.fromhex(signature)
if not len(bytes_sig) == 65:
raise ValidationError(param='signature', type_name='65 bytes')
vrs = (
big_endian_to_int(bytes_sig[64:65]) - 27,
big_endian_to_int(bytes_sig[0:32]),
big_endian_to_int(bytes_sig[32:64]),
)
sig = eth_keys.keys.Signature(vrs=vrs)
pub_key = eth_keys.keys.ecdsa_recover(Web3.keccak(text=message), sig)
return pub_key
def ec_recover(message: str, signed_message: str) -> str:
"""
This method does not prepend the message with the prefix `\x19Ethereum Signed Message:\n32`.
The caller should add the prefix to the msg/hash before calling this if the signature was
produced for an ethereum-prefixed message.
:param message:
:param signed_message:
:return:
"""
v, r, s = split_signature(Web3.toBytes(hexstr=signed_message))
signature_object = SignatureFix(vrs=(v, big_endian_to_int(r),
big_endian_to_int(s)))
return Account.recoverHash(message,
signature=signature_object.to_hex_v_hacked())
def decode(self, rlp_sign: bytes, rlp_data: bytes) -> NeonTxInfo:
self._set_defaults()
try:
utx = EthTx.fromString(rlp_data)
uv = int(rlp_sign[64]) + 35 + 2 * utx.v
ur = big_endian_to_int(rlp_sign[0:32])
us = big_endian_to_int(rlp_sign[32:64])
tx = EthTx(utx.nonce, utx.gasPrice, utx.gasLimit, utx.toAddress, utx.value, utx.callData, uv, ur, us)
self.init_from_eth_tx(tx)
except Exception as e:
self.error = e
return self
def receipt_to_r_s_v(receipt):
assert (len(receipt) == 132)
r = '0x' + receipt[2:66]
r = decode_hex(r)
r = big_endian_to_int(r)
s = '0x' + receipt[66:130]
s = decode_hex(s)
s = big_endian_to_int(s)
v = int('0x' + receipt[130:132], 16)
if v not in [27, 28]:
v += 27
return r, s, v
def __init__(self, contractInfo):
super().__init__(contractInfo)
self.name = contractInfo["name"]
abi = contractInfo["abi"]
func_abis = [
func_abi for func_abi in abi if func_abi["type"] == "function"
]
event_abis = [
event_abi for event_abi in abi if event_abi["type"] == "event"
]
self.funcs = {}
for func_abi in func_abis:
id_bytes = eth_utils.function_abi_to_4byte_selector(func_abi)
self.funcs[id_bytes] = func_abi
for func_id, func_abi in self.funcs.items():
setattr(
ContractABI,
func_abi["name"],
generate_func(func_id, func_abi, self.address),
)
setattr(ContractABI, "_" + func_abi["name"],
generate_func2(func_id, func_abi))
self.events = {}
for event_abi in event_abis:
id_bytes = eth_utils.event_abi_to_log_topic(event_abi)
event_id = eth_utils.big_endian_to_int(id_bytes)
self.events[event_id] = event_abi
def _decode_keyfile_json_v3(keyfile_json, password):
crypto = keyfile_json['crypto']
kdf = crypto['kdf']
# Derive the encryption key from the password using the key derivation
# function.
if kdf == 'pbkdf2':
derived_key = _derive_pbkdf_key(crypto, password)
elif kdf == 'scrypt':
derived_key = _derive_scrypt_key(crypto, password)
else:
raise TypeError("Unsupported key derivation function: {0}".format(kdf))
# Validate that the derived key matchs the provided MAC
ciphertext = decode_hex(crypto['ciphertext'])
mac = keccak(derived_key[16:32] + ciphertext)
expected_mac = decode_hex(crypto['mac'])
if not hmac.compare_digest(mac, expected_mac):
raise ValueError("MAC mismatch")
# Decrypt the ciphertext using the derived encryption key to get the
# private key.
encrypt_key = derived_key[:16]
cipherparams = crypto['cipherparams']
iv = big_endian_to_int(decode_hex(cipherparams['iv']))
private_key = decrypt_aes_ctr(ciphertext, encrypt_key, iv)
return private_key
def normalize_block_header(header):
normalized_header = {
'bloom': big_endian_to_int(decode_hex(header['bloom'])),
'coinbase': to_canonical_address(header['coinbase']),
'difficulty': to_int(header['difficulty']),
'extraData': decode_hex(header['extraData']),
'gasLimit': to_int(header['gasLimit']),
'gasUsed': to_int(header['gasUsed']),
'hash': decode_hex(header['hash']),
'mixHash': decode_hex(header['mixHash']),
'nonce': decode_hex(header['nonce']),
'number': to_int(header['number']),
'parentHash': decode_hex(header['parentHash']),
'receiptTrie': decode_hex(header['receiptTrie']),
'stateRoot': decode_hex(header['stateRoot']),
'timestamp': to_int(header['timestamp']),
'transactionsTrie': decode_hex(header['transactionsTrie']),
'uncleHash': decode_hex(header['uncleHash']),
}
if 'blocknumber' in header:
normalized_header['blocknumber'] = to_int(header['blocknumber'])
if 'chainname' in header:
normalized_header['chainname'] = header['chainname']
if 'chainnetwork' in header:
normalized_header['chainnetwork'] = header['chainnetwork']
return normalized_header
def decoder_fn(self, data):
value = big_endian_to_int(data)
with decimal.localcontext(abi_decimal_context):
decimal_value = decimal.Decimal(value) / TEN ** self.frac_places
return decimal_value
def decint(n):
if isinstance(n, str):
n = to_string(n)
if is_numeric(n) and n < 2**256 and n > -2**255:
return n
elif is_numeric(n):
raise EncodingError("Number out of range: %r" % n)
elif is_string(n) and len(n) == 40:
return big_endian_to_int(decode_hex(n))
elif is_string(n) and len(n) <= 32:
return big_endian_to_int(n)
elif is_string(n) and len(n) > 32:
raise EncodingError("String too long: %r" % n)
elif n is True:
return 1
elif n is False or n is None:
return 0
else:
raise EncodingError("Cannot encode integer: %r" % n)
def decode_single(typ, data):
base, sub, _ = typ
if base == 'address':
return encode_hex(data[12:])
elif base == 'string' or base == 'bytes' or base == 'hash':
return data[:int(sub)] if len(sub) else data
elif base == 'uint':
return big_endian_to_int(data)
elif base == 'int':
o = big_endian_to_int(data)
return getSignedNumber(o, int(sub))
# return (o - 2**int(sub)) if o >= 2**(int(sub) - 1) else o
elif base == 'ureal':
high, low = [int(x) for x in sub.split('x')]
return big_endian_to_int(data) * 1.0 / 2**low
elif base == 'real':
high, low = [int(x) for x in sub.split('x')]
return (big_endian_to_int(data) * 1.0 / 2**low) % 2**high
elif base == 'bool':
return bool(int(data.encode('hex'), 16))
def decoder_fn(self, data):
value = big_endian_to_int(data)
if value >= 2 ** (self.value_bit_size - 1):
signed_value = value - 2 ** self.value_bit_size
else:
signed_value = value
with decimal.localcontext(abi_decimal_context):
decimal_value = decimal.Decimal(signed_value) / TEN ** self.frac_places
return decimal_value
def normalize_account_state(account_state):
return {
to_canonical_address(address): {
'balance': to_int(state['balance']),
'code': decode_hex(state['code']),
'nonce': to_int(state['nonce']),
'storage': {
to_int(slot): big_endian_to_int(decode_hex(value))
for slot, value in state['storage'].items()
},
} for address, state in account_state.items()
}
def dec(typ, arg):
base, sub, arrlist = typ
sz = get_size(typ)
# Dynamic-sized strings are encoded as <len(str)> + <str>
if base in ('string', 'bytes') and not sub:
L = big_endian_to_int(arg[:32])
assert len(arg[32:]) == ceil32(L), "Wrong data size for string/bytes object"
return arg[32:][:L]
# Dynamic-sized arrays
elif sz is None:
L = big_endian_to_int(arg[:32])
subtyp = base, sub, arrlist[:-1]
subsize = get_size(subtyp)
# If children are dynamic, use the head/tail mechanism. Fortunately,
# here the code is simpler since we do not have to worry about
# mixed dynamic and static children, as we do in the top-level multi-arg
# case
if subsize is None:
assert len(arg) >= 32 + 32 * L, "Not enough data for head"
start_positions = [big_endian_to_int(arg[32 + 32 * i: 64 + 32 * i])
for i in range(L)] + [len(arg)]
outs = [arg[start_positions[i]: start_positions[i + 1]]
for i in range(L)]
return [dec(subtyp, out) for out in outs]
# If children are static, then grab the data slice for each one and
# sequentially decode them manually
else:
return [dec(subtyp, arg[32 + subsize * i: 32 + subsize * (i + 1)])
for i in range(L)]
# Static-sized arrays: decode piece-by-piece
elif len(arrlist):
L = arrlist[-1][0]
subtyp = base, sub, arrlist[:-1]
subsize = get_size(subtyp)
return [dec(subtyp, arg[subsize * i:subsize * (i + 1)])
for i in range(L)]
else:
return decode_single(typ, arg)
def test_decode_signed_int(integer_bit_size, stream_bytes, data_byte_size):
if integer_bit_size % 8 != 0:
with pytest.raises(ValueError):
SignedIntegerDecoder(
value_bit_size=integer_bit_size,
data_byte_size=data_byte_size,
)
return
elif integer_bit_size > data_byte_size * 8:
with pytest.raises(ValueError):
SignedIntegerDecoder(
value_bit_size=integer_bit_size,
data_byte_size=data_byte_size,
)
return
else:
decoder = SignedIntegerDecoder(
value_bit_size=integer_bit_size,
data_byte_size=data_byte_size,
)
stream = ContextFramesBytesIO(stream_bytes)
padding_bytes = data_byte_size - integer_bit_size // 8
raw_value = big_endian_to_int(stream_bytes[padding_bytes:data_byte_size])
if raw_value >= 2 ** (integer_bit_size - 1):
actual_value = raw_value - 2 ** integer_bit_size
else:
actual_value = raw_value
if len(stream_bytes) < data_byte_size:
with pytest.raises(InsufficientDataBytes):
decoder(stream)
return
elif (
(actual_value >= 0 and not all_bytes_equal(stream_bytes[:padding_bytes], 0)) or
(actual_value < 0 and not all_bytes_equal(stream_bytes[:padding_bytes], 255))
):
with pytest.raises(NonEmptyPaddingBytes):
decoder(stream)
return
else:
decoded_value = decoder(stream)
assert decoded_value == actual_value
def decode_abi(types, data):
# Process types
proctypes = [process_type(typ) for typ in types]
# Get sizes of everything
sizes = [get_size(typ) for typ in proctypes]
# Initialize array of outputs
outs = [None] * len(types)
# Initialize array of start positions
start_positions = [None] * len(types) + [len(data)]
# If a type is static, grab the data directly, otherwise record
# its start position
pos = 0
for i, typ in enumerate(types):
if sizes[i] is None:
start_positions[i] = big_endian_to_int(data[pos:pos + 32])
j = i - 1
while j >= 0 and start_positions[j] is None:
start_positions[j] = start_positions[i]
j -= 1
pos += 32
else:
outs[i] = data[pos:pos + sizes[i]]
pos += sizes[i]
# We add a start position equal to the length of the entire data
# for convenience.
j = len(types) - 1
while j >= 0 and start_positions[j] is None:
start_positions[j] = start_positions[len(types)]
j -= 1
assert pos <= len(data), "Not enough data for head"
# Grab the data for tail arguments using the start positions
# calculated above
for i, typ in enumerate(types):
if sizes[i] is None:
offset = start_positions[i]
next_offset = start_positions[i + 1]
outs[i] = data[offset:next_offset]
# Recursively decode them all
return [dec(proctypes[i], outs[i]) for i in range(len(outs))]
def test_decode_unsigned_int(integer_bit_size, stream_bytes, data_byte_size):
if integer_bit_size % 8 != 0:
with pytest.raises(ValueError):
UnsignedIntegerDecoder(
value_bit_size=integer_bit_size,
data_byte_size=data_byte_size,
)
return
elif integer_bit_size > data_byte_size * 8:
with pytest.raises(ValueError):
UnsignedIntegerDecoder(
value_bit_size=integer_bit_size,
data_byte_size=data_byte_size,
)
return
else:
decoder = UnsignedIntegerDecoder(
value_bit_size=integer_bit_size,
data_byte_size=data_byte_size,
)
stream = ContextFramesBytesIO(stream_bytes)
actual_value = big_endian_to_int(stream_bytes[:data_byte_size])
if len(stream_bytes) < data_byte_size:
with pytest.raises(InsufficientDataBytes):
decoder(stream)
return
elif actual_value > 2 ** integer_bit_size - 1:
with pytest.raises(NonEmptyPaddingBytes):
decoder(stream)
return
else:
decoded_value = decoder(stream)
assert decoded_value == actual_value
def to_int(value=None, hexstr=None, text=None):
"""
Converts value to it's integer representation.
Values are converted this way:
* value:
* bytes: big-endian integer
* bool: True => 1, False => 0
* hexstr: interpret hex as integer
* text: interpret as string of digits, like '12' => 12
"""
assert_one_val(value, hexstr=hexstr, text=text)
if hexstr is not None:
return int(hexstr, 16)
elif text is not None:
return int(text)
elif isinstance(value, bytes):
return big_endian_to_int(value)
elif isinstance(value, str):
raise TypeError("Pass in strings with keyword hexstr or text")
else:
return int(value)
def decoder_fn(self, data):
value = big_endian_to_int(data)
if value >= 2 ** (self.value_bit_size - 1):
return value - 2 ** self.value_bit_size
else:
return value
def __init__(self, pubkey: datatypes.PublicKey, address: Address) -> None:
self.pubkey = pubkey
self.address = address
self.id = big_endian_to_int(keccak(pubkey.to_bytes()))
def from_endpoint(cls, ip: str, udp_port: str, tcp_port: str = '\x00\x00') -> 'Address':
return cls(ip, big_endian_to_int(udp_port), big_endian_to_int(tcp_port))
def aes_ctr_decrypt(text, key, params):
iv = big_endian_to_int(decode_hex(params["iv"]))
ctr = Counter.new(128, initial_value=iv, allow_wraparound=True)
mode = AES.MODE_CTR
encryptor = AES.new(key, mode, counter=ctr)
return encryptor.decrypt(text)
def is_non_empty_non_null_byte_string(value):
return value and big_endian_to_int(value) != 0
def __hash__(self):
return big_endian_to_int(self.hash)
