Expand milestone_2 test

Author: smoelius

Cargo.toml

@@ -72,6 +72,8 @@ solang-forge-fmt = { version = "0.2.0", optional = true }
 # build to work.
 ethers-core = { version = "2.0.10", optional = true }
 soroban-sdk = { version = "23.0.0-rc.2.2", features = ["testutils"], optional = true }
+anyhow = "1.0"
+brotli2 = "0.3"
 
 [dev-dependencies]
 num-derive = "0.4"
@@ -93,7 +95,6 @@ ink_primitives = "5.0.0"
 wasm_host_attr = { path = "tests/wasm_host_attr" }
 num-bigint = { version = "0.4", features = ["rand", "serde"]}
 strip-ansi-escapes = "0.2"
-anyhow = "1.0"
 
 
 [package.metadata.docs.rs]

integration/stylus/milestone_2.sol

@@ -1,10 +1,14 @@
 // SPDX-License-Identifier: UNLICENSED
 pragma solidity >=0.8.0;
 
-contract T {
-    function test() public view returns (uint256) {
-        return 1;
-    }
+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 {
@@ -44,4 +48,24 @@ contract C {
         }
         return (a, b);
     }
+
+    function test3() 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();
+    }
+}
+
+contract Greeter {
+    function greet() public view {
+        print("Hello from 0x{}!".format(this));
+    }
 }

src/emit/stylus/cargo_stylus.rs

@@ -0,0 +1,55 @@
+//! This file contains two functions similar to ones from `cargo-stylus`'s codebase, which is
+//! distributed under the terms of both the MIT license and the Apache License (Version 2.0).
+
+use anyhow::Context;
+
+// smoelius: `compress_wasm` is based on the function of the same name here:
+// https://github.com/OffchainLabs/cargo-stylus/blob/5c520876d54594d9ca93cf017cb966075b4f4ca5/main/src/project.rs#L381
+pub fn compress_wasm(wasm: &[u8]) -> anyhow::Result<(Vec<u8>, Vec<u8>)> {
+    use brotli2::read::BrotliEncoder;
+    use std::io::Read;
+
+    /// Maximum brotli compression level used for Stylus contracts.
+    const BROTLI_COMPRESSION_LEVEL: u32 = 11;
+
+    /// EOF prefix used in Stylus compressed WASMs on-chain
+    const EOF_PREFIX_NO_DICT: &str = "EFF00000";
+
+    let mut compressor = BrotliEncoder::new(&*wasm, BROTLI_COMPRESSION_LEVEL);
+    let mut compressed_bytes = vec![];
+    compressor
+        .read_to_end(&mut compressed_bytes)
+        .context("failed to compress WASM bytes")?;
+
+    let mut contract_code = hex::decode(EOF_PREFIX_NO_DICT).unwrap();
+    contract_code.extend(compressed_bytes);
+
+    Ok((wasm.to_vec(), contract_code))
+}
+
+// smoelius: `contract_deployment_calldata` is based on the function of the same name here:
+// https://github.com/OffchainLabs/cargo-stylus/blob/5c520876d54594d9ca93cf017cb966075b4f4ca5/main/src/deploy/mod.rs#L305
+pub fn contract_deployment_calldata(code: &[u8]) -> Vec<u8> {
+    let code_len: [u8; 32] = u256_from_usize(code.len());
+    let mut deploy: Vec<u8> = vec![];
+    deploy.push(0x7f); // PUSH32
+    deploy.extend(code_len);
+    deploy.push(0x80); // DUP1
+    deploy.push(0x60); // PUSH1
+    deploy.push(42 + 1); // 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.extend(code);
+    deploy
+}
+
+fn u256_from_usize(x: usize) -> [u8; 32] {
+    let mut bytes = [0u8; 32];
+    bytes[32 - std::mem::size_of_val(&x)..].copy_from_slice(&x.to_be_bytes());
+    bytes
+}

src/emit/stylus/mod.rs

@@ -11,6 +11,7 @@ use inkwell::module::{Linkage, Module};
 use inkwell::values::{BasicMetadataValueEnum, BasicValue, FunctionValue, IntValue, PointerValue};
 use inkwell::AddressSpace;
 
+mod cargo_stylus;
 mod storage;
 mod target;
 

src/emit/stylus/target.rs

@@ -675,7 +675,14 @@ impl<'a> TargetRuntime<'a> for StylusTarget {
 
         let created_contract = &bin.ns.contracts[contract_no];
 
-        let code = created_contract.emit(bin.ns, bin.options, contract_no);
+        let code_without_metadata_uncompressed =
+            created_contract.emit(bin.ns, bin.options, contract_no);
+
+        let (_, code_without_metadata) =
+            super::cargo_stylus::compress_wasm(&code_without_metadata_uncompressed)
+                .expect("failed to compress wasm");
+
+        let code = super::cargo_stylus::contract_deployment_calldata(&code_without_metadata);
 
         let code_ptr =
             bin.emit_global_string(&format!("binary_{}_code", created_contract.id), &code, true);
@@ -730,7 +737,7 @@ impl<'a> TargetRuntime<'a> for StylusTarget {
             let zero_ptr = bin.build_alloca(function, bin.address_type(), "zero_ptr");
 
             bin.builder.build_store(zero_ptr, zero_address).unwrap();
-            let cmp_result = bin
+            let is_zero = bin
                 .builder
                 .build_call(
                     bin.module.get_function("__memcmp").unwrap(),
@@ -755,25 +762,10 @@ impl<'a> TargetRuntime<'a> for StylusTarget {
                 .into_int_value();
 
             // __memcmp returns true (1) if memory regions are equal, false (0) if not equal
-            // We want success to be 0 if address equals zero (creation failed), 1 if address is non-zero (creation succeeded)
-            // So we need to invert the result: if __memcmp returns 1 (equal), we want success to be 0 (failure)
-            let success_value = bin
-                .builder
-                .build_select(
-                    bin.builder
-                        .build_int_compare(
-                            IntPredicate::EQ,
-                            cmp_result,
-                            bin.context.bool_type().const_int(1, false),
-                            "address_is_zero",
-                        )
-                        .unwrap(),
-                    bin.context.i32_type().const_zero(),
-                    bin.context.i32_type().const_int(1, false),
-                    "success_value",
-                )
-                .unwrap();
-            *success = success_value.into();
+            // We want success to be 1 if address equals zero (creation failed), 0 if address is non-zero (creation succeeded)
+            // So we can use the __memcmp result directly.
+
+            *success = is_zero.into();
         }
     }
 

tests/stylus_tests/milestone_2.rs

@@ -6,11 +6,18 @@
 //! - <https://book.getfoundry.sh/cast/>
 #![warn(clippy::pedantic)]
 
-use crate::{call, deploy, MUTEX};
-use std::path::PathBuf;
+use crate::{call, deploy, send, MUTEX};
+use std::{io::Write, path::PathBuf};
 
 #[test]
 fn milestone_2() {
+    writeln!(
+        std::io::stderr(),
+        "If you run the `milestone_2` 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/milestone_2.sol"),
@@ -30,6 +37,9 @@ fn milestone_2() {
 
     stdout = call(dir, &address, ["test2()(uint256,uint256)"]).unwrap();
     println!("{}", stdout);
+
+    stdout = send(dir, &address, ["test3()", "--value=1000000000000000000"]).unwrap();
+    println!("{}", stdout);
 }
 
 fn label(stdout: &str) -> String {