Metadata V15: Generate Runtime APIs

cli/src/utils.rs

@@ -83,18 +83,12 @@ impl std::str::FromStr for MetadataVersion {
     type Err = String;
 
     fn from_str(input: &str) -> Result<Self, Self::Err> {
-        const SUPPORTED_VERSIONS: &[u32] = &[14];
-
         match input {
             "unstable" => Ok(MetadataVersion { version: u32::MAX }),
             version => {
                 let num: u32 = version
                     .parse()
-                    .map_err(|_| format!("Invalid metadata version specified {:?}. Subxt supports the following versions {:?}", version, SUPPORTED_VERSIONS))?;
-
-                if !SUPPORTED_VERSIONS.iter().any(|&value| value == num) {
-                    return Err(format!("Invalid metadata version specified {:?}. Subxt supports the following versions {:?}", version, SUPPORTED_VERSIONS));
-                }
+                    .map_err(|_| format!("Invalid metadata version specified {:?}", version))?;
 
                 Ok(MetadataVersion { version: num })
             }
@@ -105,9 +99,9 @@ impl std::str::FromStr for MetadataVersion {
 impl From<MetadataVersion> for CodegenMetadataVersion {
     fn from(input: MetadataVersion) -> CodegenMetadataVersion {
         match input.version {
-            14 => CodegenMetadataVersion::V14,
             u32::MAX => CodegenMetadataVersion::Unstable,
-            _ => panic!("MetadataVersion and CodegenMetadataVersion are not in sync!"),
+            14 => CodegenMetadataVersion::Latest,
+            v => CodegenMetadataVersion::Version(v),
         }
     }
 }

codegen/src/api/mod.rs

@@ -99,7 +99,7 @@ pub fn generate_runtime_api_from_url(
     // Fetch latest unstable version, if that fails fall back to the latest stable.
     let bytes = match fetch_metadata_bytes_blocking(url, MetadataVersion::Unstable) {
         Ok(bytes) => bytes,
-        Err(_) => fetch_metadata_bytes_blocking(url, MetadataVersion::V14)?,
+        Err(_) => fetch_metadata_bytes_blocking(url, MetadataVersion::Latest)?,
     };
 
     generate_runtime_api_from_bytes(

codegen/src/utils/fetch_metadata.rs

@@ -16,9 +16,11 @@ use std::time::Duration;
 /// The metadata version that is fetched from the node.
 #[derive(Default)]
 pub enum MetadataVersion {
-    /// Version 14.
+    /// Latest stable version of the metadata.
     #[default]
-    V14,
+    Latest,
+    /// Fetch a specified version of the metadata.
+    Version(u32),
     /// Latest unstable version of the metadata.
     Unstable,
 }
@@ -75,48 +77,122 @@ pub async fn fetch_metadata_hex(
     Ok(hex_data)
 }
 
+async fn fetch_latest_stable(client: impl ClientT) -> Result<Vec<u8>, FetchMetadataError> {
+    // Fetch latest stable metadata of a node via `Metadata_metadata`.
+    let raw: String = client
+        .request("state_call", rpc_params!["Metadata_metadata", "0x"])
+        .await?;
+    let raw_bytes = hex::decode(raw.trim_start_matches("0x"))?;
+    let bytes: frame_metadata::OpaqueMetadata = Decode::decode(&mut &raw_bytes[..])?;
+    Ok(bytes.0)
+}
+
 /// Execute runtime API call and return the specified runtime metadata version.
 async fn fetch_metadata(
     client: impl ClientT,
     version: MetadataVersion,
 ) -> Result<Vec<u8>, FetchMetadataError> {
     const UNSTABLE_METADATA_VERSION: u32 = u32::MAX;
-    const LATEST_STABLE_VERSION: u32 = 14;
 
+    // Note: `Metadata_metadata_versions` may not be present on all nodes.
+    // Once every node supports the new RPC methods, we can simplify the code a bit.
+    let supported: Option<Vec<u32>> = client
+        .request(
+            "state_call",
+            rpc_params!["Metadata_metadata_versions", "0x"],
+        )
+        .await
+        .ok()
+        .map(|raw: String| {
+            let raw_bytes = hex::decode(raw.trim_start_matches("0x"))?;
+            let versions: Vec<u32> = Decode::decode(&mut &raw_bytes[..])?;
+            Ok::<Vec<u32>, FetchMetadataError>(versions)
+        })
+        .transpose()?;
+
+    // Ensure the user requested a valid version if done implicitly.
+    if let (Some(supported_versions), MetadataVersion::Version(request_version)) =
+        (&supported, &version)
+    {
+        if !supported_versions.is_empty()
+            && !supported_versions
+                .iter()
+                .any(|value| value == request_version)
+        {
+            return Err(FetchMetadataError::Other(format!(
+                "Metadata version {} not supported",
+                request_version
+            )))?;
+        }
+    }
+
+    let mut is_latest = false;
     let version_num = match version {
-        MetadataVersion::V14 => 14,
+        MetadataVersion::Latest => {
+            // If he have a valid supported version, find the latest stable version number.
+            let version_num = if let Some(supported_versions) = &supported {
+                supported_versions
+                    .iter()
+                    .fold(None, |max, value| match (max, value) {
+                        (None, value) => Some(value),
+                        (Some(old_max), value) => {
+                            if value != &UNSTABLE_METADATA_VERSION && value > old_max {
+                                Some(value)
+                            } else {
+                                Some(old_max)
+                            }
+                        }
+                    })
+            } else {
+                // List not exposed by node.
+                None
+            };
+
+            if let Some(version_num) = version_num {
+                // Use the latest stable from the provided list.
+                is_latest = true;
+                *version_num
+            } else {
+                // List is empty or the node does not expose the list of supported versions.
+                return fetch_latest_stable(client).await;
+            }
+        }
+        MetadataVersion::Version(version) => version,
         MetadataVersion::Unstable => UNSTABLE_METADATA_VERSION,
     };
 
-    // Fetch the latest stable version with `Metadata_metadata` API.
-    if version_num == LATEST_STABLE_VERSION {
-        let raw: String = client
-            .request("state_call", rpc_params!["Metadata_metadata", "0x"])
-            .await?;
-        let raw_bytes = hex::decode(raw.trim_start_matches("0x"))?;
-        let bytes: frame_metadata::OpaqueMetadata = Decode::decode(&mut &raw_bytes[..])?;
-        return Ok(bytes.0);
-    }
-
     // Other versions (including unstable) are fetched with `Metadata_metadata_at_version`.
     let bytes = version_num.encode();
     let version: String = format!("0x{}", hex::encode(&bytes));
 
-    let raw: String = client
+    let result: Result<String, _> = client
         .request(
             "state_call",
             rpc_params!["Metadata_metadata_at_version", &version],
         )
-        .await?;
+        .await;
 
-    let raw_bytes = hex::decode(raw.trim_start_matches("0x"))?;
+    match result {
+        Ok(raw) => {
+            let raw_bytes = hex::decode(raw.trim_start_matches("0x"))?;
 
-    let opaque: Option<frame_metadata::OpaqueMetadata> = Decode::decode(&mut &raw_bytes[..])?;
-    let bytes = opaque.ok_or(FetchMetadataError::Other(
-        "Metadata version not found".into(),
-    ))?;
+            let opaque: Option<frame_metadata::OpaqueMetadata> =
+                Decode::decode(&mut &raw_bytes[..])?;
+            let bytes = opaque.ok_or(FetchMetadataError::Other(
+                "Metadata version not found".into(),
+            ))?;
 
-    Ok(bytes.0)
+            Ok(bytes.0)
+        }
+        Err(err) => {
+            // Try to fetch the latest with `Metadata_metadata`.
+            if is_latest {
+                fetch_latest_stable(client).await
+            } else {
+                Err(err.into())
+            }
+        }
+    }
 }
 
 async fn fetch_metadata_ws(

subxt/src/client/online_client.rs

@@ -141,12 +141,12 @@ impl<T: Config> OnlineClient<T> {
             const V15_METADATA_VERSION: u32 = u32::MAX;
             match rpc.metadata_at_version(V15_METADATA_VERSION).await {
                 Ok(bytes) => Ok(bytes),
-                Err(_) => rpc.state_call_metadata().await,
+                Err(_) => rpc.metadata().await,
             }
         }
 
         #[cfg(not(feature = "unstable-metadata"))]
-        rpc.state_call_metadata().await
+        rpc.metadata().await
     }
 
     /// Create an object which can be used to keep the runtime up to date
@@ -390,7 +390,7 @@ impl<T: Config> RuntimeUpdaterStream<T> {
             Err(err) => return Some(Err(err)),
         };
 
-        let metadata = match self.client.rpc().metadata(None).await {
+        let metadata = match self.client.rpc().metadata().await {
             Ok(metadata) => metadata,
             Err(err) => return Some(Err(err)),
         };

subxt/src/events/events_type.rs

@@ -76,7 +76,7 @@ impl<T: Config> Events<T> {
     ///     .await?
     ///     .expect("didn't pass a block number; qed");
     ///  // Fetch the metadata of the given block.
-    ///  let metadata = client.rpc().metadata(Some(block_hash)).await?;
+    ///  let metadata = client.rpc().metadata_legacy(Some(block_hash)).await?;
     ///  // Fetch the events from the client.
     ///  let events = Events::new_from_client(metadata, block_hash, client);
     /// # Ok(())

subxt/src/rpc/rpc.rs

@@ -143,8 +143,8 @@ impl<T: Config> Rpc<T> {
         genesis_hash.ok_or_else(|| "Genesis hash not found".into())
     }
 
-    /// Fetch the metadata
-    pub async fn metadata(&self, at: Option<T::Hash>) -> Result<Metadata, Error> {
+    /// Fetch the metadata via the legacy `state_getMetadata` RPC method.
+    pub async fn metadata_legacy(&self, at: Option<T::Hash>) -> Result<Metadata, Error> {
         let bytes: types::Bytes = self
             .client
             .request("state_getMetadata", rpc_params![at])
@@ -400,7 +400,7 @@ impl<T: Config> Rpc<T> {
     ///
     /// This returns the same output as [`Self::metadata`], but calls directly
     /// into the runtime.
-    pub async fn state_call_metadata(&self) -> Result<Metadata, Error> {
+    pub async fn metadata(&self) -> Result<Metadata, Error> {
         let bytes: frame_metadata::OpaqueMetadata =
             self.state_call("Metadata_metadata", None, None).await?;
 

testing/integration-tests/src/blocks/mod.rs

@@ -113,7 +113,7 @@ async fn runtime_api_call() -> Result<(), subxt::Error> {
     };
 
     // Compare the runtime API call against the `state_getMetadata`.
-    let metadata = api.rpc().metadata(None).await?;
+    let metadata = api.rpc().metadata_legacy(None).await?;
     let metadata = metadata.runtime_metadata();
     assert_eq!(&metadata_call, metadata);
     Ok(())

testing/integration-tests/src/client/mod.rs

@@ -438,7 +438,7 @@ async fn rpc_state_call() {
         _ => panic!("Metadata V14 or V15 unavailable"),
     };
     // Compare the runtime API call against the `state_getMetadata`.
-    let metadata = api.rpc().metadata(None).await.unwrap();
+    let metadata = api.rpc().metadata_legacy(None).await.unwrap();
     let metadata = metadata.runtime_metadata();
     assert_eq!(&metadata_call, metadata);
 }