def test_local_and_global_interface_namespaces(): interface_code = """ @public def foo() -> uint256: pass """ global_interface_codes = { "FooInterface": {"type": "vyper", "code": interface_code}, "BarInterface": {"type": "vyper", "code": interface_code}, } local_interface_codes = { "FooContract": {"FooInterface": {"type": "vyper", "code": interface_code}}, "BarContract": {"BarInterface": {"type": "vyper", "code": interface_code}}, } code = """ import a as {0} implements: {0} @public def foo() -> uint256: return 1 """ codes = {"FooContract": code.format("FooInterface"), "BarContract": code.format("BarInterface")} global_compiled = compile_codes(codes, interface_codes=global_interface_codes) local_compiled = compile_codes(codes, interface_codes=local_interface_codes) assert global_compiled == local_compiled
def test_local_and_global_interface_namespaces(): interface_code = """ @public def foo() -> uint256: pass """ global_interface_codes = { 'FooInterface': { 'type': 'vyper', 'code': interface_code }, 'BarInterface': { 'type': 'vyper', 'code': interface_code } } local_interface_codes = { 'FooContract': { 'FooInterface': { 'type': 'vyper', 'code': interface_code }, }, 'BarContract': { 'BarInterface': { 'type': 'vyper', 'code': interface_code } } } code = """ import a as {0} implements: {0} @public def foo() -> uint256: return 1 """ codes = { 'FooContract': code.format('FooInterface'), 'BarContract': code.format('BarInterface') } global_compiled = compile_codes(codes, interface_codes=global_interface_codes) local_compiled = compile_codes(codes, interface_codes=local_interface_codes) assert global_compiled == local_compiled
def test_external_interface_parsing(assert_compile_failed): interface_code = """ @public def foo() -> uint256: pass @public def bar() -> uint256: pass """ interface_codes = { 'FooBarInterface': { 'type': 'vyper', 'code': interface_code } } code = """ import a as FooBarInterface implements: FooBarInterface @public def foo() -> uint256: return 1 @public def bar() -> uint256: return 2 """ assert compile_codes({'one.vy': code}, interface_codes=interface_codes)[0] not_implemented_code = """ import a as FooBarInterface implements: FooBarInterface @public def foo() -> uint256: return 1 """ assert_compile_failed( lambda: compile_codes({'one.vy': not_implemented_code}, interface_codes=interface_codes)[0], StructureException)
def test_basic_extract_external_interface(): code = """ @constant @public def allowance(_owner: address, _spender: address) -> (uint256, uint256): return 1, 2 @public def test(_owner: address): pass @constant @private def _prive(_owner: address, _spender: address) -> (uint256, uint256): return 1, 2 """ interface = """ # External Contracts contract One: def allowance(_owner: address, _spender: address) -> (uint256, uint256): constant def test(_owner: address): modifying """ out = compile_codes({'one.vy': code}, ['external_interface'])[0] out = out['external_interface'] assert interface.strip() == out.strip()
def test_basic_extract_external_interface(): code = """ @view @external def allowance(_owner: address, _spender: address) -> (uint256, uint256): return 1, 2 @external def test(_owner: address): pass @view @internal def _prive(_owner: address, _spender: address) -> (uint256, uint256): return 1, 2 """ interface = """ # External Interfaces interface One: def allowance(_owner: address, _spender: address) -> (uint256, uint256): view def test(_owner: address): nonpayable """ out = compile_codes({"one.vy": code}, ["external_interface"])["one.vy"] out = out["external_interface"] assert interface.strip() == out.strip()
def test_keys(): compiler_data = compile_codes({'foo.vy': FOO_CODE}, output_formats=list(OUTPUT_FORMATS.keys())) output_json = format_to_output_dict(compiler_data) assert sorted(output_json.keys()) == ['compiler', 'contracts', 'sources'] assert output_json['compiler'] == f"vyper-{vyper.__version__}" data = compiler_data['foo.vy'] assert output_json['sources']['foo.vy'] == { 'id': 0, 'ast': data['ast_dict']['ast'] } assert output_json['contracts']['foo.vy']['foo'] == { 'abi': data['abi'], 'interface': data['interface'], 'ir': data['ir'], 'evm': { 'bytecode': { 'object': data['bytecode'], 'opcodes': data['opcodes'] }, 'deployedBytecode': { 'object': data['bytecode_runtime'], 'opcodes': data['opcodes_runtime'], 'sourceMap': data['source_map']['pc_pos_map_compressed'] }, 'methodIdentifiers': data['method_identifiers'], } }
def test_keys(): compiler_data = compile_codes({"foo.vy": FOO_CODE}, output_formats=list(OUTPUT_FORMATS.keys())) output_json = format_to_output_dict(compiler_data) assert sorted(output_json.keys()) == ["compiler", "contracts", "sources"] assert output_json["compiler"] == f"vyper-{vyper.__version__}" data = compiler_data["foo.vy"] assert output_json["sources"]["foo.vy"] == { "id": 0, "ast": data["ast_dict"]["ast"] } assert output_json["contracts"]["foo.vy"]["foo"] == { "abi": data["abi"], "devdoc": data["devdoc"], "interface": data["interface"], "ir": data["ir_dict"], "userdoc": data["userdoc"], "metadata": data["metadata"], "evm": { "bytecode": { "object": data["bytecode"], "opcodes": data["opcodes"] }, "deployedBytecode": { "object": data["bytecode_runtime"], "opcodes": data["opcodes_runtime"], "sourceMap": data["source_map"]["pc_pos_map_compressed"], }, "methodIdentifiers": data["method_identifiers"], }, }
def test_basic_interface_implements(assert_compile_failed): code = """ from vyper.interfaces import ERC20 implements: ERC20 @public def test() -> bool: return True """ assert_compile_failed(lambda: compile_codes({'one.vy': code}), StructureException)
def test_method_identifiers(): code = """ x: public(int128) @public def foo(x: uint256) -> bytes[100]: return b"hello" """ out = compile_codes(codes={'t.vy': code}, output_formats=['method_identifiers'], output_type='list')[0] assert out['method_identifiers'] == { 'foo(uint256)': '0x2fbebd38', 'x()': '0xc55699c' }