WithExtra types use Cow

Author: szg251

plutus-ledger-api/CHANGELOG.md

@@ -20,6 +20,8 @@ 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 using Cow under the hood, allowing ownership of
+  the data
 
 ## 3.1.0
 

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

@@ -1,4 +1,5 @@
 //! Types related to Cardano addresses
+use std::borrow::Cow;
 use std::str::FromStr;
 
 use anyhow::anyhow;
@@ -41,7 +42,14 @@ pub struct Address {
 impl Address {
     pub fn with_extra_info<'a>(&'a self, network_tag: u8) -> AddressWithExtraInfo<'a> {
         AddressWithExtraInfo {
-            address: self,
+            address: Cow::Borrowed(self),
+            network_tag,
+        }
+    }
+
+    pub fn into_address_with_extra_info<'a>(self, network_tag: u8) -> AddressWithExtraInfo<'a> {
+        AddressWithExtraInfo {
+            address: Cow::Owned(self),
             network_tag,
         }
     }
@@ -90,7 +98,7 @@ impl TryFromCSL<csl::Address> for Address {
 /// 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 address: Cow<'a, Address>,
     pub network_tag: u8,
 }
 
@@ -113,6 +121,22 @@ impl TryFromPLA<AddressWithExtraInfo<'_>> for csl::Address {
     }
 }
 
+impl<'a> TryFromCSL<csl::Address> for AddressWithExtraInfo<'a> {
+    fn try_from_csl(value: &csl::Address) -> Result<Self, TryFromCSLError>
+    where
+        Self: Sized,
+    {
+        Ok(AddressWithExtraInfo {
+            address: Cow::Owned(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<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -334,15 +358,15 @@ impl FromCSL<csl::Pointer> for StakingCredential {
 
 #[derive(Clone, Debug)]
 pub struct RewardAddressWithExtraInfo<'a> {
-    pub staking_credential: &'a StakingCredential,
+    pub staking_credential: Cow<'a, StakingCredential>,
     pub network_tag: u8,
 }
 
 impl TryFromPLA<RewardAddressWithExtraInfo<'_>> for csl::RewardAddress {
     fn try_from_pla(val: &RewardAddressWithExtraInfo<'_>) -> Result<Self, TryFromPLAError> {
         Ok(csl::RewardAddress::new(
             val.network_tag,
-            &val.staking_credential.try_to_csl()?,
+            &val.staking_credential.as_ref().try_to_csl()?,
         ))
     }
 }

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

@@ -1,5 +1,7 @@
 //! Types related to Plutus Redeemers
 
+use std::borrow::Cow;
+
 use cardano_serialization_lib as csl;
 
 #[cfg(feature = "lbf")]
@@ -26,16 +28,16 @@ pub struct Redeemer(pub PlutusData);
 
 #[derive(Clone, Debug)]
 pub struct RedeemerWithExtraInfo<'a> {
-    pub redeemer: &'a Redeemer,
-    pub tag: &'a csl::RedeemerTag,
+    pub redeemer: Cow<'a, 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;
+        let Redeemer(plutus_data) = val.redeemer.as_ref();
         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

@@ -1,5 +1,6 @@
 //! Types related to Cardano transactions.
 
+use std::borrow::Cow;
 use std::collections::BTreeMap;
 
 use cardano_serialization_lib as csl;
@@ -86,17 +87,17 @@ 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 transaction_output: Cow<'a, TransactionOutput>,
+    pub scripts: Cow<'a, BTreeMap<ScriptHash, csl::PlutusScript>>,
     pub network_id: u8,
-    pub data_cost: &'a csl::DataCost,
+    pub data_cost: Cow<'a, csl::DataCost>,
 }
 
 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: Cow::Borrowed(&val.transaction_output.address),
                 network_tag: val.network_id,
             }
             .try_to_csl()?,
@@ -127,7 +128,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.as_ref())
             .map_err(TryFromPLAError::CSLJsError)?;
         calc.set_amount(&value_without_min_utxo);
         match &val.transaction_output.datum {
@@ -205,7 +206,7 @@ pub struct TransactionInfo {
 
 #[derive(Clone, Debug)]
 pub struct WithdrawalsWithExtraInfo<'a> {
-    pub withdrawals: &'a AssocMap<StakingCredential, BigInt>,
+    pub withdrawals: Cow<'a, AssocMap<StakingCredential, BigInt>>,
     pub network_tag: u8,
 }
 
@@ -217,7 +218,7 @@ impl TryFromPLA<WithdrawalsWithExtraInfo<'_>> for csl::Withdrawals {
             .try_fold(csl::Withdrawals::new(), |mut acc, (s, q)| {
                 acc.insert(
                     &RewardAddressWithExtraInfo {
-                        staking_credential: s,
+                        staking_credential: Cow::Borrowed(s),
                         network_tag: val.network_tag,
                     }
                     .try_to_csl()?,