feat: Replaced generated code with stellar-xdr

Removed the dependencies xdr-rs-serialize and xdr-rs-serialize-derive,
since serialization is already provided by stellar-xdr.

For compatibility reasons and convenience, the existing XDRSerialize and
XDRDeserialize traits are now implemented on top of the WriteXdr and
ReadXdr traits from stellar-xdr.

Added a bunch of new data types and enum values. Removed enum types
where they added nothing beyond the same type in stellar-xdr. No support
was added for Preconditions::V2 and TransactionExt::V1, both part of the
new stellar_xdr_curr::Transaction type. When trying to convert
transactions which use these values an UnsupportedFeature error is
returned for now.

Also, not all new types have been wrapped. For example, the inner data
of the new LedgerKey values instead refers directly to the types from
the stellar-xdr crate. This can be changed when there is demand, but it
seems futile to wrap all these types in verbose API and to keep this
updated.

Closes #10

Signed-off-by: Thorbjørn Lindeijer <bjorn@lindeijer.nl>

Author: bjorn

Cargo.lock

@@ -27,8 +27,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 sha2 = "0.10.1"
 thiserror = "2.0.12"
-xdr-rs-serialize = "0.3.0"
-xdr-rs-serialize-derive = "0.3.0"
+stellar-xdr = "22.2.0"
 
 [dependencies.ed25519-dalek]
 version = "2.1.1"

Cargo.toml

@@ -24,20 +24,17 @@ You can join the discussion on our mailing list at
 
 ## Features
 
