Merge pull request #311 from pragma-org/jshy/collateral

Collateral Validations

Author: yHSJ

crates/amaru-kernel/src/lib.rs

@@ -26,13 +26,15 @@ use pallas_addresses::{
     byron::{AddrAttrProperty, AddressPayload},
     *,
 };
-use pallas_primitives::{
-    alonzo::Value as AlonzoValue,
-    conway::{MintedPostAlonzoTransactionOutput, NativeScript},
-};
+use pallas_primitives::conway::{MintedPostAlonzoTransactionOutput, NativeScript, RedeemerTag};
 use sha3::{Digest as _, Sha3_256};
 use std::{
-    array::TryFromSliceError, borrow::Cow, collections::BTreeMap, fmt::Debug, ops::Deref, sync::Arc,
+    array::TryFromSliceError,
+    borrow::Cow,
+    collections::BTreeMap,
+    fmt::{self, Debug, Formatter},
+    ops::Deref,
+    sync::Arc,
 };
 
 pub use amaru_minicbor_extra::*;
@@ -50,20 +52,21 @@ pub use pallas_crypto::{
     key::ed25519,
 };
 pub use pallas_primitives::{
-    AssetName, BigInt, Constr, DatumHash, DnsName, IPv4, IPv6, MaybeIndefArray, PlutusData,
-    PlutusScript, PolicyId, Port, PositiveCoin,
+    alonzo::Value as AlonzoValue,
     babbage::{Header, MintedHeader, PseudoHeader},
     conway::{
-        AddrKeyhash, AuxiliaryData, Block, BootstrapWitness, Certificate, Coin, Constitution,
-        CostModel, CostModels, DRep, DRepVotingThresholds, DatumOption, ExUnitPrices, ExUnits,
-        GovAction, HeaderBody, KeepRaw, Language, MintedBlock, MintedDatumOption, MintedScriptRef,
-        MintedTransactionBody, MintedTransactionOutput, MintedTx, MintedWitnessSet, Multiasset,
-        NonEmptySet, NonZeroInt, PoolMetadata, PoolVotingThresholds, PostAlonzoTransactionOutput,
+        AddrKeyhash, AssetName, AuxiliaryData, BigInt, Block, BootstrapWitness, Certificate, Coin,
+        Constitution, Constr, CostModel, CostModels, DRep, DRepVotingThresholds, DatumHash,
+        DatumOption, DnsName, ExUnitPrices, ExUnits, GovAction, GovActionId as ProposalId,
+        HeaderBody, IPv4, IPv6, KeepRaw, Language, MaybeIndefArray, MintedBlock, MintedDatumOption,
+        MintedScriptRef, MintedTransactionBody, MintedTransactionOutput, MintedTx,
+        MintedWitnessSet, Multiasset, NonEmptySet, NonZeroInt, PlutusData, PlutusScript, PolicyId,
+        PoolMetadata, PoolVotingThresholds, Port, PositiveCoin, PostAlonzoTransactionOutput,
         ProposalProcedure as Proposal, ProtocolParamUpdate, ProtocolVersion, PseudoScript,
-        PseudoTransactionOutput, RationalNumber, Redeemer, RedeemerTag, Redeemers,
-        RedeemersKey as RedeemerKey, Relay, RewardAccount, ScriptHash, ScriptRef, StakeCredential,
-        TransactionBody, TransactionInput, TransactionOutput, Tx, UnitInterval, VKeyWitness, Value,
-        Vote, Voter, VotingProcedure, VotingProcedures, VrfKeyhash, WitnessSet,
+        PseudoTransactionOutput, RationalNumber, Redeemer, Redeemers, RedeemersKey as RedeemerKey,
+        Relay, RewardAccount, ScriptHash, ScriptRef, StakeCredential, TransactionBody,
+        TransactionInput, TransactionOutput, Tx, UnitInterval, VKeyWitness, Value, Vote, Voter,
+        VotingProcedure, VotingProcedures, VrfKeyhash, WitnessSet,
     },
 };
 pub use pallas_traverse::{ComputeHash, OriginalHash};
@@ -266,6 +269,29 @@ impl From<&[u8]> for RawBlock {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct TransactionInputAdapter(TransactionInput);
+
+impl Deref for TransactionInputAdapter {
+    type Target = TransactionInput;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl std::fmt::Display for TransactionInputAdapter {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}#{}", self.0.transaction_id, self.0.index)
+    }
+}
+
+impl From<TransactionInput> for TransactionInputAdapter {
+    fn from(value: TransactionInput) -> Self {
+        Self(value)
+    }
+}
+
 pub type TransactionId = Hash<32>;
 
 pub type PoolId = Hash<28>;

