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'
}
