WIP adding cross_contract_calls test

Author: ascjones

integration-tests/cross-contract-calls/.gitignore

@@ -0,0 +1,9 @@
+# Ignore build artifacts from the local tests sub-crate.
+/target/
+
+# Ignore backup files creates by cargo fmt.
+**/*.rs.bk
+
+# Remove Cargo.lock when creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

integration-tests/cross-contract-calls/Cargo.toml

@@ -0,0 +1,32 @@
+[package]
+name = "cross-contract-calls"
+version = "5.0.0-rc"
+authors = ["Parity Technologies <[email protected]>"]
+edition = "2021"
+publish = false
+
+[dependencies]
+ink = { path = "../../crates/ink", default-features = false }
+
+# Note: We **need** to specify the `ink-as-dependency` feature.
+#
+# If we don't we will end up with linking errors!
+other-contract = { path = "other-contract", default-features = false, features = ["ink-as-dependency"] }
+
+[dev-dependencies]
+ink_e2e = { path = "../../crates/e2e" }
+
+[lib]
+path = "lib.rs"
+
+[features]
+default = ["std"]
+std = [
+    "ink/std",
+
+    # Note: The metadata generation step requires `std`. If we don't specify this the metadata
+    # generation for our contract will fail!
+    "other-contract/std",
+]
+ink-as-dependency = []
+e2e-tests = []

integration-tests/cross-contract-calls/e2e_tests.rs

@@ -0,0 +1,94 @@
+use super::incrementer::*;
+use ink_e2e::ContractsBackend;
+
+type E2EResult<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+
+#[ink_e2e::test]
+async fn migration_works<Client: E2EBackend>(mut client: Client) -> E2EResult<()> {
+    // Given
+    let mut constructor = IncrementerRef::new();
+    let contract = client
+        .instantiate("incrementer", &ink_e2e::alice(), &mut constructor)
+        .submit()
+        .await
+        .expect("instantiate failed");
+    let mut call = contract.call::<Incrementer>();
+
+    let get = call.get();
+    let get_res = client.call(&ink_e2e::alice(), &get).dry_run().await;
+    assert_eq!(get_res.return_value(), 0);
+
+    let inc = call.inc();
+    let _inc_result = client
+        .call(&ink_e2e::alice(), &inc)
+        .submit()
+        .await
+        .expect("`inc` failed");
+
+    let get = call.get();
+    let get_res = client.call(&ink_e2e::alice(), &get).dry_run().await;
+    let pre_migration_value = get_res.return_value();
+    assert_eq!(pre_migration_value, 1);
+
+    // Upload the code for the contract to be updated to after the migration.
+    let new_code_hash = client
+        .upload("updated-incrementer", &ink_e2e::alice())
+        .submit()
+        .await
+        .expect("uploading `updated-incrementer` failed")
+        .code_hash;
+    let new_code_hash = new_code_hash.as_ref().try_into().unwrap();
+
+    // Upload the code for the migration contract.
+    let migration_contract = client
+        .upload("migration", &ink_e2e::alice())
+        .submit()
+        .await
+        .expect("uploading `migration` failed");
+    let migration_code_hash = migration_contract.code_hash.as_ref().try_into().unwrap();
+
+    // When
+
+    // Set the code hash to the migration contract
+    let set_code = call.set_code(migration_code_hash);
+    let _set_code_result = client
+        .call(&ink_e2e::alice(), &set_code)
+        .submit()
+        .await
+        .expect("`set_code` failed");
+
+    // Call the migration contract with a new value for `inc_by` and the code hash
+    // of the updated contract.
+    const NEW_INC_BY: u8 = 4;
+    let migrate = contract
+        .call::<migration::incrementer::Incrementer>()
+        .migrate(NEW_INC_BY, new_code_hash);
+
+    let _migration_result = client
+        .call(&ink_e2e::alice(), &migrate)
+        .submit()
+        .await
+        .expect("`migrate` failed");
+
+    // Then
+    let inc = contract
+        .call::<updated_incrementer::incrementer::Incrementer>()
+        .inc();
+
+    let _inc_result = client
+        .call(&ink_e2e::alice(), &inc)
+        .submit()
+        .await
+        .expect("`inc` failed");
+
+    let get = call.get();
+    let get_res = client.call(&ink_e2e::alice(), &get).dry_run().await;
+
+    // Remember, we updated our incrementer contract to increment by `4`.
+    assert_eq!(
+        get_res.return_value(),
+        pre_migration_value + NEW_INC_BY as u32
+    );
+
+    Ok(())
+}

integration-tests/cross-contract-calls/lib.rs

@@ -0,0 +1,46 @@
+#![cfg_attr(not(feature = "std"), no_std, no_main)]
+
+#[ink::contract]
+mod cross_contract_calls {
+    /// We import the generated `ContractRef` of our other contract.
+    ///
+    /// Note that the other contract must have re-exported it (`pub use
+    /// OtherContractRef`) for us to have access to it.
+    use other_contract::OtherContractRef;
+
+    #[ink(storage)]
+    pub struct CrossContractCalls {
+        /// We specify that our contract will store a reference to the `OtherContract`.
+        other_contract: AccountId,
+    }
+
+    impl CrossContractCalls {
+        /// In order to use the `OtherContract` we first need to **instantiate** it.
+        ///
+        /// To do this we will use the uploaded `code_hash` of `OtherContract`.
+        #[ink(constructor)]
+        pub fn new(other_contract: AccountId) -> Self {
+            // todo: need to add instantiate_v2 methods...
+            let other_contract = OtherContractRef::new(true)
+                .code_hash(other_contract_code_hash)
+                .endowment(0)
+                .salt_bytes([0xDE, 0xAD, 0xBE, 0xEF])
+                .instantiate();
+
+            Self { other_contract }
+        }
+
+        /// Using the `ContractRef` we can call all the messages of the `OtherContract` as
+        /// if they were normal Rust methods (because at the end of the day, they
+        /// are!).
+        #[ink(message)]
+        pub fn flip_and_get(&mut self) -> bool {
+            // todo: add calls to `call_v2`
+            self.other_contract.flip();
+            self.other_contract.get()
+        }
+    }
+}
+
+#[cfg(all(test, feature = "e2e-tests"))]
+mod e2e_tests;

integration-tests/cross-contract-calls/other-contract/.gitignore

@@ -0,0 +1,9 @@
+# Ignore build artifacts from the local tests sub-crate.
+/target/
+
+# Ignore backup files creates by cargo fmt.
+**/*.rs.bk
+
+# Remove Cargo.lock when creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

