def ecadd(computation: ComputationAPI,
gas_cost: int = constants.GAS_ECADD) -> ComputationAPI:
computation.consume_gas(gas_cost, reason='ECADD Precompile')
try:
result = _ecadd(computation.msg.data_as_bytes)
except ValidationError:
raise VMError("Invalid ECADD parameters")
result_x, result_y = result
result_bytes = b''.join((
pad32(int_to_big_endian(result_x.n)),
pad32(int_to_big_endian(result_y.n)),
))
computation.output = result_bytes
return computation
def ripemd160(computation: ComputationAPI) -> ComputationAPI:
word_count = ceil32(len(computation.msg.data)) // 32
gas_fee = constants.GAS_RIPEMD160 + word_count * constants.GAS_RIPEMD160WORD
computation.consume_gas(gas_fee, reason="RIPEMD160 Precompile")
# TODO: this only works if openssl is installed.
hash = hashlib.new('ripemd160', computation.msg.data).digest()
padded_hash = pad32(hash)
computation.output = padded_hash
return computation
def ecrecover(computation: ComputationAPI) -> ComputationAPI:
computation.consume_gas(constants.GAS_ECRECOVER,
reason="ECRecover Precompile")
data = computation.msg.data_as_bytes
raw_message_hash = data[:32]
message_hash = pad32r(raw_message_hash)
v_bytes = pad32r(data[32:64])
v = big_endian_to_int(v_bytes)
r_bytes = pad32r(data[64:96])
r = big_endian_to_int(r_bytes)
s_bytes = pad32r(data[96:128])
s = big_endian_to_int(s_bytes)
try:
validate_lt_secpk1n(r, title="ECRecover: R")
validate_lt_secpk1n(s, title="ECRecover: S")
validate_lte(v, 28, title="ECRecover: V")
validate_gte(v, 27, title="ECRecover: V")
except ValidationError:
return computation
canonical_v = v - 27
try:
signature = keys.Signature(vrs=(canonical_v, r, s))
public_key = signature.recover_public_key_from_msg_hash(message_hash)
except BadSignature:
return computation
address = public_key.to_canonical_address()
padded_address = pad32(address)
computation.output = padded_address
return computation
def generate_random_keypair() -> Tuple[bytes, Address]:
key_object = keys.PrivateKey(
pad32(int_to_big_endian(random.getrandbits(8 * 32))))
return key_object.to_bytes(), Address(
key_object.public_key.to_canonical_address())
def _decode_key(self, key: bytes) -> bytes:
padded_slot = pad32(key)
return keccak(padded_slot)