def test_mixed_inequality_operation(self):
expected_output = (Opcode.INITSLOT + b'\x00' + b'\x02' +
Opcode.LDARG0 + Opcode.LDARG1 + Opcode.NOTEQUAL +
Opcode.RET)
path = self.get_contract_path('MixedInequality.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine, path, 'Main', 1, 'unit')
self.assertEqual(True, result)
result = self.run_smart_contract(engine, path, 'Main', 123, '123')
self.assertEqual(True, result)
result = self.run_smart_contract(engine, path, 'Main',
Integer.from_bytes(b'123'), '123')
self.assertEqual(True, result)
def test_dict_set_value(self):
ok = String('ok').to_bytes()
expected_output = (Opcode.INITSLOT + b'\x00' + b'\x01' +
Opcode.LDARG0 + Opcode.PUSH0 + Opcode.PUSHDATA1 +
Integer(len(ok)).to_byte_array(min_length=1) + ok +
Opcode.SETITEM + Opcode.LDARG0 + Opcode.RET)
path = self.get_contract_path('SetValue.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine, path, 'Main', {0: 'zero'})
self.assertEqual({0: 'ok'}, result)
result = self.run_smart_contract(engine, path, 'Main', {1: 'one'})
self.assertEqual({0: 'ok', 1: 'one'}, result)
def deserialize_binary(reader: BinaryReader) -> Any:
deserialized_items = []
underserialized = 1
while underserialized > 0:
stack_type = reader.read_byte()
if stack_type == StackItemType.Any:
deserialized_items.append(None)
elif stack_type == StackItemType.Boolean:
deserialized_items.append(reader.read_bool())
elif stack_type == StackItemType.Integer:
value_in_bytes = reader.read_var_bytes()
deserialized_items.append(Integer.from_bytes(value_in_bytes))
elif stack_type in (StackItemType.ByteString, StackItemType.Buffer):
deserialized_items.append(reader.read_var_bytes())
elif stack_type in (StackItemType.Array, StackItemType.Struct):
count = reader.read_var_int()
deserialized_items.append(list(range(count)))
underserialized += count
elif stack_type == StackItemType.Map:
count = reader.read_var_int()
deserialized_items.append({key: None for key in range(count)})
underserialized += count * 2
else:
raise ValueError
underserialized -= 1
stack_temp = []
while len(deserialized_items) > 0:
item = deserialized_items.pop()
if isinstance(item, list):
new_item = []
for _ in range(len(item)):
new_item.append(stack_temp.pop())
item = new_item
elif isinstance(item, dict):
new_item = {}
for _ in range(0, len(item), 2):
key = stack_temp.pop()
value = stack_temp.pop()
new_item[key] = value
item = new_item
stack_temp.append(item)
return stack_temp.pop()
def test_any_list_constant(self):
input = [1, '2', False]
byte_input1 = String(input[1]).to_bytes()
expected_output = (
Opcode.INITSSLOT + b'\x01' + Opcode.PUSH0 # False
+ Opcode.CONVERT + StackItemType.Boolean + Opcode.PUSHDATA1 # '2'
+ Integer(len(byte_input1)).to_byte_array() + byte_input1 +
Opcode.PUSH1 # 1
+ Opcode.PUSH3 # list length
+ Opcode.PACK + Opcode.DROP + Opcode.RET)
analyser = Analyser(ast.parse(str(input)))
analyser.symbol_table['x'] = Variable(Type.any)
output = CodeGenerator.generate_code(analyser)
self.assertEqual(expected_output, output)
def test_if_constant_condition(self):
expected_output = (
Opcode.INITSLOT + b'\x01' + b'\x00' + Opcode.PUSH0 # a = 0
+ Opcode.STLOC0 + Opcode.PUSH1 + Opcode.CONVERT +
StackItemType.Boolean + Opcode.JMPIFNOT # if True
+ Integer(4).to_byte_array(min_length=1, signed=True) +
Opcode.PUSH2 # a = a + 2
+ Opcode.STLOC0 + Opcode.LDLOC0 # return a
+ Opcode.RET)
path = self.get_contract_path('ConstantCondition.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine, path, 'Main')
self.assertEqual(2, result)
def test_str_to_bytes_with_builtin(self):
value = String('123').to_bytes()
expected_output = (
Opcode.PUSHDATA1 # str.to_bytes('123')
+ Integer(len(value)).to_byte_array(min_length=1) + value +
Opcode.CONVERT + Type.bytes.stack_item + Opcode.RET)
path = self.get_contract_path('StrToBytesWithBuiltin.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine,
path,
'str_to_bytes',
expected_result_type=bytes)
self.assertEqual(value, result)
def opcode(self) -> List[Tuple[Opcode, bytes]]:
from boa3.model.builtin.interop.interop import Interop
from boa3.model.type.type import Type
from boa3.neo.vm.type.Integer import Integer
from boa3.neo.vm.type.String import String
method = String(self._sys_call).to_bytes()
method_opcode = [
(Opcode.PUSHDATA1,
Integer(len(method)).to_byte_array(min_length=1) + method)
]
drop_if_void_opcode = [(Opcode.DROP,
b'')] if self.return_type is Type.none else []
return (method_opcode +
Interop.ManagementContractScriptHash.getter.opcode +
Interop.CallContract.opcode + drop_if_void_opcode)
def test_from_import_user_module_with_alias(self):
expected_output = (
Opcode.INITSLOT # function signature
+ b'\x01' + b'\x00' + Opcode.CALL +
Integer(5).to_byte_array(min_length=1, signed=True) +
Opcode.STLOC0 + Opcode.LDLOC0 + Opcode.RET +
Opcode.NEWARRAY0 # imported function
+ Opcode.RET # return
)
path = self.get_contract_path('FromImportUserModuleWithAlias.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine, path, 'Main')
self.assertEqual([], result)
def test_import_user_module_with_global_variables(self):
expected_output = (
Opcode.LDSFLD0 # b = a
+ Opcode.RET + Opcode.INITSSLOT + b'\x01' +
Opcode.CALL # a = UserModule.EmptyList()
+ Integer(4).to_byte_array(min_length=1, signed=True) +
Opcode.STSFLD0 + Opcode.RET + Opcode.NEWARRAY0 # imported function
+ Opcode.RET # return
)
path = self.get_contract_path('FromImportWithGlobalVariables.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine, path, 'Main')
self.assertEqual([], result)
def test_call_function_written_before_caller(self):
call_address = Integer(-9).to_byte_array(min_length=1, signed=True)
expected_output = (
Opcode.INITSLOT # TestFunction
+ b'\x00' + b'\x02' + Opcode.LDARG0 # return a + b
+ Opcode.LDARG1 + Opcode.ADD + Opcode.RET +
Opcode.PUSH2 # return TestAdd(a, b)
+ Opcode.PUSH1 + Opcode.CALL + call_address + Opcode.RET)
path = self.get_contract_path('CallFunctionWrittenBefore.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine, path, 'Main')
self.assertEqual(3, result)
def _get_raw_data(self, opcode: VMCode) -> bytes:
"""
Gets the Neo VM raw data of the code
:return: the unformatted data in bytes of the code.
"""
min_len = self._info.data_len // 2 # for try opcode, data_len adds catch and finally addresses
if opcode is None:
return bytes(min_len)
else:
from boa3.compiler.vmcodemapping import VMCodeMapping
code_mapping = VMCodeMapping.instance()
self_start = code_mapping.get_start_address(self)
target_start = code_mapping.get_start_address(opcode)
return (Integer(target_start - self_start).to_byte_array(
signed=True, min_length=min_len))
def get_native_contract_data(
token_script: bytes) -> Tuple[Optional[bytes], Optional[int]]:
prefix: Optional[NativeContractPrefix] = None
contract_id: NativeContractId = NativeContractId.NONE
if token_script is constants.NEO_SCRIPT:
prefix = NativeContractPrefix.NEO
contract_id = NativeContractId.NEO
elif token_script is constants.GAS_SCRIPT:
prefix = NativeContractPrefix.GAS
contract_id = NativeContractId.GAS
elif token_script is constants.MANAGEMENT_SCRIPT:
prefix = NativeContractPrefix.ContractManagement
contract_id = NativeContractId.ContractManagement
return (prefix if prefix is None else Integer(prefix).to_byte_array(
min_length=1), contract_id.value)
def convert_store_variable(self, var_id: str):
"""
Converts the assignment of a variable
:param var_id: the value to be converted
"""
index, local, is_arg = self._get_variable_info(var_id)
if index >= 0:
opcode = Opcode.get_store(index, local, is_arg)
if opcode is not None:
op_info = OpcodeInfo.get_info(opcode)
if op_info.data_len > 0:
self.__insert1(op_info, Integer(index).to_byte_array())
else:
self.__insert1(op_info)
self._stack.pop()
def test_any_variable_assignments(self):
two = String('2').to_bytes()
path = self.get_contract_path('AnyVariableAssignments.py')
expected_output = (
Opcode.INITSLOT # function signature
+ b'\x01' + b'\x00' + Opcode.PUSH1 # a = 1
+ Opcode.STLOC0 + Opcode.PUSHDATA1 # a = '2'
+ Integer(len(two)).to_byte_array() + two + Opcode.STLOC0 +
Opcode.PUSH1 # a = True
+ Opcode.CONVERT + StackItemType.Boolean + Opcode.STLOC0 +
Opcode.PUSH3 # a = [1, 2, 3]
+ Opcode.PUSH2 + Opcode.PUSH1 + Opcode.PUSH3 + Opcode.PACK +
Opcode.STLOC0 + Opcode.RET # return
)
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
def test_nested_for(self):
outer_jmpif_address = Integer(47).to_byte_array(min_length=1,
signed=True)
outer_jmp_address = Integer(-50).to_byte_array(min_length=1,
signed=True)
inner_jmpif_address = Integer(21).to_byte_array(min_length=1,
signed=True)
inner_jmp_address = Integer(-24).to_byte_array(min_length=1,
signed=True)
expected_output = (
Opcode.INITSLOT + b'\x04' + b'\x00' + Opcode.PUSH0 # a = 0
+ Opcode.STLOC0 + Opcode.PUSH15 # sequence = (3, 5, 15)
+ Opcode.PUSH5 + Opcode.PUSH3 + Opcode.PUSH3 + Opcode.PACK +
Opcode.STLOC1 + Opcode.LDLOC1 # outer_for_sequence = sequence
+ Opcode.PUSH0 # outer_for_index = 0
+ Opcode.JMP + outer_jmpif_address +
Opcode.OVER # x = outer_for_sequence[outer_for_index]
+ Opcode.OVER + Opcode.DUP + Opcode.SIGN + Opcode.PUSHM1 +
Opcode.JMPNE +
Integer(5).to_byte_array(min_length=1, signed=True) + Opcode.OVER +
Opcode.SIZE + Opcode.ADD + Opcode.PICKITEM + Opcode.STLOC2 +
Opcode.LDLOC1 # inner_for_sequence = sequence
+ Opcode.PUSH0 # inner_for_index = 0
+ Opcode.JMP + inner_jmpif_address +
Opcode.OVER # y = inner_for_sequence[inner_for_index]
+ Opcode.OVER + Opcode.DUP + Opcode.SIGN + Opcode.PUSHM1 +
Opcode.JMPNE +
Integer(5).to_byte_array(min_length=1, signed=True) + Opcode.OVER +
Opcode.SIZE + Opcode.ADD + Opcode.PICKITEM + Opcode.STLOC3 +
Opcode.LDLOC0 # a = a + x * y
+ Opcode.LDLOC2 + Opcode.LDLOC3 + Opcode.MUL + Opcode.ADD +
Opcode.STLOC0 + Opcode.INC # inner_for_index = inner_for_index + 1
+ Opcode.DUP # if inner_for_index < len(inner_for_sequence)
+ Opcode.PUSH2 + Opcode.PICK + Opcode.SIZE + Opcode.LT +
Opcode.JMPIF # end inner_for
+ inner_jmp_address + Opcode.DROP + Opcode.DROP +
Opcode.INC # outer_for_index = outer_for_index + 1
+ Opcode.DUP # if outer_for_index < len(outer_for_sequence)
+ Opcode.PUSH2 + Opcode.PICK + Opcode.SIZE + Opcode.LT +
Opcode.JMPIF # end outer_for
+ outer_jmp_address + Opcode.DROP + Opcode.DROP +
Opcode.LDLOC0 # return a
+ Opcode.RET)
path = self.get_contract_path('NestedFor.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine, path, 'Main')
self.assertEqual(529, result)
def test_dict_any_value(self):
nine = String('nine').to_bytes()
expected_output = (
Opcode.INITSLOT + b'\x01' + b'\x00' +
Opcode.NEWMAP # a = {1: True, 2: 4, 3: 'nine'}
+ Opcode.DUP + Opcode.PUSH1 # map[1] = True
+ Opcode.PUSH1 + Opcode.SETITEM + Opcode.DUP +
Opcode.PUSH2 # map[2] = 4
+ Opcode.PUSH4 + Opcode.SETITEM + Opcode.DUP +
Opcode.PUSH3 # map[3] = 'nine'
+ Opcode.PUSHDATA1 +
Integer(len(nine)).to_byte_array(min_length=1) + nine +
Opcode.SETITEM + Opcode.STLOC0 + Opcode.PUSHNULL + Opcode.RET)
path = '%s/boa3_test/test_sc/dict_test/AnyValueDict.py' % self.dirname
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
def test_dict_any_value(self):
nine = String('nine').to_bytes()
expected_output = (
Opcode.INITSLOT + b'\x01' + b'\x00' +
Opcode.NEWMAP # a = {1: True, 2: 4, 3: 'nine'}
+ Opcode.DUP + Opcode.PUSH1 # map[1] = True
+ Opcode.PUSH1 + Opcode.CONVERT + StackItemType.Boolean +
Opcode.SETITEM + Opcode.DUP + Opcode.PUSH2 # map[2] = 4
+ Opcode.PUSH4 + Opcode.SETITEM + Opcode.DUP +
Opcode.PUSH3 # map[3] = 'nine'
+ Opcode.PUSHDATA1 +
Integer(len(nine)).to_byte_array(min_length=1) + nine +
Opcode.SETITEM + Opcode.STLOC0 + Opcode.RET)
path = self.get_contract_path('AnyValueDict.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
def test_multiple_assignments_set_sequence_last(self):
expected_output = (
Opcode.INITSLOT # function signature
+ b'\x03' + b'\x00' + Opcode.PUSH3 # a = [1, 2, 3]
+ Opcode.PUSH2 + Opcode.PUSH1 + Opcode.PUSH3 + Opcode.PACK +
Opcode.STLOC0 + Opcode.PUSH2 # a[2] = c = b = 2
+ Opcode.DUP # b = 2
+ Opcode.STLOC2 + Opcode.DUP # c = 2
+ Opcode.STLOC1 + Opcode.PUSH2 # a[2] = 2
+ Opcode.DUP + Opcode.SIGN + Opcode.PUSHM1 + Opcode.JMPNE +
Integer(5).to_byte_array(signed=True, min_length=1) + Opcode.OVER +
Opcode.SIZE + Opcode.ADD + Opcode.LDLOC0 + Opcode.REVERSE3 +
Opcode.SETITEM + Opcode.PUSHNULL # return
+ Opcode.RET)
path = '%s/boa3_test/test_sc/variable_test/MultipleAssignmentsSetSequenceLast.py' % self.dirname
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
def test_if_variable_condition(self):
expected_output = (
Opcode.INITSLOT + b'\x01' + b'\x01' + Opcode.PUSH0 # a = 0
+ Opcode.STLOC0 + Opcode.LDARG0 + Opcode.JMPIFNOT # if arg0
+ Integer(4).to_byte_array(min_length=1, signed=True) +
Opcode.PUSH2 # a = a + 2
+ Opcode.STLOC0 + Opcode.LDLOC0 # return a
+ Opcode.RET)
path = self.get_contract_path('VariableCondition.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine, path, 'Main', True)
self.assertEqual(2, result)
result = self.run_smart_contract(engine, path, 'Main', False)
self.assertEqual(0, result)
def test_log_str(self):
string = String('str').to_bytes()
expected_output = (
Opcode.PUSHDATA1
+ Integer(len(string)).to_byte_array(min_length=1)
+ string
+ Opcode.SYSCALL
+ Interop.Log.interop_method_hash
+ Opcode.RET
)
path = self.get_contract_path('LogStr.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine, path, 'Main')
self.assertIsVoid(result)
def test_get_gas_native_script_hash(self):
value = GAS
expected_output = (
Opcode.PUSHDATA1
+ Integer(len(value)).to_byte_array()
+ value
+ Opcode.CONVERT
+ Type.bytes.stack_item
+ Opcode.RET
)
path = '%s/boa3_test/test_sc/interop_test/GasScriptHash.py' % self.dirname
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine(self.dirname)
result = self.run_smart_contract(engine, path, 'Main')
self.assertEqual(value, result)
def _filter_result(self, test_engine, expected_result_type, result) -> Any:
if test_engine.vm_state is not VMState.HALT and test_engine.error is not None:
raise TestExecutionException(test_engine.error)
if expected_result_type is not None:
if expected_result_type is not str and isinstance(result, str):
result = String(result).to_bytes()
if expected_result_type is bool:
if isinstance(result, bytes):
result = Integer.from_bytes(result, signed=True)
if isinstance(result, int) and result in (False, True):
result = bool(result)
if expected_result_type is bytearray and isinstance(result, bytes):
result = bytearray(result)
return result
def opcode(self) -> List[Tuple[Opcode, bytes]]:
from boa3.neo.vm.type.Integer import Integer
return [
(Opcode.DUP, b''),
(Opcode.SIGN, b''),
(Opcode.PUSHM1, b''),
(Opcode.JMPNE, Integer(5).to_byte_array(min_length=1,
signed=True)),
(Opcode.OVER, b''),
(Opcode.SIZE, b''),
(Opcode.ADD, b''),
(Opcode.OVER, b''),
(Opcode.OVER, b''),
(Opcode.PICKITEM, b''),
(Opcode.REVERSE3, b''),
(Opcode.SWAP, b''),
(Opcode.REMOVE, b''),
]
def test_cast_to_typed_dict(self):
string = String('example').to_bytes()
expected_output = (
Opcode.INITSLOT
+ b'\x01'
+ b'\x01'
+ Opcode.LDARG0 # x = cast(Dict[str, int], value)
+ Opcode.STLOC0
+ Opcode.LDLOC0 # return x['example']
+ Opcode.PUSHDATA1
+ Integer(len(string)).to_byte_array(min_length=1)
+ string
+ Opcode.PICKITEM
+ Opcode.RET
)
path = self.get_contract_path('CastToTypedDict.py')
output = self.assertCompilerLogs(CompilerWarning.TypeCasting, path)
self.assertEqual(expected_output, output)
def test_byte_array_reverse(self):
data = b'\x01\x02\x03'
expected_output = (
Opcode.INITSLOT # function signature
+ b'\x01' + b'\x00' +
Opcode.PUSHDATA1 # a = bytearray(b'\x01\x02\x03')
+ Integer(len(data)).to_byte_array(min_length=1) + data +
Opcode.CONVERT + Type.bytes.stack_item + Opcode.STLOC0 +
Opcode.LDLOC0 # a.reverse()
+ Opcode.REVERSEITEMS + Opcode.LDLOC0 + Opcode.RET # return a
)
path = '%s/boa3_test/test_sc/bytes_test/BytearrayReverse.py' % self.dirname
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine(self.dirname)
result = self.run_smart_contract(engine, path, 'Main')
self.assertEqual(b'\x03\x02\x01', result)
def test_script_hash_variable_with_builtin(self):
path = self.get_contract_path('ScriptHashVariableBuiltinCall.py')
from boa3.neo import to_script_hash
from base58 import b58encode
engine = TestEngine()
script_hash = to_script_hash('123')
result = self.run_smart_contract(engine, path, 'Main', '123',
expected_result_type=bytes)
self.assertEqual(script_hash, result)
value = b58encode('123')
if isinstance(value, int):
value = Integer(value).to_byte_array()
script_hash = to_script_hash(value)
result = self.run_smart_contract(engine, path, 'Main', value,
expected_result_type=bytes)
self.assertEqual(script_hash, result)
def test_multiple_assignments_set_sequence(self):
expected_output = (
Opcode.INITSLOT # function signature
+ b'\x03' + b'\x00' + Opcode.PUSH3 # a = [1, 2, 3]
+ Opcode.PUSH2 + Opcode.PUSH1 + Opcode.PUSH3 + Opcode.PACK +
Opcode.STLOC0 + Opcode.PUSH2 # c = a[2] = b = 2
+ Opcode.DUP # b = 2
+ Opcode.STLOC2 + Opcode.LDLOC0 # a[2] = 2
+ Opcode.PUSH2 + Opcode.DUP + Opcode.SIGN + Opcode.PUSHM1 +
Opcode.JMPNE +
Integer(5).to_byte_array(signed=True, min_length=1) + Opcode.OVER +
Opcode.SIZE + Opcode.ADD + Opcode.PUSH2 + Opcode.PICK +
Opcode.SETITEM + Opcode.STLOC1 # c = 2
+ Opcode.RET # return
)
path = self.get_contract_path('MultipleAssignmentsSetSequence.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
def run_smart_contract(self, test_engine: TestEngine, smart_contract_path: Union[str, bytes], method: str,
*arguments: Any, reset_engine: bool = False,
fake_storage: Dict[Tuple[str, str], Any] = None,
signer_accounts: Iterable[bytes] = (),
expected_result_type: Type = None,
rollback_on_fault: bool = True) -> Any:
if isinstance(smart_contract_path, str) and smart_contract_path.endswith('.py'):
if not (os.path.isfile(smart_contract_path.replace('.py', '.nef'))
and os.path.isfile(smart_contract_path.replace('.py', '.manifest.json'))):
# both .nef and .manifest.json are required to execute the smart contract
self.compile_and_save(smart_contract_path, log=False)
smart_contract_path = smart_contract_path.replace('.py', '.nef')
elif isinstance(smart_contract_path, bytes):
from boa3.neo3.core.types import UInt160
smart_contract_path = UInt160(smart_contract_path)
if isinstance(fake_storage, dict):
test_engine.set_storage(fake_storage)
for account in signer_accounts:
test_engine.add_signer_account(account)
result = test_engine.run(smart_contract_path, method, *arguments,
reset_engine=reset_engine, rollback_on_fault=rollback_on_fault)
if test_engine.vm_state is not VMState.HALT and test_engine.error is not None:
raise TestExecutionException(test_engine.error)
if expected_result_type is not None:
if expected_result_type is not str and isinstance(result, str):
result = String(result).to_bytes()
if expected_result_type is bool:
if isinstance(result, bytes):
result = Integer.from_bytes(result, signed=True)
if isinstance(result, int) and result in (False, True):
result = bool(result)
if expected_result_type is bytearray and isinstance(result, bytes):
result = bytearray(result)
return result
def test_return_void_function(self):
called_function_address = Integer(4).to_byte_array(min_length=1,
signed=True)
expected_output = (
Opcode.CALL # Main
+ called_function_address # return TestFunction()
+ Opcode.PUSHNULL + Opcode.RET + Opcode.INITSLOT # TestFunction
+ b'\x01' + b'\x00' + Opcode.PUSH1 # a = 1
+ Opcode.STLOC0 + Opcode.RET # return
)
path = self.get_contract_path('ReturnVoidFunction.py')
output = Boa3.compile(path)
self.assertEqual(expected_output, output)
engine = TestEngine()
result = self.run_smart_contract(engine, path, 'Main')
self.assertIsNone(result)
def test_sequence_of_int_sequence_fail(self):
ok = String('ok').to_bytes()
expected_output = (
Opcode.INITSLOT + b'\x04' + b'\x00' +
Opcode.PUSH3 # int_list = [1, 2, 3]
+ Opcode.PUSH2 + Opcode.PUSH1 + Opcode.PUSH3 + Opcode.PACK +
Opcode.STLOC0 + Opcode.PUSHDATA1 # any_tuple = (True, 1, 'ok')
+ Integer(len(ok)).to_byte_array() + ok + Opcode.PUSH1 +
Opcode.PUSH1 + Opcode.PUSH3 + Opcode.PACK + Opcode.STLOC1 +
Opcode.PUSH8 # int_tuple = 10, 9, 8
+ Opcode.PUSH9 + Opcode.PUSH10 + Opcode.PUSH3 + Opcode.PACK +
Opcode.STLOC2 +
Opcode.LDLOC2 # a = [int_list, any_tuple, int_tuple]
+ Opcode.LDLOC1 + Opcode.LDLOC0 + Opcode.PUSH3 + Opcode.PACK +
Opcode.STLOC3 + Opcode.RET)
path = self.get_contract_path('SequenceOfAnyIntSequence.py')
output = self.assertCompilerLogs(CompilerWarning.TypeCasting, path)
self.assertEqual(expected_output, output)
