Own WithExtra types

Author: szg251

plutus-ledger-api/CHANGELOG.md

@@ -20,6 +20,7 @@ Changelog](https://keepachangelog.com/en/1.1.0).
   - Addresses are formatted using bech32, if supplemented with network id
   - CurrencySymbols are formatted as hex if native tokens or as the `lovelace`
     string
+- `WithExtraInfo` types are now owned
 
 ## 3.1.0
 

plutus-ledger-api/src/v1/address.rs

@@ -14,6 +14,7 @@ use serde_with::{DeserializeFromStr, SerializeDisplay};
 use crate as plutus_ledger_api;
 use crate::csl::csl_to_pla::{FromCSL, TryFromCSL, TryFromCSLError, TryToPLA};
 use crate::csl::pla_to_csl::{TryFromPLA, TryFromPLAError, TryToCSL};
+use crate::error::ConversionError;
 use crate::plutus_data::{
     parse_constr, parse_fixed_len_constr_fields, IsPlutusData, PlutusData, PlutusDataError,
 };
@@ -39,7 +40,7 @@ pub struct Address {
 }
 
 impl Address {
-    pub fn with_extra_info<'a>(&'a self, network_tag: u8) -> AddressWithExtraInfo<'a> {
+    pub fn with_extra_info(self, network_tag: u8) -> AddressWithExtraInfo {
         AddressWithExtraInfo {
             address: self,
             network_tag,
@@ -89,13 +90,13 @@ impl TryFromCSL<csl::Address> for Address {
 #[cfg_attr(feature = "serde", derive(SerializeDisplay, DeserializeFromStr))]
 /// Address with network information. The `WithExtraInfo` variant has Display instance, serializing into
 /// a bech32 address format.
-pub struct AddressWithExtraInfo<'a> {
-    pub address: &'a Address,
+pub struct AddressWithExtraInfo {
+    pub address: Address,
     pub network_tag: u8,
 }
 
-impl TryFromPLA<AddressWithExtraInfo<'_>> for csl::Address {
-    fn try_from_pla(val: &AddressWithExtraInfo<'_>) -> Result<Self, TryFromPLAError> {
+impl TryFromPLA<AddressWithExtraInfo> for csl::Address {
+    fn try_from_pla(val: &AddressWithExtraInfo) -> Result<Self, TryFromPLAError> {
         let payment = val.address.credential.try_to_csl()?;
 
         Ok(match val.address.staking_credential {
@@ -113,20 +114,71 @@ impl TryFromPLA<AddressWithExtraInfo<'_>> for csl::Address {
     }
 }
 
+impl TryFromCSL<csl::Address> for AddressWithExtraInfo {
+    fn try_from_csl(value: &csl::Address) -> Result<Self, TryFromCSLError>
+    where
+        Self: Sized,
+    {
+        Ok(AddressWithExtraInfo {
+            address: value.try_to_pla()?,
+            network_tag: value.network_id().map_err(|err| {
+                TryFromCSLError::ImpossibleConversion(format!(
+                    "Couldn't extract network tag from address: {err}"
+                ))
+            })?,
+        })
+    }
+}
+
 /// Serializing into a bech32 address format.
-impl std::fmt::Display for AddressWithExtraInfo<'_> {
+impl std::fmt::Display for AddressWithExtraInfo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let bech32_addr: Option<String> = self
             .try_to_csl()
             .ok()
             .and_then(|csl_addr: csl::Address| csl_addr.to_bech32(None).ok());
         match bech32_addr {
             Some(addr) => write!(f, "{}", addr),
-            None => write!(f, "INVALID ADDRESS {:?}", self),
+            None => Err(std::fmt::Error),
         }
     }
 }
 
+impl FromStr for AddressWithExtraInfo {
+    type Err = ConversionError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let csl_addr = csl::Address::from_bech32(s).map_err(|err| {
+            ConversionError::ParseError(anyhow!(
+                "Error while parsing bech32 address '{}': {}",
+                s,
+                err
+            ))
+        })?;
+
+        let address = Address::try_from_csl(&csl_addr).map_err(|err| {
+            ConversionError::ParseError(anyhow!(
+                "Error while parsing bech32 address '{}': {}",
+                s,
+                err
+            ))
+        })?;
+
+        let network_tag = csl_addr.network_id().map_err(|err| {
+            ConversionError::ParseError(anyhow!(
+                "Error while parsing extracting network tag from address '{}': {}",
+                s,
+                err
+            ))
+        })?;
+
+        Ok(AddressWithExtraInfo {
+            address,
+            network_tag,
+        })
+    }
+}
+
 ////////////////
 // Credential //
 ////////////////

plutus-ledger-api/src/v1/redeemer.rs

@@ -25,17 +25,17 @@ use crate::v1::crypto::LedgerBytes;
 pub struct Redeemer(pub PlutusData);
 
 #[derive(Clone, Debug)]
-pub struct RedeemerWithExtraInfo<'a> {
-    pub redeemer: &'a Redeemer,
-    pub tag: &'a csl::RedeemerTag,
+pub struct RedeemerWithExtraInfo {
+    pub redeemer: Redeemer,
+    pub tag: csl::RedeemerTag,
     pub index: u64,
 }
 
-impl TryFromPLA<RedeemerWithExtraInfo<'_>> for csl::Redeemer {
-    fn try_from_pla<'a>(val: &RedeemerWithExtraInfo<'_>) -> Result<csl::Redeemer, TryFromPLAError> {
-        let Redeemer(plutus_data) = val.redeemer;
+impl TryFromPLA<RedeemerWithExtraInfo> for csl::Redeemer {
+    fn try_from_pla<'a>(val: &RedeemerWithExtraInfo) -> Result<csl::Redeemer, TryFromPLAError> {
+        let Redeemer(plutus_data) = &val.redeemer;
         Ok(csl::Redeemer::new(
-            val.tag,
+            &val.tag,
             &val.index.try_to_csl()?,
             &plutus_data.try_to_csl()?,
             &csl::ExUnits::new(&csl::BigNum::from(0u64), &csl::BigNum::from(0u64)),

plutus-ledger-api/src/v2/transaction.rs

@@ -85,18 +85,18 @@ impl TryFromCSL<csl::TransactionOutputs> for Vec<TransactionOutput> {
 }
 
 #[derive(Clone, Debug)]
-pub struct TransactionOutputWithExtraInfo<'a> {
-    pub transaction_output: &'a TransactionOutput,
-    pub scripts: &'a BTreeMap<ScriptHash, csl::PlutusScript>,
+pub struct TransactionOutputWithExtraInfo {
+    pub transaction_output: TransactionOutput,
+    pub scripts: BTreeMap<ScriptHash, csl::PlutusScript>,
     pub network_id: u8,
-    pub data_cost: &'a csl::DataCost,
+    pub data_cost: csl::DataCost,
 }
 
-impl TryFromPLA<TransactionOutputWithExtraInfo<'_>> for csl::TransactionOutput {
-    fn try_from_pla(val: &TransactionOutputWithExtraInfo<'_>) -> Result<Self, TryFromPLAError> {
+impl TryFromPLA<TransactionOutputWithExtraInfo> for csl::TransactionOutput {
+    fn try_from_pla(val: &TransactionOutputWithExtraInfo) -> Result<Self, TryFromPLAError> {
         let mut output_builder = csl::TransactionOutputBuilder::new().with_address(
             &AddressWithExtraInfo {
-                address: &val.transaction_output.address,
+                address: val.transaction_output.address.clone(),
                 network_tag: val.network_id,
             }
             .try_to_csl()?,
@@ -127,7 +127,7 @@ impl TryFromPLA<TransactionOutputWithExtraInfo<'_>> for csl::TransactionOutput {
 
         let value_without_min_utxo = val.transaction_output.value.try_to_csl()?;
 
-        let mut calc = csl::MinOutputAdaCalculator::new_empty(val.data_cost)
+        let mut calc = csl::MinOutputAdaCalculator::new_empty(&val.data_cost)
             .map_err(TryFromPLAError::CSLJsError)?;
         calc.set_amount(&value_without_min_utxo);
         match &val.transaction_output.datum {
@@ -204,13 +204,13 @@ pub struct TransactionInfo {
 }
 
 #[derive(Clone, Debug)]
-pub struct WithdrawalsWithExtraInfo<'a> {
-    pub withdrawals: &'a AssocMap<StakingCredential, BigInt>,
+pub struct WithdrawalsWithExtraInfo {
+    pub withdrawals: AssocMap<StakingCredential, BigInt>,
     pub network_tag: u8,
 }
 
-impl TryFromPLA<WithdrawalsWithExtraInfo<'_>> for csl::Withdrawals {
-    fn try_from_pla(val: &WithdrawalsWithExtraInfo<'_>) -> Result<Self, TryFromPLAError> {
+impl TryFromPLA<WithdrawalsWithExtraInfo> for csl::Withdrawals {
+    fn try_from_pla(val: &WithdrawalsWithExtraInfo) -> Result<Self, TryFromPLAError> {
         val.withdrawals
             .0
             .iter()

plutus-ledger-api/tests/csl.rs

@@ -124,7 +124,7 @@ mod csl_pla_roundtrip_tests {
       #[test]
       fn test_address(val in arb_address()) {
         prop_assert_eq!(
-            Address::try_from_csl(&val.with_extra_info(1).try_to_csl()?)?,
+            Address::try_from_csl(&val.clone().with_extra_info(1).try_to_csl()?)?,
             val
         )
       }

plutus-ledger-api/tests/display.rs

@@ -140,7 +140,7 @@ mod display_serialisation_tests {
 
             #[test]
             fn address(val in arb_address()) {
-                let roundtripped = Address::from_str(&val.with_extra_info(0).to_string()).unwrap();
+                let roundtripped = Address::from_str(&val.clone().with_extra_info(0).to_string()).unwrap();
 
                 assert_eq!(val, roundtripped);
             }