Revert contracts put_code test to pure code (not using the macro)

Cargo.toml

@@ -19,6 +19,9 @@ include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE"]
 [features]
 client = ["substrate-subxt-client"]
 
+# enable this feature to run tests which require a local dev chain node
+integration-tests = []
+
 [dependencies]
 log = "0.4.11"
 thiserror = "1.0.20"

src/frame/contracts.rs

@@ -117,43 +117,75 @@ pub struct InstantiatedEvent<T: Contracts> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use sp_keyring::AccountKeyring;
 
-    subxt_test!({
+    use super::*;
-        name: test_put_code_and_instantiate,
+    use crate::{ClientBuilder, PairSigner, ContractsTemplateRuntime};
-        prelude: {
+
-            const CONTRACT: &str = r#"
+    fn contract_wasm() -> Vec<u8> {
-(module
+        const CONTRACT: &str = r#"
-    (func (export "call"))
+            (module
-    (func (export "deploy"))
+                (func (export "call"))
-)
+                (func (export "deploy"))
-"#;
+            )
-            let wasm = wabt::wat2wasm(CONTRACT).expect("invalid wabt");
+        "#;
-            let code_hash;
+        wabt::wat2wasm(CONTRACT).expect("invalid wabt")
-        },
+    }
-        step: {
+
-            call: PutCodeCall {
+    #[async_std::test]
-                _runtime: PhantomData,
+    #[cfg(feature = "integration-tests")]
-                code: &wasm,
+    async fn tx_put_code() {
-            },
+        env_logger::try_init().ok();
-            event: CodeStoredEvent {
+
-                code_hash: {
+        let signer = PairSigner::new(AccountKeyring::Alice.pair());
-                    code_hash = event.code_hash.clone();
+        let client = ClientBuilder::<ContractsTemplateRuntime>::new().build().await.unwrap();
-                    event.code_hash.clone()
+
-                },
+        let code = contract_wasm();
-            },
+        let result = client.put_code_and_watch(&signer, &code).await.unwrap();
-        },
+        let code_stored = result.code_stored().unwrap();
-        step: {
+
-            call: InstantiateCall {
+        assert!(
-                endowment: 100_000_000_000_000,
+            code_stored.is_some(),
-                gas_limit: 500_000_000,
+            format!(
-                code_hash: &code_hash,
+                "Error calling put_code and receiving CodeStored Event: {:?}",
-                data: &[],
+                code_stored
-            },
+            )
-            event: InstantiatedEvent {
+        );
-                caller: alice.clone(),
+    }
-                contract: event.contract.clone(),
+
-            },
+    // #[test]
-        },
+    // #[cfg(feature = "integration-tests")]
-    });
+    // fn tx_instantiate() {
+    //     env_logger::try_init().ok();
+    //     let result: Result<_, Error> = async_std::task::block_on(async move {
+    //         let signer = AccountKeyring::Bob.pair();
+    //         let client = test_client().await;
+    //
+    //         let code_hash = put_code(&client, signer.clone()).await?;
+    //
+    //         log::info!("Code hash: {:?}", code_hash);
+    //
+    //         let xt = client.xt(signer, None).await?;
+    //         let result = xt
+    //             .watch()
+    //             .submit(InstantiateCall {
+    //                 endowment: 100_000_000_000_000,
+    //                 gas_limit: 500_000_000,
+    //                 code_hash: &code_hash,
+    //                 data: &[],
+    //             })
+    //             .await?;
+    //         let event = result
+    //             .find_event::<InstantiatedEvent<_>>()?
+    //             .ok_or(Error::Other("Failed to find Instantiated event".into()))?;
+    //         Ok(event)
+    //     });
+    //
+    //     log::info!("Instantiate result: {:?}", result);
+    //
+    //     assert!(
+    //         result.is_ok(),
+    //         format!("Error instantiating contract: {:?}", result)
+    //     );
+    // }
 }

src/runtimes.rs

@@ -116,6 +116,39 @@ impl Balances for NodeTemplateRuntime {
 
 impl Sudo for NodeTemplateRuntime {}
 
+/// Concrete type definitions compatible with the node template, with the
+/// contracts pallet enabled.
+///
+/// Inherits types from [`NodeTemplateRuntime`], but adds an implementation for
+/// the contracts pallet trait.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct ContractsTemplateRuntime;
+
+impl Runtime for ContractsTemplateRuntime {
+    type Signature = <NodeTemplateRuntime as Runtime>::Signature;
+    type Extra = DefaultExtra<Self>;
+}
+
+impl System for ContractsTemplateRuntime {
+    type Index = <NodeTemplateRuntime as System>::Index;
+    type BlockNumber = <NodeTemplateRuntime as System>::BlockNumber;
+    type Hash = <NodeTemplateRuntime as System>::Hash;
+    type Hashing = <NodeTemplateRuntime as System>::Hashing;
+    type AccountId = <NodeTemplateRuntime as System>::AccountId;
+    type Address = <NodeTemplateRuntime as System>::Address;
+    type Header = <NodeTemplateRuntime as System>::Header;
+    type Extrinsic = <NodeTemplateRuntime as System>::Extrinsic;
+    type AccountData = <NodeTemplateRuntime as System>::AccountData;
+}
+
+impl Balances for ContractsTemplateRuntime {
+    type Balance = <NodeTemplateRuntime as Balances>::Balance;
+}
+
+impl Contracts for ContractsTemplateRuntime {}
+
+impl Sudo for ContractsTemplateRuntime {}
+
 /// Concrete type definitions compatible with those for kusama, v0.7
 ///
 /// # Note