taler-rust

api.rs (6659B)

---

 /*
   This file is part of TALER
   Copyright (C) 2024, 2025, 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, num::ParseIntError, ops::Deref, str::FromStr};
 
 use aws_lc_rs::{
     error::KeyRejected,
     signature::{self, Ed25519KeyPair, KeyPair as _, ParsedPublicKey},
 };
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::value::RawValue;
 
 use crate::{encoding::base32::Base32Error, types::base32::Base32};
 
 pub mod params;
 pub mod prepared;
 pub mod revenue;
 pub mod wire;
 
 #[derive(
     Debug,
     Clone,
     Copy,
     PartialEq,
     Eq,
     PartialOrd,
     Ord,
     Hash,
     serde_with::DeserializeFromStr,
     serde_with::SerializeDisplay,
 )]
 pub struct LibtoolVersion {
     pub current: u32,
     pub revision: u32,
     pub age: u32,
 }
 
 impl LibtoolVersion {
     pub const fn new(current: u32, revision: u32, age: u32) -> Self {
         assert!(age <= current);
         Self {
             current,
             revision,
             age,
         }
     }
 }
 
 #[derive(Debug, thiserror::Error)]
 pub enum LibtoolVersionError {
     #[error("age exceeds current")]
     AgeExceedsCurrent,
     #[error("invalid format")]
     InvalidFormat,
     #[error(transparent)]
     ParseIntError(#[from] ParseIntError),
 }
 
 impl FromStr for LibtoolVersion {
     type Err = LibtoolVersionError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut parts = s.split(':');
 
         let current = parts
             .next()
             .ok_or(LibtoolVersionError::InvalidFormat)?
             .parse::<u32>()?;
 
         let revision = match parts.next() {
             Some(p) => p.parse::<u32>()?,
             None => 0,
         };
 
         let age = match parts.next() {
             Some(p) => p.parse::<u32>()?,
             None => 0,
         };
 
         if parts.next().is_some() {
             return Err(LibtoolVersionError::InvalidFormat);
         }
 
         Ok(Self::new(current, revision, age))
     }
 }
 
 impl Display for LibtoolVersion {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}:{}:{}", self.current, self.revision, self.age)
     }
 }
 
 /// <https://docs.taler.net/core/api-common.html#tsref-type-ErrorDetail>
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ErrorDetail {
     pub code: u16,
     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>>,
 }
 
 /// 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(Clone, PartialEq, Eq)]
 pub struct EddsaPublicKey(Base32<32>);
 
 impl Deref for EddsaPublicKey {
     type Target = Base32<32>;
 
     fn deref(&self) -> &Self::Target {
         &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(serde::de::Error::custom)
     }
 }
 
 impl Display for EddsaPublicKey {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.0.fmt(f)
     }
 }
 
 impl std::fmt::Debug for EddsaPublicKey {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         Display::fmt(&self.0, 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<[u8; 32]> for EddsaPublicKey {
     type Error = EddsaPublicKeyError;
 
     fn try_from(value: [u8; 32]) -> Result<Self, Self::Error> {
         let encoded = Base32::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 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))
     }
 }