use std::collections::BTreeMap;
use serde_json::Value;
use crate::cpn::mcard_token::{reflect_mcard_to_pcard, reify_pcard_to_mcard, NetMCard, PrimitiveConstant, TokenMCard};
use crate::layer0::parameter_context::{ParameterContext, ParameterValue, CONTRACT_NET_DIGEST, PARAMETER_TYPES};
use crate::layer0::vocabulary::{HANDLE_CONTRACT_PARAM, HANDLE_CONTRACT_RUNTIME, HANDLE_VCARD_CONTRACT_PARAM};
use crate::layer0::vocabulary_types::TYPE_URI_PARAM;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum ParameterCardError {
UnknownParameter(String),
ForeignToken(String),
WrongType { key: String, found: String },
DigestMismatch(String),
Reify(String),
}
impl std::fmt::Display for ParameterCardError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{self:?}")
}
}
impl std::error::Error for ParameterCardError {}
pub fn parameter_handle(key: &str) -> String {
HANDLE_CONTRACT_PARAM.to_string() + key
}
pub fn parameter_vcard_handle(key: &str) -> String {
HANDLE_VCARD_CONTRACT_PARAM.to_string() + key
}
fn type_uri(key: &str) -> Result<String, ParameterCardError> {
PARAMETER_TYPES
.iter()
.find(|(name, _)| *name == key)
.map(|(_, base)| TYPE_URI_PARAM.to_string() + base)
.ok_or_else(|| ParameterCardError::UnknownParameter(key.to_string()))
}
fn json_value(value: &ParameterValue) -> Value {
match value {
ParameterValue::Int(number) => Value::from(*number),
ParameterValue::Text(text) => Value::from(text.clone()),
ParameterValue::Bool(flag) => Value::from(*flag),
}
}
pub fn reify_parameter(key: &str, value: &ParameterValue) -> Result<TokenMCard, ParameterCardError> {
let pcard = PrimitiveConstant { constant_value: json_value(value), output_type: type_uri(key)? };
reify_pcard_to_mcard(&pcard, ¶meter_handle(key), None, None).map_err(ParameterCardError::Reify)
}
pub fn reflect_parameter(token: &TokenMCard) -> Result<(String, Value), ParameterCardError> {
let key = token
.token_id
.strip_prefix(HANDLE_CONTRACT_PARAM)
.ok_or_else(|| ParameterCardError::ForeignToken(token.token_id.clone()))?;
let pcard = reflect_mcard_to_pcard(token);
if pcard.output_type != type_uri(key)? {
return Err(ParameterCardError::WrongType { key: key.to_string(), found: pcard.output_type });
}
Ok((key.to_string(), pcard.constant_value))
}
pub fn contract_net_mcard(context: &ParameterContext) -> Result<NetMCard, ParameterCardError> {
let mut marking = BTreeMap::new();
for (key, value) in context.as_mapping() {
marking.insert(parameter_handle(key), vec![reify_parameter(key, &value)?]);
}
NetMCard::create(HANDLE_CONTRACT_RUNTIME, Vec::new(), Vec::new(), marking, None, None).map_err(ParameterCardError::Reify)
}
pub fn parameter_context_hash(context: &ParameterContext) -> Result<String, ParameterCardError> {
Ok(contract_net_mcard(context)?.card.hash.clone())
}
pub fn verify_contract_digest() -> Result<String, ParameterCardError> {
let digest = parameter_context_hash(&ParameterContext::default())?;
if digest != CONTRACT_NET_DIGEST {
return Err(ParameterCardError::DigestMismatch(digest));
}
Ok(digest)
}