taler-rust

api_common.rs (6295B)

---

 /*
   This file is part of TALER
   Copyright (C) 2024, 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::{borrow::Cow, fmt::Display, ops::Deref, str::FromStr};
 
 use aws_lc_rs::{
     error::KeyRejected,
     signature::{self, Ed25519KeyPair, KeyPair, ParsedPublicKey},
 };
 use serde::{Deserialize, Deserializer, Serialize, de::Error};
 use serde_json::value::RawValue;
 
 use crate::types::base32::{Base32, Base32Error};
 
 /// <https://docs.taler.net/core/api-common.html#tsref-type-ErrorDetail>
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ErrorDetail {
     pub code: u32,
     pub hint: Option<Box<str>>,
     pub detail: Option<Box<str>>,
     pub parameter: Option<Box<str>>,
     pub path: Option<Box<str>>,
     pub offset: Option<Box<str>>,
     pub index: Option<Box<str>>,
     pub object: Option<Box<str>>,
     pub currency: Option<Box<str>>,
     pub type_expected: Option<Box<str>>,
     pub type_actual: Option<Box<str>>,
     pub extra: Option<Box<RawValue>>,
 }
 
 pub fn safe_u64(nb: u64) -> SafeU64 {
     SafeU64::try_from(nb).expect("invalid safe u64")
 }
 
 /// <https://docs.taler.net/core/api-common.html#tsref-type-SafeUint64>
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize)]
 pub struct SafeU64(u64);
 
 impl Deref for SafeU64 {
     type Target = u64;
 
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum SafeU64Error {
     #[error("{0} unsafe, {0} > (2^53 - 1)")]
     Unsafe(u64),
     #[error("{0} is negative")]
     Negative(i64),
 }
 
 impl TryFrom<u64> for SafeU64 {
     type Error = SafeU64Error;
 
     fn try_from(nb: u64) -> Result<Self, Self::Error> {
         if nb < (1 << 53) - 1 {
             Ok(SafeU64(nb))
         } else {
             Err(SafeU64Error::Unsafe(nb))
         }
     }
 }
 
 impl TryFrom<i64> for SafeU64 {
     type Error = SafeU64Error;
 
     fn try_from(nb: i64) -> Result<Self, Self::Error> {
         u64::try_from(nb)
             .map_err(|_| SafeU64Error::Negative(nb))
             .and_then(|it| it.try_into())
     }
 }
 
 impl TryFrom<i32> for SafeU64 {
     type Error = SafeU64Error;
 
     fn try_from(nb: i32) -> Result<Self, Self::Error> {
         u64::try_from(nb)
             .map_err(|_| SafeU64Error::Negative(nb as i64))
             .and_then(|it| it.try_into())
     }
 }
 
 impl<'de> Deserialize<'de> for SafeU64 {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
         SafeU64::try_from(u64::deserialize(deserializer)?).map_err(D::Error::custom)
     }
 }
 
 impl Display for SafeU64 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.0.fmt(f)
     }
 }
 
 /// 64-byte hash code
 pub type HashCode = Base32<64>;
 /// 32-bytes hash code
 pub type ShortHashCode = Base32<32>;
 pub type WadId = Base32<24>;
 pub type EddsaSignature = Base32<64>;
 
 /// EdDSA and ECDHE public keys always point on Curve25519
 /// and represented  using the standard 256 bits Ed25519 compact format,
 /// converted to Crockford Base32.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct EddsaPublicKey(Base32<32>);
 
 impl AsRef<Base32<32>> for EddsaPublicKey {
     fn as_ref(&self) -> &Base32<32> {
         &self.0
     }
 }
 
 impl Serialize for EddsaPublicKey {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
         self.0.serialize(serializer)
     }
 }
 
 impl<'de> Deserialize<'de> for EddsaPublicKey {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
         let raw = Cow::<str>::deserialize(deserializer)?;
         Self::from_str(&raw).map_err(D::Error::custom)
     }
 }
 
 impl Display for EddsaPublicKey {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.0.fmt(f)
     }
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum EddsaPublicKeyError {
     #[error(transparent)]
     Base32(#[from] Base32Error<32>),
     #[error(transparent)]
     Invalid(#[from] KeyRejected),
 }
 
 impl FromStr for EddsaPublicKey {
     type Err = EddsaPublicKeyError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let encoded = Base32::<32>::from_str(s)?;
         Self::try_from(encoded)
     }
 }
 
 impl TryFrom<&[u8]> for EddsaPublicKey {
     type Error = EddsaPublicKeyError;
 
     fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
         let encoded = Base32::try_from(value)?;
         Self::try_from(encoded)
     }
 }
 
 impl TryFrom<Base32<32>> for EddsaPublicKey {
     type Error = EddsaPublicKeyError;
 
     fn try_from(value: Base32<32>) -> Result<Self, Self::Error> {
         ParsedPublicKey::new(&signature::ED25519, value.as_ref())?;
         Ok(Self(value))
     }
 }
 
 impl EddsaPublicKey {
     pub fn slice(&self) -> &[u8; 32] {
         self.0.deref()
     }
 
     pub fn rand() -> EddsaPublicKey {
         let signing_key = Ed25519KeyPair::generate().unwrap();
         let bytes: [u8; 32] = signing_key.public_key().as_ref().try_into().unwrap();
         Self(Base32::from(bytes))
     }
 }
 
 impl sqlx::Type<sqlx::Postgres> for EddsaPublicKey {
     fn type_info() -> sqlx::postgres::PgTypeInfo {
         <Base32<32>>::type_info()
     }
 }
 
 impl<'q> sqlx::Encode<'q, sqlx::Postgres> for EddsaPublicKey {
     fn encode_by_ref(
         &self,
         buf: &mut sqlx::postgres::PgArgumentBuffer,
     ) -> Result<sqlx::encode::IsNull, sqlx::error::BoxDynError> {
         self.0.encode_by_ref(buf)
     }
 }
 
 impl<'r> sqlx::Decode<'r, sqlx::Postgres> for EddsaPublicKey {
     fn decode(value: sqlx::postgres::PgValueRef<'r>) -> Result<Self, sqlx::error::BoxDynError> {
         let raw = <Base32<32>>::decode(value)?;
         Ok(Self(raw))
     }
 }