crates/amaru-kernel/src/memoized/transaction_output.rs

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use pallas_primitives::{Bytes, Hash, PolicyId, PositiveCoin, conway::Multiasset};
+
 use crate::{
     Address, AlonzoValue, AssetName, KeyValuePairs, Lovelace, MemoizedDatum, MemoizedNativeScript,
     MemoizedPlutusData, MemoizedScript, MintedTransactionOutput, NonEmptyKeyValuePairs,
@@ -338,11 +340,57 @@ fn serialize_value<S: serde::ser::Serializer>(
     }
 }
 
-// FIXME: Eventually allow deserializing complete values, not just coins.
 fn deserialize_value<'de, D: serde::de::Deserializer<'de>>(
     deserializer: D,
 ) -> Result<Value, D::Error> {
-    Ok(Value::Coin(serde::Deserialize::deserialize(deserializer)?))
+    #[derive(serde::Deserialize)]
+    enum ValueHelper {
+        Coin(u64),
+        Multiasset(u64, Vec<(String, Vec<(String, u64)>)>),
+    }
+
+    let helper: ValueHelper = serde::Deserialize::deserialize(deserializer)?;
+
+    match helper {
+        ValueHelper::Coin(coin) => Ok(Value::Coin(coin)),
+        ValueHelper::Multiasset(coin, multiasset_data) => {
+            let mut converted_multiasset = Vec::new();
+
+            for (policy_id, assets) in multiasset_data {
+                let policy_id = hex::decode(&policy_id).map_err(|_| {
+                    serde::de::Error::custom(format!("invalid hex string: {policy_id}"))
+                })?;
+
+                let mut converted_assets = Vec::new();
+                for (asset_name, quantity) in assets {
+                    let asset_name = hex::decode(&asset_name).map_err(|_| {
+                        serde::de::Error::custom(format!("invalid hex string: {asset_name}"))
+                    })?;
+
+                    converted_assets.push((
+                        Bytes::from(asset_name),
+                        quantity.try_into().map_err(|_| {
+                            serde::de::Error::custom(format!("invalid quantity value: {quantity}"))
+                        })?,
+                    ));
+                }
+
+                let policy_id: PolicyId = Hash::from(policy_id.as_slice());
+
+                converted_multiasset.push((
+                    policy_id,
+                    NonEmptyKeyValuePairs::from_vec(converted_assets).ok_or(
+                        serde::de::Error::custom(format!("empty asset bundle: {policy_id}")),
+                    )?,
+                ));
+            }
+
+            let multiasset: Multiasset<PositiveCoin> =
+                Multiasset::from_vec(converted_multiasset)
+                    .ok_or(serde::de::Error::custom("empty multiasset"))?;
+            Ok(Value::Multiasset(coin, multiasset))
+        }
+    }
 }
 
 pub fn serialize_script<S: serde::ser::Serializer>(

crates/amaru-ledger/src/rules/transaction.rs

@@ -30,6 +30,9 @@ pub use fees::InvalidFees;
 pub mod inputs;
 pub use inputs::InvalidInputs;
 
+pub mod collateral;
+pub use collateral::InvalidCollateral;
+
 pub mod metadata;
 pub use metadata::InvalidTransactionMetadata;
 
@@ -74,6 +77,9 @@ pub enum InvalidTransaction {
     #[error("invalid transaction scripts: {0}")]
     Scripts(#[from] InvalidScripts),
 
+    #[error("invalid collateral: {0}")]
+    Collateral(#[from] InvalidCollateral),
+
     #[error("invalid transaction metadata: {0}")]
     Metadata(#[from] InvalidTransactionMetadata),
 }
@@ -124,12 +130,22 @@ where
             .reference_inputs
             .as_deref()
             .map(|vec| vec.as_slice()),
-        transaction_body
-            .collateral
-            .as_deref()
-            .map(|vec| vec.as_slice()),
     )?;
 
+    if transaction_witness_set.redeemer.is_some() {
+        collateral::execute(
+            context,
+            transaction_body
+                .collateral
+                .as_deref()
+                .map(|vec| vec.as_slice()),
+            transaction_body.collateral_return.as_ref(),
+            transaction_body.total_collateral,
+            transaction_body.fee,
+            protocol_parameters,
+        )?;
+    }
+
     mint::execute(context, transaction_body.mint.as_ref());
 
     outputs::execute(