def encode_int(v):
s = encode_hex(int_to_big_endian(int(v)))
if s[:1] == '0': # remove leading zero
s = s[1:]
if not s:
s = '0'
return '0x' + s
def mine(block_number, difficulty, mining_hash, start_nonce=0, rounds=1000):
assert utils.is_numeric(start_nonce)
cache = get_cache(block_number)
nonce = start_nonce
target = utils.zpad(
utils.int_to_big_endian(2**256 // (difficulty or 1) - 1), 32)
for i in range(1, rounds + 1):
bin_nonce = utils.zpad(utils.int_to_big_endian((nonce + i) & TT64M1),
8)
o = hashimoto_light(block_number, cache, mining_hash, bin_nonce)
if o[b'result'] <= target:
log.debug('nonce found: {}'.format(bin_nonce))
assert len(bin_nonce) == 8
assert len(o[b'mix digest']) == 32
return bin_nonce, o[b'mix digest']
return None, None
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 test_transaction(filename, testname, testdata):
try:
rlpdata = decode_hex(testdata["rlp"][2:])
o = {}
tx = rlp.decode(rlpdata, transactions.Transaction)
blknum = int(testdata["blocknumber"])
# if blknum >= config.default_config["HOMESTEAD_FORK_BLKNUM"]:
# tx.check_low_s_homestead()
assert config_fork_specific_validation(konfig, blknum, tx)
assert tx.startgas >= tx.intrinsic_gas_used
if tx.sender == null_address:
assert tx.value == 0 and tx.gasprice == 0 and tx.nonce == 0
o["sender"] = tx.sender
o["transaction"] = {
"data": '0x' * (len(tx.data) > 0) + encode_hex(tx.data),
"gasLimit": str(tx.startgas),
"gasPrice": str(tx.gasprice),
"nonce": str(tx.nonce),
"r":
'0x' + encode_hex(utils.zpad(utils.int_to_big_endian(tx.r), 32)),
"s":
'0x' + encode_hex(utils.zpad(utils.int_to_big_endian(tx.s), 32)),
"v": str(tx.v),
"value": str(tx.value),
"to": encode_hex(tx.to),
}
except Exception as e:
tx = None
sys.stderr.write(str(e))
if 'transaction' not in testdata: # expected to fail
# print(tx.to_dict(), testdata)
assert tx is None
else:
assert set(o['transaction'].keys()) == set(
testdata.get("transaction", dict()).keys())
o.get("transaction", None) == testdata.get("transaction", None)
assert str_to_bytes(encode_hex(o.get("sender", ''))) == str_to_bytes(
testdata.get("sender", ''))
def format_message(msg, kwargs, highlight, level):
if 'memory' in kwargs:
vm.log_vm_op.memory = '0x' + kwargs['memory']
if 'storage' in kwargs:
s = []
storage = kwargs['storage']['storage']
for k in sorted(storage.keys()):
v = '0x' + encode_hex(zpad(int_to_big_endian(scan_int(storage[k])),32))
k = '0x' + encode_hex(zpad(int_to_big_endian(scan_int(k)),32))
s.append(k + ': ' + v)
s = ','.join(s)
vm.log_vm_op.storage = s
return '{"pc":%s,"op":%s,"gas":"%s","gasCost":"%s","memory":"%s","stack":[%s],"storage":{%s},"depth":%s}' % (
kwargs['pc'],
kwargs['inst'],
encode_int(int(kwargs['gas'])),
encode_int(kwargs['gas_cost']),
vm.log_vm_op.memory,
','.join(['"%s"' % encode_int(v) for v in kwargs['stack']]),
vm.log_vm_op.storage,
kwargs['depth']+1
)
def proc_modexp(ext, msg):
if not ext.post_metropolis_hardfork():
return 1, msg.gas, []
print('modexp proc', msg.gas)
baselen = msg.data.extract32(0)
explen = msg.data.extract32(32)
modlen = msg.data.extract32(64)
first_exp_bytes = msg.data.extract32(96 + baselen) >> (8 *
max(32 - explen, 0))
bitlength = -1
while first_exp_bytes:
bitlength += 1
first_exp_bytes >>= 1
adjusted_explen = max(bitlength, 0) + 8 * max(explen - 32, 0)
gas_cost = (mult_complexity(max(modlen, baselen)) *
max(adjusted_explen, 1)) // opcodes.GMODEXPQUADDIVISOR
print(baselen, explen, modlen, 'expected gas cost', gas_cost)
if msg.gas < gas_cost:
return 0, 0, []
if baselen == 0:
return 1, msg.gas - gas_cost, [0] * modlen
if modlen == 0:
return 1, msg.gas - gas_cost, []
base = bytearray(baselen)
msg.data.extract_copy(base, 0, 96, baselen)
exp = bytearray(explen)
msg.data.extract_copy(exp, 0, 96 + baselen, explen)
mod = bytearray(modlen)
msg.data.extract_copy(mod, 0, 96 + baselen + explen, modlen)
if utils.big_endian_to_int(mod) == 0:
return 1, msg.gas - gas_cost, [0] * modlen
o = pow(utils.big_endian_to_int(base), utils.big_endian_to_int(exp),
utils.big_endian_to_int(mod))
return 1, msg.gas - \
gas_cost, [
safe_ord(x) for x in utils.zpad(
utils.int_to_big_endian(o), modlen)]
def encode_hex_from_int(x):
return encode_hex(utils.zpad(utils.int_to_big_endian(x), 256))
def intlen(o):
return len(int_to_big_endian(o))
def mk_modexp_data(b, e, m):
benc = int_to_big_endian(b)
eenc = int_to_big_endian(e)
menc = int_to_big_endian(m)
return encode_int32(len(benc)) + encode_int32(len(eenc)) + \
encode_int32(len(menc)) + benc + eenc + menc
def b64(int_bloom):
"returns b256"
return utils.zpad(utils.int_to_big_endian(int_bloom), 256)
def test_mcopy2():
c = tester.Chain()
contract = c.contract(mcopy_code_2, language='serpent')
assert contract.mcopy_test() == \
b''.join([utils.zpad(utils.int_to_big_endian(x), 32)
for x in [99, 111, 119]])
def valueconv(k, v):
if k in ['r', 's']:
return '0x' + encode_hex(utils.int_to_big_endian(v))
return v
def int_to_0x_hex(v):
o = encode_hex(int_to_big_endian(v))
if o and o[0] == '0':
return '0x' + o[1:]
else:
return '0x' + o
def encode_single(typ, arg): # pylint: disable=too-many-return-statements,too-many-branches,too-many-statements,too-many-locals
""" Encode `arg` as `typ`.
`arg` will be encoded in a best effort manner, were necessary the function
will try to correctly define the underlying binary representation (ie.
decoding a hex-encoded address/hash).
Args:
typ (Tuple[(str, int, list)]): A 3-tuple defining the `arg` type.
The first element defines the type name.
The second element defines the type length in bits.
The third element defines if it's an array type.
Together the first and second defines the elementary type, the third
element must be present but is ignored.
Valid type names are:
- uint
- int
- bool
- ufixed
- fixed
- string
- bytes
- hash
- address
arg (object): The object to be encoded, it must be a python object
compatible with the `typ`.
Raises:
ValueError: when an invalid `typ` is supplied.
ValueOutOfBounds: when `arg` cannot be encoded as `typ` because of the
binary contraints.
Note:
This function don't work with array types, for that use the `enc`
function.
"""
base, sub, _ = typ
if base == 'uint':
sub = int(sub)
if not (0 < sub <= 256 and sub % 8 == 0):
raise ValueError(
'invalid unsigned integer bit length {}'.format(sub))
try:
i = decint(arg, signed=False)
except EncodingError:
# arg is larger than 2**256
raise ValueOutOfBounds(repr(arg))
if not 0 <= i < 2 ** sub:
raise ValueOutOfBounds(repr(arg))
value_encoded = int_to_big_endian(i)
return zpad(value_encoded, 32)
if base == 'int':
sub = int(sub)
bits = sub - 1
if not (0 < sub <= 256 and sub % 8 == 0):
raise ValueError('invalid integer bit length {}'.format(sub))
try:
i = decint(arg, signed=True)
except EncodingError:
# arg is larger than 2**255
raise ValueOutOfBounds(repr(arg))
if not -2 ** bits <= i < 2 ** bits:
raise ValueOutOfBounds(repr(arg))
value = i % 2 ** 256 # convert negative to "equivalent" positive
value_encoded = int_to_big_endian(value)
return zpad(value_encoded, 32)
if base == 'bool':
if arg is True:
value_encoded = int_to_big_endian(1)
elif arg is False:
value_encoded = int_to_big_endian(0)
else:
raise ValueError('%r is not bool' % arg)
return zpad(value_encoded, 32)
if base == 'ufixed':
sub = str(sub) # pylint: disable=redefined-variable-type
high_str, low_str = sub.split('x')
high = int(high_str)
low = int(low_str)
if not (0 < high + low <= 256 and high % 8 == 0 and low % 8 == 0):
raise ValueError('invalid unsigned fixed length {}'.format(sub))
if not 0 <= arg < 2 ** high:
raise ValueOutOfBounds(repr(arg))
float_point = arg * 2 ** low
fixed_point = int(float_point)
return zpad(int_to_big_endian(fixed_point), 32)
if base == 'fixed':
sub = str(sub) # pylint: disable=redefined-variable-type
high_str, low_str = sub.split('x')
high = int(high_str)
low = int(low_str)
bits = high - 1
if not (0 < high + low <= 256 and high % 8 == 0 and low % 8 == 0):
raise ValueError('invalid unsigned fixed length {}'.format(sub))
if not -2 ** bits <= arg < 2 ** bits:
raise ValueOutOfBounds(repr(arg))
float_point = arg * 2 ** low
fixed_point = int(float_point)
value = fixed_point % 2 ** 256
return zpad(int_to_big_endian(value), 32)
# Decimals
if base == 'decimal':
val_to_encode = int(arg * 10**int(sub))
return zpad(encode_int(val_to_encode % 2**256), 32)
if base == 'string':
if isinstance(arg, utils.unicode):
arg = arg.encode('utf8')
else:
try:
arg.decode('utf8')
except UnicodeDecodeError:
raise ValueError('string must be utf8 encoded')
if len(sub): # fixed length
if not 0 <= len(arg) <= int(sub):
raise ValueError('invalid string length {}'.format(sub))
if not 0 <= int(sub) <= 32:
raise ValueError('invalid string length {}'.format(sub))
return rzpad(arg, 32)
if not 0 <= len(arg) < TT256:
raise Exception('Integer invalid or out of range: %r' % arg)
length_encoded = zpad(int_to_big_endian(len(arg)), 32)
value_encoded = rzpad(arg, utils.ceil32(len(arg)))
return length_encoded + value_encoded
if base == 'bytes':
if not is_string(arg):
if isinstance(arg, str):
arg = bytes(arg, 'utf8')
else:
raise EncodingError('Expecting string: %r' % arg)
arg = utils.to_string(arg) # py2: force unicode into str
if len(sub): # fixed length
if not 0 <= len(arg) <= int(sub):
raise ValueError('string must be utf8 encoded')
if not 0 <= int(sub) <= 32:
raise ValueError('string must be utf8 encoded')
return rzpad(arg, 32)
if not 0 <= len(arg) < TT256:
raise Exception('Integer invalid or out of range: %r' % arg)
length_encoded = zpad(int_to_big_endian(len(arg)), 32)
value_encoded = rzpad(arg, utils.ceil32(len(arg)))
return length_encoded + value_encoded
if base == 'hash':
if not (int(sub) and int(sub) <= 32):
raise EncodingError('too long: %r' % arg)
if is_numeric(arg):
return zpad(encode_int(arg), 32)
if len(arg) == int(sub):
return zpad(arg, 32)
if len(arg) == int(sub) * 2:
return zpad(decode_hex(arg), 32)
raise EncodingError('Could not parse hash: %r' % arg)
if base == 'address':
assert sub == ''
if is_numeric(arg):
return zpad(encode_int(arg), 32)
if len(arg) == 20:
return zpad(arg, 32)
if len(arg) == 40:
return zpad(decode_hex(arg), 32)
if len(arg) == 42 and arg[:2] == '0x':
return zpad(decode_hex(arg[2:]), 32)
raise EncodingError('Could not parse address: %r' % arg)
raise EncodingError('Unhandled type: %r %r' % (base, sub))