- * Working XDR definitions for all Stellar types.
- * Seamlessy convert monetary amounts between decimal representation
-   and stroops.
+* Wraps generated XDR definitions from `stellar-xdr` in a nicer API.
+
+* Seamlessy convert monetary amounts between decimal representation
+  and stroops.
 
 
 ## Documentation
 
 You can find the documentation on [docs.rs](https://docs.rs/stellar-base).
 
 
-## Generating XDR types
-
-You can generated XDR types using [our fork of `xdrgen`](https://github.com/aurora-rs/xdrgen).
-
 ## Changelog
 
 [You can find a changelog here.](https://github.com/aurora-rs/stellar-base-rs/blob/master/CHANGELOG.md)

README.md

@@ -6,10 +6,10 @@ bitflags! {
     /// Account flags.
     #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
     pub struct AccountFlags: u32 {
-        const AUTH_REQUIRED = xdr::AccountFlags::AuthRequiredFlag as u32;
-        const AUTH_REVOCABLE = xdr::AccountFlags::AuthRevocableFlag as u32;
-        const AUTH_IMMUTABLE = xdr::AccountFlags::AuthImmutableFlag as u32;
-        const AUTH_CLAWBACK_ENABLED = xdr::AccountFlags::AuthClawbackEnabledFlag as u32;
+        const AUTH_REQUIRED = xdr::AccountFlags::RequiredFlag as u32;
+        const AUTH_REVOCABLE = xdr::AccountFlags::RevocableFlag as u32;
+        const AUTH_IMMUTABLE = xdr::AccountFlags::ImmutableFlag as u32;
+        const AUTH_CLAWBACK_ENABLED = xdr::AccountFlags::ClawbackEnabledFlag as u32;
     }
 }
 
@@ -53,12 +53,14 @@ impl DataValue {
 
     /// Returns the DataValue xdr object.
     pub fn to_xdr(&self) -> Result<xdr::DataValue> {
-        let inner = self.as_bytes().to_vec();
-        Ok(xdr::DataValue::new(inner))
+        let inner = self.as_bytes();
+        Ok(xdr::DataValue(
+            inner.try_into().map_err(|_| Error::XdrError)?,
+        ))
     }
 
     /// Creates a DataValue from xdr object.
     pub fn from_xdr(x: &xdr::DataValue) -> Result<DataValue> {
-        DataValue::from_slice(&x.value)
+        DataValue::from_slice(&x)
     }
 }

src/account.rs

@@ -1,15 +1,13 @@
 //! Represent monetary values and prices.
 use crate::error::{Error, Result};
 use crate::xdr;
-use crate::xdr::{XDRDeserialize, XDRSerialize};
 use num_rational::Ratio;
 use num_traits::cast::ToPrimitive;
 use rust_decimal::Decimal;
 use std::convert::TryFrom;
 use std::fmt;
+use std::io::{Read, Write};
 use std::str::FromStr;
-use xdr_rs_serialize::de::XDRIn;
-use xdr_rs_serialize::ser::XDROut;
 
 const STELLAR_SCALE: u32 = 7;
 
@@ -140,26 +138,26 @@ impl Stroops {
 
     /// Returns stroops amount as xdr object.
     pub fn to_xdr_int64(&self) -> Result<xdr::Int64> {
-        Ok(xdr::Int64::new(self.0))
+        Ok(self.0)
     }
 
     /// Returns stroops amount as xdr object.
     pub fn to_xdr_uint32(&self) -> Result<xdr::Uint32> {
         if self.0 >= 0 {
-            Ok(xdr::Uint32::new(self.0 as u32))
+            Ok(self.0 as u32)
         } else {
             Err(Error::NegativeStroops)
         }
     }
 
     /// Creates from xdr object.
-    pub fn from_xdr_int64(x: &xdr::Int64) -> Result<Stroops> {
-        Ok(Stroops::new(x.value))
+    pub fn from_xdr_int64(x: xdr::Int64) -> Result<Stroops> {
+        Ok(Stroops(x))
     }
 
     /// Creates from xdr object.
-    pub fn from_xdr_uint32(x: &xdr::Uint32) -> Result<Stroops> {
-        Ok(Stroops::new(x.value as i64))
+    pub fn from_xdr_uint32(x: xdr::Uint32) -> Result<Stroops> {
+        Ok(Stroops::new(x as i64))
     }
 }
 
@@ -189,14 +187,14 @@ impl Price {
     /// Returns price as xdr object.
     pub fn to_xdr(&self) -> Result<xdr::Price> {
         Ok(xdr::Price {
-            n: xdr::Int32::new(self.numerator()),
-            d: xdr::Int32::new(self.denominator()),
+            n: self.numerator(),
+            d: self.denominator(),
         })
     }
 
     /// Creates price from xdr object.
     pub fn from_xdr(x: &xdr::Price) -> Result<Price> {
-        Ok(Price::new(x.n.value, x.d.value))
+        Ok(Price::new(x.n, x.d))
     }
 }
 
@@ -265,18 +263,17 @@ impl TryFrom<Stroops> for Amount {
     }
 }
 
-impl XDRSerialize for Price {
-    fn write_xdr(&self, out: &mut Vec<u8>) -> Result<u64> {
-        let xdr_price = self.to_xdr()?;
-        xdr_price.write_xdr(out).map_err(Error::XdrError)
+impl xdr::WriteXdr for Price {
+    fn write_xdr<W: Write>(&self, w: &mut xdr::Limited<W>) -> xdr::Result<()> {
+        let xdr_price = self.to_xdr().map_err(|_| xdr::Error::Invalid)?;
+        xdr_price.write_xdr(w)
     }
 }
 
-impl XDRDeserialize for Price {
-    fn from_xdr_bytes(buffer: &[u8]) -> Result<(Self, u64)> {
-        let (xdr_price, bytes_read) = xdr::Price::read_xdr(buffer).map_err(Error::XdrError)?;
-        let res = Price::from_xdr(&xdr_price)?;
-        Ok((res, bytes_read))
+impl xdr::ReadXdr for Price {
+    fn read_xdr<R: Read>(r: &mut xdr::Limited<R>) -> xdr::Result<Self> {
+        let xdr_result = xdr::Price::read_xdr(r)?;
+        Self::from_xdr(&xdr_result).map_err(|_| xdr::Error::Invalid)
     }
 }