Merge pull request #85 from ava-labs/sync-0.0.393

sync: Bump to 0.0.393

Author: exdx

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "avalanche-types"
-version = "0.0.390" # https://crates.io/crates/avalanche-types
+version = "0.0.393" # https://crates.io/crates/avalanche-types
 edition = "2021"
 rust-version = "1.69" # use "rustup override set stable" to overwrite current toolchain
 publish = true

src/jsonrpc/admin.rs

@@ -1,11 +1,14 @@
-#[allow(dead_code)]
+use std::io::{self, Error as ioError, ErrorKind};
+
+use serde::{Deserialize, Serialize};
 
 /// The chain alias method name
 const ALIAS_METHOD: &str = "admin.aliasChain";
 
 /// The request to alias a chain via the admin API.
 /// Ref: https://docs.avax.network/apis/avalanchego/apis/admin#adminaliaschain
-struct ChainAliasRequest {
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
+pub struct ChainAliasRequest {
     /// Jsonrpc version
     pub jsonrpc: String,
     /// Id of request
@@ -27,20 +30,63 @@ impl Default for ChainAliasRequest {
     }
 }
 
+impl ChainAliasRequest {
+    pub fn encode_json(&self) -> io::Result<String> {
+        serde_json::to_string(&self)
+            .map_err(|e| ioError::new(ErrorKind::Other, format!("failed to serialize JSON {}", e)))
+    }
+}
+
 /// Parameters for the alias request.
-struct ChainAliasParams {
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
+pub struct ChainAliasParams {
     /// The long-form chain ID
     pub chain: String,
     /// The newly issues alias
     pub alias: String,
 }
 
 /// Response for the alias request.
-struct ChainAliasResponse {
+#[derive(Debug, Serialize, Deserialize, Eq, PartialEq, Clone)]
+pub struct ChainAliasResponse {
     /// Jsonrpc version
     pub jsonrpc: String,
     /// Id of request
     pub id: u32,
-    /// Result (empty)
-    pub result: (),
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::jsonrpc::admin::{ChainAliasParams, ChainAliasRequest, ChainAliasResponse};
+    use crate::jsonrpc::{DEFAULT_ID, DEFAULT_VERSION};
+
+    #[test]
+    fn test_serialization() {
+        let chain = String::from("sV6o671RtkGBcno1FiaDbVcFv2sG5aVXMZYzKdP4VQAWmJQnM");
+        let alias = String::from("devnet");
+
+        let req = ChainAliasRequest {
+            params: Some(ChainAliasParams { chain, alias }),
+            ..Default::default()
+        };
+
+        let serialized = req.encode_json().expect("failed serialization");
+
+        let expected: &str = r#"{"jsonrpc":"2.0","id":1,"method":"admin.aliasChain","params":{"chain":"sV6o671RtkGBcno1FiaDbVcFv2sG5aVXMZYzKdP4VQAWmJQnM","alias":"devnet"}}"#;
+        assert_eq!(serialized, expected);
+    }
+
+    #[test]
+    fn test_deserialization() {
+        let resp = ChainAliasResponse {
+            jsonrpc: String::from(DEFAULT_VERSION),
+            id: DEFAULT_ID,
+        };
+
+        let expected = r#"{"jsonrpc": "2.0","id": 1,"result": {}}"#.as_bytes();
+        let deserialized: ChainAliasResponse =
+            serde_json::from_slice(expected).expect("failed deserialization");
+
+        assert_eq!(resp, deserialized);
+    }
 }

src/jsonrpc/client/admin.rs

@@ -0,0 +1,90 @@
+use std::time::Duration;
+
+use reqwest::{header::CONTENT_TYPE, ClientBuilder};
+
+use crate::{
+    errors::{Error, Result},
+    jsonrpc::admin::{ChainAliasParams, ChainAliasRequest, ChainAliasResponse},
+    utils,
+};
+
+/// Set an alias for a chain.
+pub async fn alias_chain(
+    http_rpc: &str,
+    chain: String,
+    alias: String,
+) -> Result<ChainAliasResponse> {
+    let (scheme, host, port, _, _) =
+        utils::urls::extract_scheme_host_port_path_chain_alias(http_rpc).map_err(|e| {
+            Error::Other {
+                message: format!("failed extract_scheme_host_port_path_chain_alias '{}'", e),
+                retryable: false,
+            }
+        })?;
+
+    let u = if let Some(scheme) = scheme {
+        if let Some(port) = port {
+            format!("{scheme}://{host}:{port}/ext/info")
+        } else {
+            format!("{scheme}://{host}/ext/info")
+        }
+    } else {
+        format!("http://{host}/ext/info")
+    };
+    log::info!("getting network name for {u}");
+
+    let data = ChainAliasRequest {
+        params: Some(ChainAliasParams { chain, alias }),
+        ..Default::default()
+    };
+
+    let d = data.encode_json().map_err(|e| Error::Other {
+        message: format!("failed encode_json '{}'", e),
+        retryable: false,
+    })?;
+
+    let req_cli_builder = ClientBuilder::new()
+        .user_agent(env!("CARGO_PKG_NAME"))
+        .danger_accept_invalid_certs(true)
+        .timeout(Duration::from_secs(15))
+        .connection_verbose(true)
+        .build()
+        .map_err(|e| {
+            // TODO: check retryable
+            Error::Other {
+                message: format!("failed reqwest::ClientBuilder.build '{}'", e),
+                retryable: false,
+            }
+        })?;
+
+    let resp = req_cli_builder
+        .post(&u)
+        .header(CONTENT_TYPE, "application/json")
+        .body(d)
+        .send()
+        .await
+        .map_err(|e|
+        // TODO: check retryable
+        Error::API {
+            message: format!("failed reqwest::Client.send '{}'", e),
+            retryable: false,
+        })?;
+
+    let out = resp.bytes().await.map_err(|e| {
+        // TODO: check retryable
+        Error::Other {
+            message: format!("failed reqwest response bytes '{}'", e),
+            retryable: false,
+        }
+    })?;
+    let out: Vec<u8> = out.into();
+
+    let response: ChainAliasResponse = serde_json::from_slice(&out)
+        .map_err(|e| Error::Other {
+            message: format!("failed serde_json::from_slice '{}'", e),
+            retryable: false,
+        })
+        .unwrap();
+
+    Ok(response)
+}

src/jsonrpc/client/mod.rs

@@ -1,3 +1,4 @@
+pub mod admin;
 pub mod evm;
 pub mod health;
 pub mod info;