Add dynamic types support

CHANGELOG.md

@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Remove check for compatible `scale` and `scale-info` versions - [#1370](https://github.com/paritytech/cargo-contract/pull/1370)
 - Add workspace support -[#1358](https://github.com/paritytech/cargo-contract/pull/1358)
 - Add `Storage Total Deposit` to `info` command output - [#1347](https://github.com/paritytech/cargo-contract/pull/1347)
+- Add dynamic types support - [#1399](https://github.com/paritytech/cargo-contract/pull/1399)
 
 ### Fixed
 - Do not allow to execute calls on immutable contract messages - [#1397](https://github.com/paritytech/cargo-contract/pull/1397)

crates/cargo-contract/src/cmd/info.rs

@@ -19,10 +19,7 @@ use super::{
     display_all_contracts,
     DefaultConfig,
 };
-use anyhow::{
-    anyhow,
-    Result,
-};
+use anyhow::Result;
 use contract_analyze::determine_language;
 use contract_extrinsics::{
     fetch_all_contracts,
@@ -107,12 +104,8 @@ impl InfoCommand {
 
             let info_to_json = fetch_contract_info(contract, &rpc, &client).await?;
 
-            let wasm_code = fetch_wasm_code(&client, &rpc, info_to_json.code_hash())
-                .await?
-                .ok_or(anyhow!(
-                    "Contract wasm code was not found for account id {}",
-                    contract
-                ))?;
+            let wasm_code =
+                fetch_wasm_code(&client, &rpc, info_to_json.code_hash()).await?;
             // Binary flag applied
             if self.binary {
                 if self.output_json {

crates/extrinsics/Cargo.toml

@@ -12,7 +12,7 @@ documentation = "https://docs.rs/contract-extrinsics"
 homepage = "https://www.substrate.io/"
 description = "Library defining extrinsics for smart contracts on substrate"
 keywords = ["wasm", "parity", "webassembly", "blockchain", "edsl"]
-include = ["Cargo.toml", "*.rs", "LICENSE", "src/**/*.scale",]
+include = ["Cargo.toml", "*.rs", "LICENSE",]
 
 [dependencies]
 contract-build = { version = "4.0.0-alpha", path = "../build" }

crates/extrinsics/src/call.rs

@@ -17,7 +17,6 @@
 use super::{
     account_id,
     events::DisplayEvents,
-    runtime_api::api,
     state,
     state_call,
     submit_extrinsic,
@@ -33,6 +32,7 @@ use super::{
 };
 use crate::{
     check_env_types,
+    extrinsic_calls::Call,
     extrinsic_opts::ExtrinsicOpts,
 };
 
@@ -240,10 +240,7 @@ impl CallExec {
     pub async fn call_dry_run(&self) -> Result<ContractExecResult<Balance, ()>> {
         let storage_deposit_limit = self
             .opts
-            .storage_deposit_limit()
-            .as_ref()
-            .map(|bv| bv.denominate_balance(&self.token_metadata))
-            .transpose()?;
+            .storage_deposit_limit_balance(&self.token_metadata)?;
         let call_request = CallRequest {
             origin: account_id(&self.signer),
             dest: self.contract.clone(),
@@ -281,7 +278,7 @@ impl CallExec {
                 "Tried to execute a call on the immutable contract message '{}'. Please do a dry-run instead.",
                 &self.message
             );
-            return Err(inner.into());
+            return Err(inner.into())
         }
 
         // use user specified values where provided, otherwise estimate
@@ -290,15 +287,18 @@ impl CallExec {
             None => self.estimate_gas().await?,
         };
         tracing::debug!("calling contract {:?}", self.contract);
+        let storage_deposit_limit = self
+            .opts
+            .storage_deposit_limit_balance(&self.token_metadata)?;
 
-        let call = api::tx().contracts().call(
+        let call = Call::new(
             self.contract.clone().into(),
             self.value.denominate_balance(&self.token_metadata)?,
-            gas_limit.into(),
-            self.opts
-                .compact_storage_deposit_limit(&self.token_metadata)?,
+            gas_limit,
+            storage_deposit_limit,
             self.call_data.clone(),
-        );
+        )
+        .build();
 
         let result =
             submit_extrinsic(&self.client, &self.rpc, &call, &self.signer).await?;
@@ -416,7 +416,7 @@ impl CallExec {
 ///
 /// Copied from `pallet-contracts-rpc-runtime-api`.
 #[derive(Encode)]
-pub struct CallRequest {
+struct CallRequest {
     origin: <DefaultConfig as Config>::AccountId,
     dest: <DefaultConfig as Config>::AccountId,
     value: Balance,

crates/extrinsics/src/contract_info.rs

@@ -21,7 +21,6 @@ use anyhow::{
 
 use super::{
     get_best_block,
-    runtime_api::api,
     Balance,
     Client,
     CodeHash,
@@ -207,18 +206,21 @@ pub async fn fetch_wasm_code(
     client: &Client,
     rpc: &LegacyRpcMethods<DefaultConfig>,
     hash: &CodeHash,
-) -> Result<Option<Vec<u8>>> {
-    let pristine_code_address = api::storage().contracts().pristine_code(hash);
+) -> Result<Vec<u8>> {
     let best_block = get_best_block(rpc).await?;
 
-    let pristine_bytes = client
+    let pristine_code_address =
+        dynamic("Contracts", "PristineCode", vec![Value::from_bytes(hash)]);
+    let pristine_code = client
         .storage()
         .at(best_block)
         .fetch(&pristine_code_address)
         .await?
-        .map(|v| v.0);
-
-    Ok(pristine_bytes)
+        .ok_or_else(|| anyhow!("No WASM code was found for code hash {}", hash))?;
+    let pristine_code = pristine_code
+        .as_type::<BoundedVec<u8>>()
+        .map_err(|e| anyhow!("Contract wasm code could not be parsed: {e}"));
+    pristine_code.map(|v| v.0)
 }
 
 /// Parse a contract account address from a storage key. Returns error if a key is
@@ -236,18 +238,18 @@ fn parse_contract_account_address(
         .map_err(|err| anyhow!("AccountId deserialization error: {}", err))
 }
 
-/// Fetch all contract addresses from the storage using the provided client and count of
-/// requested elements starting from an optional address
+/// Fetch all contract addresses from the storage using the provided client.
 pub async fn fetch_all_contracts(
     client: &Client,
     rpc: &LegacyRpcMethods<DefaultConfig>,
 ) -> Result<Vec<AccountId32>> {
-    let root_key = api::storage()
-        .contracts()
-        .contract_info_of_iter()
-        .to_root_bytes();
-
     let best_block = get_best_block(rpc).await?;
+    let root_key = subxt::dynamic::storage(
+        "Contracts",
+        "ContractInfoOf",
+        vec![Value::from_bytes(AccountId32([0u8; 32]))],
+    )
+    .to_root_bytes();
     let mut keys = client
         .storage()
         .at(best_block)
@@ -341,7 +343,7 @@ mod tests {
     #[test]
     fn contract_info_v11_decode_works() {
         // This version of metadata includes the deposit_account field in ContractInfo
-        #[subxt::subxt(runtime_metadata_path = "src/runtime_api/metadata_v11.scale")]
+        #[subxt::subxt(runtime_metadata_path = "src/test_runtime_api/metadata_v11.scale")]
         mod api_v11 {}
 
         use api_v11::runtime_types::{
@@ -352,7 +354,7 @@ mod tests {
             },
         };
 
-        let metadata_bytes = std::fs::read("src/runtime_api/metadata_v11.scale")
+        let metadata_bytes = std::fs::read("src/test_runtime_api/metadata_v11.scale")
             .expect("the metadata must be present");
         let metadata =
             Metadata::decode(&mut &*metadata_bytes).expect("the metadata must decode");
@@ -406,7 +408,7 @@ mod tests {
     fn contract_info_v15_decode_works() {
         // This version of metadata does not include the deposit_account field in
         // ContractInfo
-        #[subxt::subxt(runtime_metadata_path = "src/runtime_api/metadata.scale")]
+        #[subxt::subxt(runtime_metadata_path = "src/test_runtime_api/metadata_v15.scale")]
         mod api_v15 {}
 
         use api_v15::runtime_types::{
@@ -417,7 +419,7 @@ mod tests {
             pallet_contracts::storage::ContractInfo as ContractInfoV15,
         };
 
-        let metadata_bytes = std::fs::read("src/runtime_api/metadata.scale")
+        let metadata_bytes = std::fs::read("src/test_runtime_api/metadata_v15.scale")
             .expect("the metadata must be present");
         let metadata =
             Metadata::decode(&mut &*metadata_bytes).expect("the metadata must decode");

crates/extrinsics/src/events.rs

@@ -15,8 +15,9 @@
 // along with cargo-contract.  If not, see <http://www.gnu.org/licenses/>.
 
 use super::{
-    runtime_api::api::contracts::events::ContractEmitted,
+    Balance,
     BalanceVariant,
+    CodeHash,
     DefaultConfig,
     TokenMetadata,
 };
@@ -40,8 +41,96 @@ use subxt::{
     self,
     blocks::ExtrinsicEvents,
     events::StaticEvent,
+    ext::{
+        scale_decode,
+        scale_encode,
+    },
+    Config,
 };
 
+/// A custom event emitted by the contract.
+#[derive(
+    scale::Decode,
+    scale::Encode,
+    scale_decode::DecodeAsType,
+    scale_encode::EncodeAsType,
+    Debug,
+)]
+#[decode_as_type(crate_path = "subxt::ext::scale_decode")]
+#[encode_as_type(crate_path = "subxt::ext::scale_encode")]
+pub struct ContractEmitted {
+    pub contract: <DefaultConfig as Config>::AccountId,
+    pub data: Vec<u8>,
+}
+
+impl StaticEvent for ContractEmitted {
+    const PALLET: &'static str = "Contracts";
+    const EVENT: &'static str = "ContractEmitted";
+}
+
+/// A contract was successfully instantiated.
+#[derive(
+    Debug,
+    scale::Decode,
+    scale::Encode,
+    scale_decode::DecodeAsType,
+    scale_encode::EncodeAsType,
+)]
+#[decode_as_type(crate_path = "subxt::ext::scale_decode")]
+#[encode_as_type(crate_path = "subxt::ext::scale_encode")]
+pub struct ContractInstantiated {
+    /// Account id of the deployer.
+    pub deployer: <DefaultConfig as Config>::AccountId,
+    /// Account id where the contract was instantiated to.
+    pub contract: <DefaultConfig as Config>::AccountId,
+}
+
+impl StaticEvent for ContractInstantiated {
+    const PALLET: &'static str = "Contracts";
+    const EVENT: &'static str = "Instantiated";
+}
+
+/// An event triggered by either the `instantiate_with_code` or the `upload_code` call.
+#[derive(
+    Debug,
+    scale::Decode,
+    scale::Encode,
+    scale_decode::DecodeAsType,
+    scale_encode::EncodeAsType,
+)]
+#[decode_as_type(crate_path = "subxt::ext::scale_decode")]
+#[encode_as_type(crate_path = "subxt::ext::scale_encode")]
+pub struct CodeStored {
+    /// Hash under which the contract code was stored.
+    pub code_hash: CodeHash,
+}
+
+impl StaticEvent for CodeStored {
+    const PALLET: &'static str = "Contracts";
+    const EVENT: &'static str = "CodeStored";
+}
+
+/// An event triggered by the `remove_code` call.
+#[derive(
+    Debug,
+    scale::Decode,
+    scale::Encode,
+    scale_decode::DecodeAsType,
+    scale_encode::EncodeAsType,
+)]
+#[decode_as_type(crate_path = "subxt::ext::scale_decode")]
+#[encode_as_type(crate_path = "subxt::ext::scale_encode")]
+pub struct CodeRemoved {
+    pub code_hash: CodeHash,
+    pub deposit_released: Balance,
+    pub remover: <DefaultConfig as Config>::AccountId,
+}
+
+impl StaticEvent for CodeRemoved {
+    const PALLET: &'static str = "Contracts";
+    const EVENT: &'static str = "CodeRemoved";
+}
+
 /// Field that represent data of an event from invoking a contract extrinsic.
 #[derive(serde::Serialize)]
 pub struct Field {
@@ -64,7 +153,7 @@ impl Field {
     }
 }
 
-/// An event produced from from invoking a contract extrinsic.
+/// An event produced from invoking a contract extrinsic.
 #[derive(serde::Serialize)]
 pub struct Event {
     /// name of a pallet