feat[lang]: add raw_create() builtin

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,116 @@ 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
+
+
+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

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,48 @@ def build_IR(self, expr, args, kwargs, context):
         )
 
 
+class RawCreate(_CreateBase):
+    _id = "raw_create"
+    _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)
+        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))
+
+        ret = ["seq"]
+
+        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=type_size_bound, returns_len=True
+            )
+            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))
+
+
 class CreateMinimalProxyTo(_CreateBase):
     # create an EIP1167 "minimal proxy" to the target contract
 
@@ -2683,6 +2726,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(),

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