Merge pull request #14 from paritytech/sm/fix

Add support for args in constructors

Author: smiasojed

Cargo.lock

@@ -16,7 +16,36 @@ impl CastClient {
     }
 
     /// Deploy a contract and return the contract address.
-    pub fn deploy(&self, bytecode_hex: &str, private_key: &str) -> String {
+    /// If `constructor_sig` is non-empty, ABI-encodes `args` and appends them to the bytecode.
+    pub fn deploy(
+        &self,
+        bytecode_hex: &str,
+        constructor_sig: &str,
+        args: &[&str],
+        private_key: &str,
+    ) -> String {
+        let bytecode = if !constructor_sig.is_empty() {
+            let mut cmd = Command::new("cast");
+            cmd.args(["abi-encode", constructor_sig]);
+            for arg in args {
+                cmd.arg(arg);
+            }
+            let output = cmd.output().expect("cast abi-encode failed to execute");
+            assert!(
+                output.status.success(),
+                "cast abi-encode failed: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+            let encoded_args = String::from_utf8(output.stdout)
+                .unwrap()
+                .trim()
+                .trim_start_matches("0x")
+                .to_string();
+            format!("{bytecode_hex}{encoded_args}")
+        } else {
+            bytecode_hex.to_string()
+        };
+
         let output = Command::new("cast")
             .args([
                 "send",
@@ -28,7 +57,7 @@ impl CastClient {
                 "9999999999999",
                 "--json",
                 "--create",
-                bytecode_hex,
+                &bytecode,
             ])
             .output()
             .expect("cast send --create failed to execute");

crates/pvm-contract-e2e-tests/src/cast.rs

@@ -30,7 +30,7 @@ fn deploy_variant(variant: &str) -> (AnvilPolkadot, CastClient, String) {
     let anvil = AnvilPolkadot::start();
     let cast = CastClient::new(&anvil.rpc_url);
     let hex = c.bytecode_hex(variant, "release");
-    let address = cast.deploy(&hex, DEFAULT_PRIVATE_KEY);
+    let address = cast.deploy(&hex, "", &[], DEFAULT_PRIVATE_KEY);
     (anvil, cast, address)
 }
 
@@ -88,7 +88,7 @@ fn dispatch_fallback_handles_unknown_selector() {
     let anvil = AnvilPolkadot::start();
     let cast = CastClient::new(&anvil.rpc_url);
     let hex = c.bytecode_hex(DEFAULT_VARIANT, "release");
-    let address = cast.deploy(&hex, DEFAULT_PRIVATE_KEY);
+    let address = cast.deploy(&hex, "", &[], DEFAULT_PRIVATE_KEY);
 
     // 0xdeadbeef is not a known selector — fallback should handle it
     let mut cmd = std::process::Command::new("cast");

crates/pvm-contract-e2e-tests/tests/e2e_tests.rs

@@ -8,7 +8,7 @@ fn deploy(binary_name: &str) -> (AnvilPolkadot, CastClient, String) {
     let anvil = AnvilPolkadot::start();
     let cast = CastClient::new(&anvil.rpc_url);
     let hex = c.bytecode_hex(binary_name, "release");
-    let address = cast.deploy(&hex, DEFAULT_PRIVATE_KEY);
+    let address = cast.deploy(&hex, "", &[], DEFAULT_PRIVATE_KEY);
     (anvil, cast, address)
 }
 
@@ -384,3 +384,65 @@ fn composite_tuple_false() {
     );
     assert_eq!(val, "0");
 }
+
+// --- Constructor Arguments ---
+
+fn deploy_constructor_args(owner: &str, supply: &str) -> (AnvilPolkadot, CastClient, String) {
+    let c = contract("test-contracts");
+    c.build();
+    let anvil = AnvilPolkadot::start();
+    let cast = CastClient::new(&anvil.rpc_url);
+    let hex = c.bytecode_hex("constructor-args", "release");
+    let address = cast.deploy(
+        &hex,
+        "constructor(address,uint256)",
+        &[owner, supply],
+        DEFAULT_PRIVATE_KEY,
+    );
+    (anvil, cast, address)
+}
+
+#[test]
+fn constructor_args_sets_owner_and_supply() {
+    let owner = DEFAULT_ADDRESS;
+    let supply = "1000000";
+    let (_anvil, cast, addr) = deploy_constructor_args(owner, supply);
+
+    let got_owner = cast.call(&addr, "getOwner()(address)", &[]);
+    assert_eq!(
+        got_owner.to_lowercase(),
+        owner.to_lowercase(),
+        "Constructor should set owner"
+    );
+
+    let got_supply = cast.call(&addr, "getInitialSupply()(uint256)", &[]);
+    assert_eq!(got_supply, supply, "Constructor should set initial supply");
+}
+
+#[test]
+fn constructor_args_different_values() {
+    let owner = "0x70997970C51812dc3A010C7d01b50e0d17dc79C8";
+    let supply = "999";
+    let (_anvil, cast, addr) = deploy_constructor_args(owner, supply);
+
+    let got_owner = cast.call(&addr, "getOwner()(address)", &[]);
+    assert_eq!(
+        got_owner.to_lowercase(),
+        owner.to_lowercase(),
+        "Constructor should set different owner"
+    );
+
+    let got_supply = cast.call(&addr, "getInitialSupply()(uint256)", &[]);
+    assert_eq!(
+        got_supply, supply,
+        "Constructor should set different supply"
+    );
+}
+
+#[test]
+fn constructor_args_zero_supply() {
+    let (_anvil, cast, addr) = deploy_constructor_args(DEFAULT_ADDRESS, "0");
+
+    let got_supply = cast.call(&addr, "getInitialSupply()(uint256)", &[]);
+    assert_eq!(got_supply, "0", "Constructor should handle zero supply");
+}

crates/pvm-contract-e2e-tests/tests/integration_tests.rs

@@ -22,4 +22,5 @@ pvm-contract-types = { path = "../pvm-contract-types" }
 
 [dev-dependencies]
 ruint = { version = "1.17", default-features = false }
+serde_json = { workspace = true }
 pvm-contract-types = { path = "../pvm-contract-types", features = ["alloc"] }

crates/pvm-contract-macros/Cargo.toml

@@ -38,13 +38,37 @@ fn generate_abi_gen_main_impl(parsed: &ParsedContract) -> syn::Result<TokenStrea
     };
 
     let constructor_entry = if parsed.has_constructor {
+        let constructor_input_entries: Vec<TokenStream> = parsed
+            .constructor_inputs
+            .iter()
+            .map(|(name, sol_type)| {
+                let name_str = name.to_string();
+                let type_name_expr = generate_sol_type_name_expr(sol_type)?;
+                Ok(quote! {
+                    if !__first_ctor_input {
+                        __abi.push(',');
+                    } else {
+                        __first_ctor_input = false;
+                    }
+                    __abi.push_str("{\"name\":\"");
+                    __abi.push_str(#name_str);
+                    __abi.push_str("\",\"type\":\"");
+                    __abi.push_str(&#type_name_expr);
+                    __abi.push_str("\"}");
+                })
+            })
+            .collect::<syn::Result<Vec<_>>>()?;
+
         quote! {
             if !__first_item {
                 __abi.push(',');
             } else {
                 __first_item = false;
             }
-            __abi.push_str("{\"type\":\"constructor\",\"inputs\":[]}");
+            __abi.push_str("{\"type\":\"constructor\",\"inputs\":[");
+            let mut __first_ctor_input = true;
+            #(#constructor_input_entries)*
+            __abi.push_str("]}");
         }
     } else {
         quote! {}
@@ -237,95 +261,20 @@ fn generate_sol_type_name_expr(sol_type: &SolType) -> syn::Result<TokenStream> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::signature::FunctionSignature;
 
     #[test]
     fn returns_empty_stream_for_sol_path_contract() {
-        let parsed = parsed_contract(vec![], false);
-
-        assert!(generate_abi_gen_main(&parsed, true).is_empty());
-    }
-
-    #[test]
-    fn generates_constructor_and_known_types_without_sol_encode_import() {
-        let parsed = parsed_contract(
-            vec![method(
-                "balance_of",
-                "balanceOf",
-                vec![SolType::Address],
-                vec![SolType::Uint(256)],
-                &["account"],
-            )],
-            true,
-        );
-
-        let output = generate_abi_gen_main(&parsed, false).to_string();
-
-        assert!(output.contains("cfg (feature = \"abi-gen\")"));
-        assert!(output.contains("{\\\"type\\\":\\\"constructor\\\",\\\"inputs\\\":[]}"));
-        assert!(output.contains("{\\\"type\\\":\\\"function\\\",\\\"name\\\":\\\""));
-        assert!(output.contains("__abi . push_str (\"balanceOf\")"));
-        assert!(output.contains("__abi . push_str (\"account\")"));
-        assert!(output.contains("String :: from (\"address\")"));
-        assert!(output.contains("String :: from (\"uint256\")"));
-        assert!(!output.contains("SolEncode"));
-    }
-
-    #[test]
-    fn generates_sol_encode_calls_for_custom_types() {
-        let parsed = parsed_contract(
-            vec![method(
-                "touch",
-                "touch",
-                vec![SolType::Custom("my_crate::MyType".to_string())],
-                vec![SolType::Array(Box::new(SolType::Custom(
-                    "my_crate::MyType".to_string(),
-                )))],
-                &["value"],
-            )],
-            false,
-        );
-
-        let output = generate_abi_gen_main(&parsed, false).to_string();
-
-        assert!(output.contains("use :: pvm_contract_types :: SolEncode ;"));
-        assert!(output.contains(
-            "< my_crate :: MyType as :: pvm_contract_types :: SolEncode > :: sol_name ()"
-        ));
-        assert!(output.contains("push_str (\"[]\")"));
-    }
-
-    fn parsed_contract(methods: Vec<MethodInfo>, has_constructor: bool) -> ParsedContract {
-        ParsedContract {
+        let parsed = ParsedContract {
             mod_name: syn::parse_str("contract").unwrap(),
-            methods,
-            has_constructor,
+            methods: vec![],
+            has_constructor: false,
             has_fallback: false,
             constructor_name: None,
             constructor_returns_result: false,
+            constructor_inputs: vec![],
             fallback_name: None,
-        }
-    }
+        };
 
-    fn method(
-        fn_name: &str,
-        signature_name: &str,
-        inputs: Vec<SolType>,
-        outputs: Vec<SolType>,
-        param_names: &[&str],
-    ) -> MethodInfo {
-        MethodInfo {
-            fn_name: syn::parse_str(fn_name).unwrap(),
-            signature: FunctionSignature {
-                name: signature_name.to_string(),
-                inputs,
-                outputs,
-            },
-            param_names: param_names
-                .iter()
-                .map(|name| syn::parse_str(name).unwrap())
-                .collect(),
-            returns_result: false,
-        }
+        assert!(generate_abi_gen_main(&parsed, true).is_empty());
     }
 }