From af85a5c0153bcd81265702f98782f0b944f737f6 Mon Sep 17 00:00:00 2001 From: Charles Cooper Date: Thu, 8 Aug 2024 22:00:14 +0800 Subject: [PATCH 01/12] feat: implement raw_create --- vyper/builtins/functions.py | 43 +++++++++++++++++++++++++++++++++++++ vyper/utils.py | 3 +++ 2 files changed, 46 insertions(+) diff --git a/vyper/builtins/functions.py b/vyper/builtins/functions.py index 674efda7ce..ce4cb99882 100644 --- a/vyper/builtins/functions.py +++ b/vyper/builtins/functions.py @@ -88,6 +88,7 @@ from vyper.utils import ( DECIMAL_DIVISOR, EIP_170_LIMIT, + EIP_3860_LIMIT, SHA3_PER_WORD, MemoryPositions, bytes_to_int, @@ -1679,6 +1680,47 @@ def build_IR(self, expr, args, kwargs, context): ) +class RawCreate(_CreateBase): + _id = "create_minimal_proxy_to" + _inputs = [("bytecode", BytesT(EIP_3860_LIMIT))] + _has_varargs = True + + def _add_gas_estimate(self, args, should_use_create2): + return _create_addl_gas_estimate(EIP_170_LIMIT, should_use_create2) + + def _build_create_IR(self, expr, args, context, value, salt, revert_on_failure): + initcode = args[0] + ctor_args = args[1:] + + ctor_args = [ensure_in_memory(arg, context) for arg in ctor_args] + + # encode the varargs + to_encode = ir_tuple_from_args(ctor_args) + bufsz = initcode.typ.maxlen + to_encode.typ.abi_type.size_bound() + + buf = context.new_internal_variable(get_type_for_exact_size(bufsz)) + + ret = [] + + with scope_multi((initcode, value, salt), ("initcode", "value", "salt")) as ( + b1, + initcode, + value, + salt, + ): + bytecode_len = get_bytearray_length(initcode) + + maxlen = initcode.typ.maxlen + ret.append(copy_bytes(buf, bytes_data_ptr(initcode), bytecode_len, maxlen)) + + argbuf = add_ofst(buf, bytecode_len) + argslen = abi_encode(argbuf, to_encode, context, bufsz=bufsz, returns_len=True) + total_len = add_ofst(argbuf, argslen) + ret.append(_create_ir(value, buf, total_len, salt, revert_on_failure)) + + return b1.resolve(IRnode.from_list(ret)) + + class CreateMinimalProxyTo(_CreateBase): # create an EIP1167 "minimal proxy" to the target contract @@ -2683,6 +2725,7 @@ def _try_fold(self, node): "breakpoint": Breakpoint(), "selfdestruct": SelfDestruct(), "raw_call": RawCall(), + "raw_create": RawCreate(), "raw_log": RawLog(), "raw_revert": RawRevert(), "create_minimal_proxy_to": CreateMinimalProxyTo(), diff --git a/vyper/utils.py b/vyper/utils.py index 2b95485f4e..1ae7b38498 100644 --- a/vyper/utils.py +++ b/vyper/utils.py @@ -465,8 +465,11 @@ def quantize(d: decimal.Decimal, places=MAX_DECIMAL_PLACES, rounding_mode=decima EIP_170_LIMIT = 0x6000 # 24kb +EIP_3860_LIMIT = EIP_170_LIMIT * 2 ERC5202_PREFIX = b"\xFE\x71\x00" # default prefix from ERC-5202 +assert EIP_3860_LIMIT == 49152 # directly from the EIP + SHA3_BASE = 30 SHA3_PER_WORD = 6 From a4f2935abd2263358a1ec7b6e4b21aff4667ff33 Mon Sep 17 00:00:00 2001 From: Charles Cooper Date: Fri, 9 Aug 2024 18:50:27 +0800 Subject: [PATCH 02/12] add simple test --- .../builtins/codegen/test_create_functions.py | 37 +++++++++++++++++++ vyper/builtins/functions.py | 8 ++-- 2 files changed, 40 insertions(+), 5 deletions(-) diff --git a/tests/functional/builtins/codegen/test_create_functions.py b/tests/functional/builtins/codegen/test_create_functions.py index 19bea22a99..d0981576cc 100644 --- a/tests/functional/builtins/codegen/test_create_functions.py +++ b/tests/functional/builtins/codegen/test_create_functions.py @@ -6,6 +6,7 @@ import vyper.ir.compile_ir as compile_ir from tests.utils import ZERO_ADDRESS from vyper.codegen.ir_node import IRnode +from vyper.compiler import compile_code from vyper.compiler.settings import OptimizationLevel from vyper.utils import EIP_170_LIMIT, ERC5202_PREFIX, checksum_encode, keccak256 @@ -746,3 +747,39 @@ def test(target: address) -> address: c.test(c.address, value=2) test1 = c.address assert env.get_code(test1) == bytecode + + +def test_raw_create(get_contract, env): + to_deploy_code = """ +foo: public(uint256) + """ + + out = compile_code(to_deploy_code, output_formats=["bytecode", "bytecode_runtime"]) + initcode = bytes.fromhex(out["bytecode"].removeprefix("0x")) + runtime = bytes.fromhex(out["bytecode_runtime"].removeprefix("0x")) + + deployer_code = f""" +@external +def deploy_from_literal() -> address: + return raw_create({initcode}) + +@external +def deploy_from_calldata(s: Bytes[1024]) -> address: + return raw_create(s) + +@external +def deploy_from_memory() -> address: + s: Bytes[1024] = {initcode} + return raw_create(s) + """ + + deployer = get_contract(deployer_code) + + res = deployer.deploy_from_literal() + assert env.get_code(res) == runtime + + res = deployer.deploy_from_memory() + assert env.get_code(res) == runtime + + res = deployer.deploy_from_calldata(initcode) + assert env.get_code(res) == runtime diff --git a/vyper/builtins/functions.py b/vyper/builtins/functions.py index ce4cb99882..cb6b055f82 100644 --- a/vyper/builtins/functions.py +++ b/vyper/builtins/functions.py @@ -1681,7 +1681,7 @@ def build_IR(self, expr, args, kwargs, context): class RawCreate(_CreateBase): - _id = "create_minimal_proxy_to" + _id = "raw_create" _inputs = [("bytecode", BytesT(EIP_3860_LIMIT))] _has_varargs = True @@ -1700,13 +1700,11 @@ def _build_create_IR(self, expr, args, context, value, salt, revert_on_failure): buf = context.new_internal_variable(get_type_for_exact_size(bufsz)) - ret = [] + ret = ["seq"] with scope_multi((initcode, value, salt), ("initcode", "value", "salt")) as ( b1, - initcode, - value, - salt, + (initcode, value, salt), ): bytecode_len = get_bytearray_length(initcode) From dc3e377f18566f4915eb93cd9fc75fb710a24d16 Mon Sep 17 00:00:00 2001 From: cyberthirst Date: Tue, 13 Aug 2024 13:33:48 +0200 Subject: [PATCH 03/12] add tests for raw_create --- .../builtins/codegen/test_create_functions.py | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) diff --git a/tests/functional/builtins/codegen/test_create_functions.py b/tests/functional/builtins/codegen/test_create_functions.py index d0981576cc..e4bf78b680 100644 --- a/tests/functional/builtins/codegen/test_create_functions.py +++ b/tests/functional/builtins/codegen/test_create_functions.py @@ -783,3 +783,80 @@ def deploy_from_memory() -> address: res = deployer.deploy_from_calldata(initcode) assert env.get_code(res) == runtime + + +def test_raw_create_double_eval(get_contract, env): + to_deploy_code = """ +foo: public(uint256) + + +@deploy +def __init__(x: uint256): + self.foo = x + """ + + out = compile_code(to_deploy_code, output_formats=["bytecode", "bytecode_runtime"]) + initcode = bytes.fromhex(out["bytecode"].removeprefix("0x")) + runtime = bytes.fromhex(out["bytecode_runtime"].removeprefix("0x")) + + deployer_code = """ +interface Foo: + def foo() -> uint256: view + +a: DynArray[uint256, 10] +counter: public(uint256) + +@deploy +def __init__(): + self.a.append(1) + self.a.append(2) + +def get_index() -> uint256: + self.counter += 1 + return 0 + +@external +def deploy_from_calldata(s: Bytes[1024]) -> address: + res: address = raw_create(s, self.a[self.get_index()]) + assert staticcall Foo(res).foo() == 1 + return res + """ + + deployer = get_contract(deployer_code) + + res = deployer.deploy_from_calldata(initcode) + assert env.get_code(res) == runtime + + assert deployer.counter() == 1 + + +def test_raw_create_salt(get_contract, env, create2_address_of, keccak): + to_deploy_code = """ +foo: public(uint256) + +@deploy +def __init__(arg: uint256): + self.foo = arg + """ + + out = compile_code(to_deploy_code, output_formats=["bytecode", "bytecode_runtime"]) + initcode = bytes.fromhex(out["bytecode"].removeprefix("0x")) + runtime = bytes.fromhex(out["bytecode_runtime"].removeprefix("0x")) + + deployer_code = """ +@external +def deploy_from_calldata(s: Bytes[1024], arg: uint256, salt: bytes32) -> address: + return raw_create(s, arg, salt=salt) + """ + + deployer = get_contract(deployer_code) + + salt = keccak(b"vyper") + arg = 42 + res = deployer.deploy_from_calldata(initcode, arg, salt) + + initcode = initcode + abi.encode("(uint256)", (arg,)) + + assert HexBytes(res) == create2_address_of(deployer.address, salt, initcode) + + assert env.get_code(res) == runtime From 394b637dd7063217939907592c88c2a0a9fa5216 Mon Sep 17 00:00:00 2001 From: Charles Cooper Date: Tue, 27 Aug 2024 22:56:18 +0800 Subject: [PATCH 04/12] fix buf bound bug --- vyper/builtins/functions.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/vyper/builtins/functions.py b/vyper/builtins/functions.py index cb6b055f82..0550f260f2 100644 --- a/vyper/builtins/functions.py +++ b/vyper/builtins/functions.py @@ -1696,7 +1696,8 @@ def _build_create_IR(self, expr, args, context, value, salt, revert_on_failure): # encode the varargs to_encode = ir_tuple_from_args(ctor_args) - bufsz = initcode.typ.maxlen + to_encode.typ.abi_type.size_bound() + type_size_bound = to_encode.typ.abi_type.size_bound() + bufsz = initcode.typ.maxlen + type_size_bound buf = context.new_internal_variable(get_type_for_exact_size(bufsz)) @@ -1712,7 +1713,9 @@ def _build_create_IR(self, expr, args, context, value, salt, revert_on_failure): ret.append(copy_bytes(buf, bytes_data_ptr(initcode), bytecode_len, maxlen)) argbuf = add_ofst(buf, bytecode_len) - argslen = abi_encode(argbuf, to_encode, context, bufsz=bufsz, returns_len=True) + argslen = abi_encode( + argbuf, to_encode, context, bufsz=type_size_bound, returns_len=True + ) total_len = add_ofst(argbuf, argslen) ret.append(_create_ir(value, buf, total_len, salt, revert_on_failure)) From e7025ae4e025657407eafd4802c8ff3ef44217cd Mon Sep 17 00:00:00 2001 From: Charles Cooper Date: Tue, 27 Aug 2024 22:57:28 +0800 Subject: [PATCH 05/12] fix total_len --- vyper/builtins/functions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vyper/builtins/functions.py b/vyper/builtins/functions.py index 0550f260f2..8a68a1f2b1 100644 --- a/vyper/builtins/functions.py +++ b/vyper/builtins/functions.py @@ -1716,7 +1716,7 @@ def _build_create_IR(self, expr, args, context, value, salt, revert_on_failure): argslen = abi_encode( argbuf, to_encode, context, bufsz=type_size_bound, returns_len=True ) - total_len = add_ofst(argbuf, argslen) + total_len = add_ofst(bytecode_len, argslen) ret.append(_create_ir(value, buf, total_len, salt, revert_on_failure)) return b1.resolve(IRnode.from_list(ret)) From 2870bd94ef8a5820122493400c920bf864459a5f Mon Sep 17 00:00:00 2001 From: cyberthirst Date: Wed, 4 Sep 2024 14:44:02 +0200 Subject: [PATCH 06/12] add tests for raw_create --- .../builtins/codegen/test_create_functions.py | 100 ++++++++++++++++++ 1 file changed, 100 insertions(+) diff --git a/tests/functional/builtins/codegen/test_create_functions.py b/tests/functional/builtins/codegen/test_create_functions.py index e4bf78b680..c63ea2af1b 100644 --- a/tests/functional/builtins/codegen/test_create_functions.py +++ b/tests/functional/builtins/codegen/test_create_functions.py @@ -860,3 +860,103 @@ def deploy_from_calldata(s: Bytes[1024], arg: uint256, salt: bytes32) -> address assert HexBytes(res) == create2_address_of(deployer.address, salt, initcode) assert env.get_code(res) == runtime + + +def test_raw_create_value(get_contract, env): + value = 1 + to_deploy_code = f""" +foo: public(uint256) + +@deploy +@payable +def __init__(): + assert msg.value == {value} + """ + + out = compile_code(to_deploy_code, output_formats=["bytecode", "bytecode_runtime"]) + initcode = bytes.fromhex(out["bytecode"].removeprefix("0x")) + runtime = bytes.fromhex(out["bytecode_runtime"].removeprefix("0x")) + + deployer_code = f""" +@external +def deploy() -> address: + return raw_create({initcode}, value={value}) + """ + + deployer = get_contract(deployer_code) + + env.set_balance(deployer.address, value) + + res = deployer.deploy() + assert env.get_code(res) == runtime + + +@pytest.mark.parametrize("constructor_reverts", [True, False]) +@pytest.mark.parametrize("revert_on_failure", [True, False]) +def test_raw_create_revert_on_failure( + get_contract, env, tx_failed, constructor_reverts, revert_on_failure +): + to_deploy_code = """ +foo: public(uint256) + +@deploy +@payable +def __init__(constructor_reverts: bool): + assert not constructor_reverts + """ + + out = compile_code(to_deploy_code, output_formats=["bytecode", "bytecode_runtime"]) + initcode = bytes.fromhex(out["bytecode"].removeprefix("0x")) + initcode += abi.encode("(uint8)", (constructor_reverts,)) + runtime = bytes.fromhex(out["bytecode_runtime"].removeprefix("0x")) + + deployer_code = f""" +@external +def deploy() -> address: + return raw_create({initcode}, revert_on_failure={revert_on_failure}) + """ + + deployer = get_contract(deployer_code) + + if revert_on_failure and constructor_reverts: + with tx_failed(): + deployer.deploy() + else: + res = deployer.deploy() + if constructor_reverts: + assert res == ZERO_ADDRESS + assert env.get_code(res) == b"" + else: + assert env.get_code(res) == runtime + + +def test_raw_create_dynamic_arg(get_contract, env): + array = [1, 2, 3] + + to_deploy_code = """ +foo: public(uint256) + +@deploy +@payable +def __init__(a: DynArray[uint256, 10]): + for i: uint256 in range(1, 4): + assert a[i - 1] == i + """ + + out = compile_code(to_deploy_code, output_formats=["bytecode", "bytecode_runtime"]) + initcode = bytes.fromhex(out["bytecode"].removeprefix("0x")) + initcode += abi.encode("(uint256[])", (array,)) + runtime = bytes.fromhex(out["bytecode_runtime"].removeprefix("0x")) + + deployer_code = f""" +@external +def deploy() -> address: + a: DynArray[uint256, 10] = {array} + return raw_create({initcode}, a) + """ + + deployer = get_contract(deployer_code) + + res = deployer.deploy() + + assert env.get_code(res) == runtime From 513de70651e34ec86945d4c6f3eb22d7e951bec1 Mon Sep 17 00:00:00 2001 From: cyberthirst Date: Wed, 4 Sep 2024 15:02:50 +0200 Subject: [PATCH 07/12] merge value and revert tests --- .../builtins/codegen/test_create_functions.py | 51 +++++++------------ 1 file changed, 17 insertions(+), 34 deletions(-) diff --git a/tests/functional/builtins/codegen/test_create_functions.py b/tests/functional/builtins/codegen/test_create_functions.py index c63ea2af1b..a252b6dcad 100644 --- a/tests/functional/builtins/codegen/test_create_functions.py +++ b/tests/functional/builtins/codegen/test_create_functions.py @@ -862,47 +862,22 @@ def deploy_from_calldata(s: Bytes[1024], arg: uint256, salt: bytes32) -> address assert env.get_code(res) == runtime -def test_raw_create_value(get_contract, env): - value = 1 - to_deploy_code = f""" -foo: public(uint256) - -@deploy -@payable -def __init__(): - assert msg.value == {value} - """ - - out = compile_code(to_deploy_code, output_formats=["bytecode", "bytecode_runtime"]) - initcode = bytes.fromhex(out["bytecode"].removeprefix("0x")) - runtime = bytes.fromhex(out["bytecode_runtime"].removeprefix("0x")) - - deployer_code = f""" -@external -def deploy() -> address: - return raw_create({initcode}, value={value}) - """ - - deployer = get_contract(deployer_code) - - env.set_balance(deployer.address, value) - - res = deployer.deploy() - assert env.get_code(res) == runtime - - @pytest.mark.parametrize("constructor_reverts", [True, False]) -@pytest.mark.parametrize("revert_on_failure", [True, False]) +@pytest.mark.parametrize("use_value", [True, False]) +@pytest.mark.parametrize("revert_on_failure", [True, False, None]) def test_raw_create_revert_on_failure( - get_contract, env, tx_failed, constructor_reverts, revert_on_failure + get_contract, env, tx_failed, constructor_reverts, revert_on_failure, use_value ): - to_deploy_code = """ + value = 1 + value_assert = f"assert msg.value == {value}" if use_value else "" + to_deploy_code = f""" foo: public(uint256) @deploy @payable def __init__(constructor_reverts: bool): assert not constructor_reverts + {value_assert} """ out = compile_code(to_deploy_code, output_formats=["bytecode", "bytecode_runtime"]) @@ -910,15 +885,23 @@ def __init__(constructor_reverts: bool): initcode += abi.encode("(uint8)", (constructor_reverts,)) runtime = bytes.fromhex(out["bytecode_runtime"].removeprefix("0x")) + value_kw = f", value={value}" if use_value else "" + revert_kw = f", revert_on_failure={revert_on_failure}" if revert_on_failure is not None else "" deployer_code = f""" @external def deploy() -> address: - return raw_create({initcode}, revert_on_failure={revert_on_failure}) + return raw_create({initcode}{revert_kw}{value_kw}) """ deployer = get_contract(deployer_code) + env.set_balance(deployer.address, value) - if revert_on_failure and constructor_reverts: + if ( + revert_on_failure + and constructor_reverts + or revert_on_failure is None + and constructor_reverts + ): with tx_failed(): deployer.deploy() else: From f77c64a8f82cd668156f1e17ae67b8c4a86648ba Mon Sep 17 00:00:00 2001 From: cyberthirst Date: Wed, 4 Sep 2024 15:03:51 +0200 Subject: [PATCH 08/12] rename test --- tests/functional/builtins/codegen/test_create_functions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/functional/builtins/codegen/test_create_functions.py b/tests/functional/builtins/codegen/test_create_functions.py index a252b6dcad..b56e6482db 100644 --- a/tests/functional/builtins/codegen/test_create_functions.py +++ b/tests/functional/builtins/codegen/test_create_functions.py @@ -865,7 +865,7 @@ def deploy_from_calldata(s: Bytes[1024], arg: uint256, salt: bytes32) -> address @pytest.mark.parametrize("constructor_reverts", [True, False]) @pytest.mark.parametrize("use_value", [True, False]) @pytest.mark.parametrize("revert_on_failure", [True, False, None]) -def test_raw_create_revert_on_failure( +def test_raw_create_revert_value_kws( get_contract, env, tx_failed, constructor_reverts, revert_on_failure, use_value ): value = 1 From 961c406d441148e87686643c160c1bdfd9e9328b Mon Sep 17 00:00:00 2001 From: cyberthirst Date: Mon, 16 Sep 2024 20:22:19 +0200 Subject: [PATCH 09/12] encode args within raw_create --- tests/functional/builtins/codegen/test_create_functions.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tests/functional/builtins/codegen/test_create_functions.py b/tests/functional/builtins/codegen/test_create_functions.py index b56e6482db..6945b70b1a 100644 --- a/tests/functional/builtins/codegen/test_create_functions.py +++ b/tests/functional/builtins/codegen/test_create_functions.py @@ -882,7 +882,6 @@ def __init__(constructor_reverts: bool): out = compile_code(to_deploy_code, output_formats=["bytecode", "bytecode_runtime"]) initcode = bytes.fromhex(out["bytecode"].removeprefix("0x")) - initcode += abi.encode("(uint8)", (constructor_reverts,)) runtime = bytes.fromhex(out["bytecode_runtime"].removeprefix("0x")) value_kw = f", value={value}" if use_value else "" @@ -890,7 +889,7 @@ def __init__(constructor_reverts: bool): deployer_code = f""" @external def deploy() -> address: - return raw_create({initcode}{revert_kw}{value_kw}) + return raw_create({initcode},{constructor_reverts}{revert_kw}{value_kw}) """ deployer = get_contract(deployer_code) @@ -928,7 +927,6 @@ def __init__(a: DynArray[uint256, 10]): out = compile_code(to_deploy_code, output_formats=["bytecode", "bytecode_runtime"]) initcode = bytes.fromhex(out["bytecode"].removeprefix("0x")) - initcode += abi.encode("(uint256[])", (array,)) runtime = bytes.fromhex(out["bytecode_runtime"].removeprefix("0x")) deployer_code = f""" From 26698e6d04136e8b3706d0126ea3f97aed556dac Mon Sep 17 00:00:00 2001 From: cyberthirst Date: Mon, 16 Sep 2024 20:25:46 +0200 Subject: [PATCH 10/12] simplify revert condition --- .../builtins/codegen/test_create_functions.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/tests/functional/builtins/codegen/test_create_functions.py b/tests/functional/builtins/codegen/test_create_functions.py index 6945b70b1a..ad1097e5c8 100644 --- a/tests/functional/builtins/codegen/test_create_functions.py +++ b/tests/functional/builtins/codegen/test_create_functions.py @@ -895,12 +895,9 @@ def deploy() -> address: deployer = get_contract(deployer_code) env.set_balance(deployer.address, value) - if ( - revert_on_failure - and constructor_reverts - or revert_on_failure is None - and constructor_reverts - ): + expect_revert = constructor_reverts and revert_on_failure in (True, None) + + if expect_revert: with tx_failed(): deployer.deploy() else: @@ -912,6 +909,8 @@ def deploy() -> address: assert env.get_code(res) == runtime +# test that raw_create correctly interfaces with the abi encoder +# and can handle dynamic arguments def test_raw_create_dynamic_arg(get_contract, env): array = [1, 2, 3] From 49ccb9bf7a25394683a6c58c6cac3f7ebf6d1af2 Mon Sep 17 00:00:00 2001 From: cyberthirst Date: Mon, 16 Sep 2024 20:29:32 +0200 Subject: [PATCH 11/12] add comment --- tests/functional/builtins/codegen/test_create_functions.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/functional/builtins/codegen/test_create_functions.py b/tests/functional/builtins/codegen/test_create_functions.py index ad1097e5c8..77e96970a1 100644 --- a/tests/functional/builtins/codegen/test_create_functions.py +++ b/tests/functional/builtins/codegen/test_create_functions.py @@ -862,6 +862,8 @@ def deploy_from_calldata(s: Bytes[1024], arg: uint256, salt: bytes32) -> address assert env.get_code(res) == runtime +# test raw_create with all combinations of value and revert_on_failure kwargs (including not present at all) +# additionally parametrize whether the constructor reverts or not @pytest.mark.parametrize("constructor_reverts", [True, False]) @pytest.mark.parametrize("use_value", [True, False]) @pytest.mark.parametrize("revert_on_failure", [True, False, None]) From c25430a9ca3be1b55a3e686f2b768f47180a33ef Mon Sep 17 00:00:00 2001 From: Charles Cooper Date: Wed, 18 Sep 2024 08:28:06 -0400 Subject: [PATCH 12/12] fix lint --- tests/functional/builtins/codegen/test_create_functions.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/functional/builtins/codegen/test_create_functions.py b/tests/functional/builtins/codegen/test_create_functions.py index 77e96970a1..e7a80fcedf 100644 --- a/tests/functional/builtins/codegen/test_create_functions.py +++ b/tests/functional/builtins/codegen/test_create_functions.py @@ -862,7 +862,8 @@ def deploy_from_calldata(s: Bytes[1024], arg: uint256, salt: bytes32) -> address assert env.get_code(res) == runtime -# test raw_create with all combinations of value and revert_on_failure kwargs (including not present at all) +# test raw_create with all combinations of value and revert_on_failure kwargs +# (including not present at all) # additionally parametrize whether the constructor reverts or not @pytest.mark.parametrize("constructor_reverts", [True, False]) @pytest.mark.parametrize("use_value", [True, False])