use std::{collections::HashMap, sync::Arc};
use serde::{Deserialize, Deserializer, Serialize, Serializer, de::Error as DeError};
use serde_json::Value;
use url::Url;
use crate::{
PendingRpcRequest, Result, RpcNamespace,
rpc::{BatchPolicy, HttpJsonRpcTransport},
};
pub const NEAR_RPC_METHODS: &[&str] = &["block", "query", "status"];
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum NearFinality {
Final,
Optimistic,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(untagged)]
pub enum NearBlockId {
Height(u64),
Hash(String),
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum NearBlockReference {
Finality {
finality: NearFinality,
},
BlockId {
block_id: NearBlockId,
},
}
impl Serialize for NearBlockReference {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
use serde::ser::SerializeMap;
let mut map = serializer.serialize_map(Some(1))?;
match self {
Self::Finality { finality } => map.serialize_entry("finality", finality)?,
Self::BlockId { block_id } => map.serialize_entry("block_id", block_id)?,
}
map.end()
}
}
impl<'de> Deserialize<'de> for NearBlockReference {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct WireReference {
finality: Option<NearFinality>,
block_id: Option<NearBlockId>,
}
let reference = WireReference::deserialize(deserializer)?;
match (reference.finality, reference.block_id) {
(Some(finality), None) => Ok(Self::Finality { finality }),
(None, Some(block_id)) => Ok(Self::BlockId { block_id }),
(Some(_), Some(_)) => Err(D::Error::custom(
"NEAR block reference cannot contain both finality and block_id",
)),
(None, None) => Err(D::Error::custom(
"NEAR block reference requires finality or block_id",
)),
}
}
}
#[derive(Clone, Debug, Deserialize)]
pub struct NearStatus {
pub chain_id: String,
pub genesis_hash: String,
pub latest_protocol_version: u64,
pub protocol_version: u64,
pub sync_info: NearSyncInfo,
pub version: NearNodeVersion,
#[serde(flatten)]
pub additional: HashMap<String, Value>,
}
#[derive(Clone, Debug, Deserialize)]
pub struct NearSyncInfo {
pub latest_block_hash: String,
pub latest_block_height: u64,
pub latest_block_time: String,
pub latest_state_root: String,
pub syncing: bool,
#[serde(flatten)]
pub additional: HashMap<String, Value>,
}
#[derive(Clone, Debug, Deserialize)]
pub struct NearNodeVersion {
pub version: String,
pub build: String,
pub rustc_version: Option<String>,
#[serde(flatten)]
pub additional: HashMap<String, Value>,
}
#[derive(Clone, Debug, Deserialize)]
pub struct NearBlockView {
pub author: String,
pub header: NearBlockHeader,
pub chunks: Vec<Value>,
#[serde(flatten)]
pub additional: HashMap<String, Value>,
}
#[derive(Clone, Debug, Deserialize)]
pub struct NearBlockHeader {
pub hash: String,
pub height: u64,
pub prev_hash: String,
pub timestamp: u64,
pub timestamp_nanosec: String,
pub gas_price: String,
pub total_supply: String,
#[serde(flatten)]
pub additional: HashMap<String, Value>,
}
#[derive(Clone, Debug, Deserialize)]
pub struct NearAccountView {
pub amount: String,
pub locked: String,
pub code_hash: String,
pub storage_usage: u64,
pub storage_paid_at: Option<u64>,
pub block_height: u64,
pub block_hash: String,
pub state: Option<String>,
pub bootstrap_nonce: Option<u64>,
pub global_contract_account_id: Option<String>,
pub global_contract_hash: Option<String>,
#[serde(flatten)]
pub additional: HashMap<String, Value>,
}
#[derive(Clone)]
pub struct NearClient {
pub rpc: NearRpcClient,
}
impl NearClient {
pub(crate) fn new(transport: Arc<HttpJsonRpcTransport>) -> Self {
Self {
rpc: NearRpcClient::new(transport),
}
}
}
#[derive(Clone)]
pub struct NearRpcClient {
namespace: RpcNamespace,
}
impl NearRpcClient {
pub(crate) fn new(transport: Arc<HttpJsonRpcTransport>) -> Self {
Self {
namespace: RpcNamespace::new(transport, BatchPolicy::Unsupported),
}
}
#[must_use]
pub fn endpoint(&self) -> String {
let endpoint = self.namespace.endpoint();
if endpoint.is_empty() {
return endpoint;
}
let Ok(mut url) = Url::parse(&endpoint) else {
return String::new();
};
url.set_path("/");
url.set_query(None);
url.set_fragment(None);
let _ = url.set_username("");
let _ = url.set_password(None);
url.to_string()
}
#[must_use]
pub fn status(&self) -> PendingRpcRequest<NearStatus> {
self.namespace
.request("status", Vec::<Value>::new())
.expect("empty parameters serialize")
}
pub fn block(&self, reference: NearBlockReference) -> Result<PendingRpcRequest<NearBlockView>> {
self.namespace.request("block", reference)
}
pub fn view_account(
&self,
account_id: impl Into<String>,
reference: NearBlockReference,
) -> Result<PendingRpcRequest<NearAccountView>> {
let selector = serde_json::to_value(reference)
.expect("NEAR block reference serialization is infallible");
let Some(selector) = selector.as_object() else {
unreachable!("NEAR block references serialize as one-key objects");
};
let mut params = serde_json::Map::with_capacity(3);
params.insert(
"request_type".to_owned(),
Value::String("view_account".to_owned()),
);
params.insert("account_id".to_owned(), Value::String(account_id.into()));
params.extend(selector.clone());
self.namespace.request("query", Value::Object(params))
}
}