Add create2 Yul primitive and test

Author: smoelius

integration/stylus/create2.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity >=0.8.0;
+
+interface ArbWasm {
+    /// @notice Activate a wasm program
+    /// @param program the program to activate
+    /// @return version the stylus version the program was activated against
+    /// @return dataFee the data fee paid to store the activated program
+    function activateProgram(
+        address program
+    ) external payable returns (uint16 version, uint256 dataFee);
+}
+
+contract C {
+    function test_create2() public payable {
+        Greeter greeter = new Greeter();
+        print("greeter = {}".format(address(greeter)));
+
+        ArbWasm arbWasm = ArbWasm(address(0x71));
+        (uint16 version, uint256 dataFee) = arbWasm.activateProgram{
+            value: msg.value
+        }(address(greeter));
+        print("version = {}".format(version));
+        print("dataFee = {}".format(dataFee));
+
+        greeter.greet();
+
+        bytes initCode = contractDeploymentCalldata(address(greeter).code);
+        print("initCode = {}".format(initCode));
+
+        Greeter greeter0;
+        assembly {
+            greeter0 := create2(
+                0,
+                initCode,
+                0, // codeLen - ignored
+                0 // salt
+            )
+        }
+        print("greeter0 = {}".format(address(greeter0)));
+        greeter0.greet();
+
+        Greeter greeter1;
+        assembly {
+            greeter1 := create2(
+                0,
+                initCode,
+                0, // codeLen - ignored
+                1 // salt
+            )
+        }
+        print("greeter1 = {}".format(address(greeter1)));
+        greeter1.greet();
+    }
+}
+
+contract Greeter {
+    function greet() public view {
+        print("Greetings from 0x{}!".format(this));
+    }
+}
+
+function contractDeploymentCalldata(bytes code) pure returns (bytes) {
+    bytes memory deploy;
+    uint256 codeLen = code.length;
+    deploy.push(0x7f); // PUSH32
+    deploy = pushBytes(deploy, bytes32(codeLen));
+    deploy.push(0x80); // DUP1
+    deploy.push(0x60); // PUSH1
+    deploy.push(43); // prelude + version
+    deploy.push(0x60); // PUSH1
+    deploy.push(0x00);
+    deploy.push(0x39); // CODECOPY
+    deploy.push(0x60); // PUSH1
+    deploy.push(0x00);
+    deploy.push(0xf3); // RETURN
+    deploy.push(0x00); // version
+    deploy = pushBytes(deploy, code);
+    return deploy;
+}
+
+function pushBytes(bytes memory xs, bytes memory ys) pure returns (bytes) {
+    uint256 n = ys.length;
+    for (uint256 i = 0; i < n; i++) {
+        xs.push(ys[i]);
+    }
+    return xs;
+}

src/codegen/mod.rs

