def __init__(self, ctx, *args):
assert isinstance(ctx, NativeABIContract)
assert len(self.args) == len(args), \
"%s called with wrong number of args" % self.__class__.__name__
# topic0 sha3(EventName + signature)
topics = [self.event_id()]
indexed_args = []
non_indexed_args = []
for val, arg in zip(args, self.args):
if arg['indexed']:
indexed_args.append((arg['type'], val))
else:
non_indexed_args.append((arg['type'], val))
assert len(indexed_args) <= 3
# topics 1-n
for typ, val in indexed_args:
topics.append(big_endian_to_int(abi.encode_abi([typ], [val])))
# remaining non indexed data
data = abi.encode_abi([a[0] for a in non_indexed_args], [a[1] for a in non_indexed_args])
# add log
ctx._ext.log(ctx.address, topics, data)
def ethereum_event(eventid, eventabi, eventdata, contract_address):
event_types = [
param['type']
for param in eventabi['inputs']
]
event_data = [
eventdata[param['name']]
for param in eventabi['inputs']
if not param['indexed']
]
event_topics = [eventid] + [
encode_single(param['type'], eventdata[param['name']])
for param in eventabi['inputs']
if param['indexed']
]
event_data = encode_abi(event_types, event_data)
event = {
'topics': event_topics,
'data': event_data,
'address': contract_address,
}
return event
def abi_args_signature(self, args):
"""
Given the calling `args` for the function call, abi encode them.
"""
if len(self.input_types) != len(args):
raise ValueError("Expected {0} arguments, only got {1}".format(len(self.input_types), len(args))) # NOQA
scrubbed_args = tuple(clean_args(*zip(self.input_types, args)))
return abi.encode_abi(self.input_types, scrubbed_args)
def _db_encode_type(cls, value_type, val):
if value_type in ('string', 'bytes', 'binary', 'address'):
assert len(val) <= 32
assert isinstance(val, bytes)
return big_endian_to_int(val)
data = abi.encode_abi([value_type], [val])
assert len(data) <= 32
return big_endian_to_int(data)
def run_abi_test(params, mode):
types, args = params['types'], params['args']
out = abi.encode_abi(types, args)
assert abi.decode_abi(types, out) == args
if mode == FILL:
params['result'] = encode_hex(out)
return params
elif mode == VERIFY:
assert params['result'] == encode_hex(out)
elif mode == TIME:
x = time.time()
abi.encode_abi(types, args)
y = time.time()
abi.decode_abi(out, args)
return {
'encoding': y - x,
'decoding': time.time() - y
}
def create_contract(self, from_, code, gas, sig=None, args=None):
'''
Create a contract on the blockchain from compiled EVM code. Returns the
transaction hash.
'''
from_ = from_ or self.eth_coinbase()
if sig is not None and args is not None:
types = sig[sig.find('(') + 1: sig.find(')')].split(',')
encoded_params = encode_abi(types, args)
code += encoded_params.encode('hex')
return self.eth_sendTransaction(from_address=from_, gas=gas, data=code)
def abi_encode_return_vals(method, vals):
assert issubclass(method.im_class, NativeABIContract)
return_types = method.im_class._get_method_abi(method)['return_types']
# encode return value to list
if isinstance(return_types, list):
assert isinstance(vals, (list, tuple)) and len(vals) == len(return_types)
elif vals is None:
assert return_types is None
return ''
else:
vals = (vals, )
return_types = (return_types, )
return abi.encode_abi(return_types, vals)
def _encode_function(self, signature, param_values):
prefix = utils.big_endian_to_int(utils.sha3(signature)[:4])
if signature.find('(') == -1:
raise RuntimeError('Invalid function signature. Missing "(" and/or ")"...')
if signature.find(')') - signature.find('(') == 1:
return utils.encode_int(prefix)
types = signature[signature.find('(') + 1: signature.find(')')].split(',')
encoded_params = encode_abi(types, param_values)
return utils.zpad(utils.encode_int(prefix), 4) + encoded_params
def abi_data(sig, data):
prefix = get_prefix(sig)
data_abi = hex(prefix).rstrip('L')
logger.debug("ABI prefix: %s" % data_abi)
types = sig.split(':')[1][1:-1].split(',')
logger.debug("ABI types: %s" % types)
for i, s in enumerate(data):
if isinstance(data[i], (str, unicode)) and data[i][:2] == "0x":
data[i] = unhex(data[i])
logger.debug("ABI data: %s" % data)
data_abi += abi.encode_abi(types, data).encode('hex')
logger.debug("ABI encoded: %s" % data_abi)
return data_abi
def abi_data(fun_name, sig, data):
types = []
prefix = get_prefix(fun_name, sig)
data_abi = hex(prefix).rstrip('L')
for i, s in enumerate(sig):
if s == 's':
types.append('string')
elif s == 'a':
types.append('int256[]')
else:
if isinstance(data[i], (str, unicode)) and data[i][:2] == "0x":
data[i] = unhex(data[i])
types.append('int256')
data_abi += abi.encode_abi(types, data).encode('hex')
logger.debug("ABI data: %s" % data_abi)
return data_abi
def ethereum_event(eventid, eventabi, eventdata, contract_address):
event_types = [param['type'] for param in eventabi['inputs']]
event_data = [
eventdata[param['name']] for param in eventabi['inputs']
if not param['indexed']
]
event_topics = [eventid] + [
encode_single(param['type'], eventdata[param['name']])
for param in eventabi['inputs'] if param['indexed']
]
event_data = encode_abi(event_types, event_data)
event = {
'topics': event_topics,
'data': event_data,
'address': contract_address,
}
return event
def test_event():
event_abi = [{
'name':
'Test',
'anonymous':
False,
'inputs': [
{
'indexed': False,
'name': 'a',
'type': 'int256'
},
{
'indexed': False,
'name': 'b',
'type': 'int256'
},
],
'type':
'event',
}]
contract_abi = ContractTranslator(event_abi)
normalized_name = normalize_name('Test')
encode_types = ['int256', 'int256']
id_ = event_id(normalized_name, encode_types)
topics = [id_]
data = encode_abi(encode_types, [1, 2])
result = contract_abi.decode_event(topics, data)
assert result['_event_type'] == b'Test'
assert result['a'] == 1
assert result['b'] == 2
def test_encode_decode_int():
int8 = ('int', '8', [])
int32 = ('int', '32', [])
int256 = ('int', '256', [])
int8_values = [
1,
-1,
127,
-128,
]
int32_values = [
1,
-1,
127,
-128,
2**31 - 1,
-2**31,
]
int256_values = [
1,
-1,
127,
-128,
2**31 - 1,
-2**31,
2**255 - 1,
-2**255,
]
for value in int8_values:
assert encode_abi(['int8'], [value]) == encode_single(int8, value)
assert decode_abi(['int8'], encode_abi(['int8'], [value]))[0] == value
for value in int32_values:
assert encode_abi(['int32'], [value]) == encode_single(int32, value)
assert decode_abi(['int32'], encode_abi(['int32'],
[value]))[0] == value
for value in int256_values:
assert encode_abi(['int256'], [value]) == encode_single(int256, value)
assert decode_abi(['int256'], encode_abi(['int256'],
[value]))[0] == value
def abi_args_signature(self, args):
"""
Given the calling `args` for the function call, abi encode them.
"""
return abi.encode_abi(self.input_types, args)
def test_abi_encode_signed_int():
assert abi.decode_abi(['int8'], abi.encode_abi(['int8'], [1]))[0] == 1
assert abi.decode_abi(['int8'], abi.encode_abi(['int8'], [-1]))[0] == -1
# -*- coding: utf-8 -*-
from ethereum.abi import encode_abi, encode_int
def encode_calldata(arg_types, args):
args = encode_abi(arg_types, args)
return args.hex()
if __name__ == '__main__':
print(encode_abi(['uint256'], [12345]))
def abi_encode_args(method, args):
"encode args for method: method_id|data"
assert issubclass(method.im_class, NativeABIContract), method.im_class
m_abi = method.im_class._get_method_abi(method)
return zpad(encode_int(m_abi['id']), 4) + abi.encode_abi(m_abi['arg_types'], args)
def encode_calldata(func_name, arg_types, args):
mid = method_id(func_name, arg_types)
function_selector = zpad(encode_int(mid), 4)
args = encode_abi(arg_types, args)
return "0x" + function_selector.hex() + args.hex()
def test_abi_encode_signed_int():
assert abi.decode_abi(['int8'], abi.encode_abi(['int8'], [1]))[0] == 1
assert abi.decode_abi(['int8'], abi.encode_abi(['int8'], [-1]))[0] == -1
def test_abi_encode_var_sized_array():
abi.encode_abi(['address[]'], [['\x00' * 20] * 3])
def test_abi_encode_var_sized_array():
abi.encode_abi(['address[]'], [[b'\x00' * 20] * 3])
def encode_calldata(arg_types, args):
args = encode_abi(arg_types, args)
return args.hex()
def test_encode_decode_bool():
assert decode_abi(['bool'], encode_abi(['bool'], [True]))[0] is True
assert decode_abi(['bool'], encode_abi(['bool'], [False]))[0] is False
def testAddress(self):
addr = '407d73d8a49eeb85d32cf465507dd71d507100c1'
enc = encode_abi(['address'], [
str(bytearray.fromhex('407d73d8a49eeb85d32cf465507dd71d507100c1'))
]).encode('hex')
self.assertEqual(enc[-40:], addr)
def test_abi_encode_fixed_size_array():
abi.encode_abi(['uint16[2]'], [[5, 6]])
def testEncodeAbi(self):
enc = encode_abi(['uint32', 'uint32[]', 'bytes10', 'bytes'], [
int(0x123), [int(0x456), int(0x789)], "1234567890", "Hello, world!"
]).encode('hex')
data = "00000000000000000000000000000000000000000000000000000000000001230000000000000000000000000000000000000000000000000000000000000080313233343536373839300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000004560000000000000000000000000000000000000000000000000000000000000789000000000000000000000000000000000000000000000000000000000000000d48656c6c6f2c20776f726c642100000000000000000000000000000000000000"
self.assertEqual(enc, data)
def test_abi_encode_fixed_size_array():
abi.encode_abi(['uint16[2]'], [[5, 6]])
def abi_encode_args(method, args):
"encode args for method: method_id|data"
assert issubclass(method.im_class, NativeABIContract), method.im_class
m_abi = method.im_class._get_method_abi(method)
return zpad(encode_int(m_abi['id']), 4) + abi.encode_abi(
m_abi['arg_types'], args)