integration-tests/cross-contract-calls/other-contract/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "other-contract"
+version = "5.0.0-rc"
+authors = ["Parity Technologies <[email protected]>"]
+edition = "2021"
+publish = false
+
+[dependencies]
+ink = { path = "../../../crates/ink", default-features = false }
+
+[dev-dependencies]
+ink_e2e = { path = "../../../crates/e2e" }
+
+[lib]
+path = "lib.rs"
+
+[features]
+default = ["std"]
+std = [
+    "ink/std",
+]
+ink-as-dependency = []
+e2e-tests = []

integration-tests/cross-contract-calls/other-contract/lib.rs

@@ -0,0 +1,33 @@
+#![cfg_attr(not(feature = "std"), no_std, no_main)]
+
+/// Re-export the `ContractRef` generated by the ink! codegen.
+///
+/// This let's other crates which pull this contract in as a dependency to interact
+/// with this contract in a type-safe way.
+pub use self::other_contract::OtherContractRef;
+
+#[ink::contract]
+mod other_contract {
+
+    #[ink(storage)]
+    pub struct OtherContract {
+        value: bool,
+    }
+
+    impl OtherContract {
+        #[ink(constructor)]
+        pub fn new(init_value: bool) -> Self {
+            Self { value: init_value }
+        }
+
+        #[ink(message)]
+        pub fn flip(&mut self) {
+            self.value = !self.value;
+        }
+
+        #[ink(message)]
+        pub fn get(&self) -> bool {
+            self.value
+        }
+    }
+}