@@ -1808,6 +1808,7 @@ pub enum Builtin {
     ChainId,
     ContractCode,
     ContractCodehash,
+    Create2,
     Gasleft,
     GasLimit,
     Gasprice,

src/codegen/yul/builtin.rs

@@ -117,7 +117,6 @@ pub(crate) fn process_builtin(
         | YulBuiltInFunction::ReturnDataCopy
         // Functions that manage contracts
         | YulBuiltInFunction::Create
-        | YulBuiltInFunction::Create2
         | YulBuiltInFunction::Call
         | YulBuiltInFunction::CallCode
         | YulBuiltInFunction::DelegateCall
@@ -144,6 +143,14 @@ pub(crate) fn process_builtin(
             Expression::Poison
         }
 
+        YulBuiltInFunction::Create2 => {
+            let value = expression(&args[0], contract_no, ns, vartab, cfg, opt);
+            let code = expression(&args[1], contract_no, ns, vartab, cfg, opt);
+            let code_len = expression(&args[2], contract_no, ns, vartab, cfg, opt);
+            let salt = expression(&args[3], contract_no, ns, vartab, cfg, opt);
+            Expression::Builtin { loc: *loc, tys: vec![Type::Address(false)], kind: Builtin::Create2, args: vec![value, code, code_len, salt] }
+        }
+
         YulBuiltInFunction::Origin => {
             Expression::Builtin { loc: *loc, tys: vec![Type::Address(false)], kind: Builtin::Origin, args: vec![] }
         }

src/emit/stylus/target.rs

@@ -864,6 +864,7 @@ impl<'a> TargetRuntime<'a> for StylusTarget {
     }
 
     /// builtin expressions
+    #[warn(unused_variables)]
     fn builtin<'b>(
         &self,
         bin: &Binary<'b>,
@@ -1056,6 +1057,65 @@ impl<'a> TargetRuntime<'a> for StylusTarget {
                 .left()
                 .unwrap()
             }
+            Expression::Builtin {
+                kind: Builtin::Create2,
+                args,
+                ..
+            } => {
+                let [value, code, code_len, salt] = args.as_slice() else {
+                    panic!()
+                };
+
+                let value = expression(self, bin, value, vartab, function);
+                let code = expression(self, bin, code, vartab, function);
+                // smoelius: `code_len` is ignored.
+                let _code_len = expression(self, bin, code_len, vartab, function);
+                let salt = expression(self, bin, salt, vartab, function);
+
+                let code_ptr = bin.vector_bytes(code);
+
+                let code_len = bin.vector_len(code);
+
+                let value_ptr = bin
+                    .builder
+                    .build_alloca(bin.value_type(), "value_ptr")
+                    .unwrap();
+                bin.builder.build_store(value_ptr, value).unwrap();
+
+                let salt_buf = bin.builder.build_alloca(bin.value_type(), "salt").unwrap();
+                bin.builder.build_store(salt_buf, salt).unwrap();
+
+                let address = bin
+                    .builder
+                    .build_array_alloca(
+                        bin.context.i8_type(),
+                        i32_const!(bin.ns.address_length as u64),
+                        "address",
+                    )
+                    .unwrap();
+
+                let revert_data_len = bin
+                    .builder
+                    .build_alloca(bin.llvm_type(&ast::Type::Uint(32)), "revert_data_len")
+                    .unwrap();
+
+                call!(
+                    "create2",
+                    &[
+                        code_ptr.into(),
+                        code_len.into(),
+                        value_ptr.into(),
+                        salt_buf.into(),
+                        address.into(),
+                        revert_data_len.into()
+                    ],
+                    "create2"
+                );
+
+                bin.builder
+                    .build_load(bin.address_type(), address, "address")
+                    .unwrap()
+            }
             Expression::Builtin {
                 kind: Builtin::Gasleft,
                 ..

tests/stylus_tests/create2.rs

@@ -0,0 +1,37 @@
+//! This test expects you to have a devnode running:
+//! <https://docs.arbitrum.io/run-arbitrum-node/run-nitro-dev-node>
+//!
+//! It also expects `cargo-stylus` and `cast` to be installed:
+//! - <https://github.com/OffchainLabs/cargo-stylus>
+//! - <https://book.getfoundry.sh/cast/>
+#![warn(clippy::pedantic)]
+
+use crate::{deploy, send, MUTEX};
+use std::{io::Write, path::PathBuf};
+
+#[test]
+fn create2() {
+    writeln!(
+        std::io::stderr(),
+        "If you run the `create2` test twice, it will fail the second time because the \
+         contract `Greeter` cannot be activated twice.",
+    )
+    .unwrap();
+
+    let _lock = MUTEX.lock();
+    let (tempdir, address) = deploy(
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("integration/stylus/create2.sol"),
+        "C",
+        true,
+    )
+    .unwrap();
+    let dir = &tempdir;
+
+    let stdout = send(
+        dir,
+        &address,
+        ["test_create2()", "--value=1000000000000000000"],
+    )
+    .unwrap();
+    println!("{}", stdout);
+}

tests/stylus_tests/mod.rs

@@ -1,6 +1,7 @@
 mod api;
 mod arb_wasm;
 mod counter;
+mod create2;
 mod milestone_1;
 mod milestone_2;
 mod milestone_3;