From 5c18f06fa224ee1f5904c4d1901a6ded6086522b Mon Sep 17 00:00:00 2001 From: Matthias Benkort <5680256+KtorZ@users.noreply.github.com> Date: Thu, 8 Aug 2024 13:33:10 +0200 Subject: [PATCH] fix(traverse): use Conway types in places they are meant to (#499) --- pallas-codec/src/utils.rs | 22 ++++++++++++++++++++++ pallas-primitives/src/babbage/model.rs | 13 +++++++------ pallas-primitives/src/conway/model.rs | 16 +++++++++------- pallas-traverse/src/assets.rs | 20 +++++++++++++++++++- pallas-traverse/src/lib.rs | 10 +++++++++- pallas-traverse/src/output.rs | 10 +++++----- pallas-traverse/src/tx.rs | 8 ++++++-- pallas-traverse/src/withdrawals.rs | 1 + 8 files changed, 78 insertions(+), 22 deletions(-) diff --git a/pallas-codec/src/utils.rs b/pallas-codec/src/utils.rs index d6a362c..0c873ec 100644 --- a/pallas-codec/src/utils.rs +++ b/pallas-codec/src/utils.rs @@ -175,6 +175,22 @@ where Indef(Vec<(K, V)>), } +impl IntoIterator for NonEmptyKeyValuePairs +where + K: Clone, + V: Clone, +{ + type Item = (K, V); + type IntoIter = std::vec::IntoIter; + + fn into_iter(self) -> Self::IntoIter { + match self { + NonEmptyKeyValuePairs::Def(pairs) => pairs.into_iter(), + NonEmptyKeyValuePairs::Indef(pairs) => pairs.into_iter(), + } + } +} + impl NonEmptyKeyValuePairs where K: Clone, @@ -911,6 +927,12 @@ impl From for u64 { } } +impl From<&PositiveCoin> for u64 { + fn from(x: &PositiveCoin) -> Self { + u64::from(*x) + } +} + impl<'b, C> minicbor::decode::Decode<'b, C> for PositiveCoin { fn decode(d: &mut minicbor::Decoder<'b>, ctx: &mut C) -> Result { let n = d.decode_with(ctx)?; diff --git a/pallas-primitives/src/babbage/model.rs b/pallas-primitives/src/babbage/model.rs index a624fe1..5e795dd 100644 --- a/pallas-primitives/src/babbage/model.rs +++ b/pallas-primitives/src/babbage/model.rs @@ -370,24 +370,25 @@ impl<'b> From> for TransactionOutput { #[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)] #[cbor(map)] -pub struct PseudoPostAlonzoTransactionOutput { +pub struct PseudoPostAlonzoTransactionOutput { #[n(0)] pub address: Bytes, #[n(1)] - pub value: Value, + pub value: T1, #[n(2)] - pub datum_option: Option, + pub datum_option: Option, #[n(3)] - pub script_ref: Option>, + pub script_ref: Option>, } -pub type PostAlonzoTransactionOutput = PseudoPostAlonzoTransactionOutput; +pub type PostAlonzoTransactionOutput = + PseudoPostAlonzoTransactionOutput; pub type MintedPostAlonzoTransactionOutput<'b> = - PseudoPostAlonzoTransactionOutput, MintedScriptRef<'b>>; + PseudoPostAlonzoTransactionOutput, MintedScriptRef<'b>>; impl<'b> From> for PostAlonzoTransactionOutput { fn from(value: MintedPostAlonzoTransactionOutput<'b>) -> Self { diff --git a/pallas-primitives/src/conway/model.rs b/pallas-primitives/src/conway/model.rs index 25d8a99..b7f7bdb 100644 --- a/pallas-primitives/src/conway/model.rs +++ b/pallas-primitives/src/conway/model.rs @@ -45,7 +45,7 @@ pub use crate::alonzo::AssetName; pub type Multiasset = NonEmptyKeyValuePairs>; -pub use crate::alonzo::Mint; +pub type Mint = Multiasset; pub use crate::alonzo::Coin; @@ -720,7 +720,7 @@ pub struct PseudoTransactionBody { pub certificates: Option>, #[n(5)] - pub withdrawals: Option>, // TODO: NON EMPTY + pub withdrawals: Option>, #[n(7)] pub auxiliary_data_hash: Option, @@ -1220,7 +1220,8 @@ where } } -pub use crate::babbage::PseudoPostAlonzoTransactionOutput; +pub type PostAlonzoTransactionOutput = + crate::babbage::PseudoPostAlonzoTransactionOutput; pub type TransactionOutput = PseudoTransactionOutput; @@ -1236,10 +1237,11 @@ impl<'b> From> for TransactionOutput { } } -pub type PostAlonzoTransactionOutput = PseudoPostAlonzoTransactionOutput; - -pub type MintedPostAlonzoTransactionOutput<'b> = - PseudoPostAlonzoTransactionOutput, MintedScriptRef<'b>>; +pub type MintedPostAlonzoTransactionOutput<'b> = crate::babbage::PseudoPostAlonzoTransactionOutput< + Value, + MintedDatumOption<'b>, + MintedScriptRef<'b>, +>; impl<'b> From> for PostAlonzoTransactionOutput { fn from(value: MintedPostAlonzoTransactionOutput<'b>) -> Self { diff --git a/pallas-traverse/src/assets.rs b/pallas-traverse/src/assets.rs index b69adff..8106221 100644 --- a/pallas-traverse/src/assets.rs +++ b/pallas-traverse/src/assets.rs @@ -8,6 +8,7 @@ impl<'b> MultiEraPolicyAssets<'b> { MultiEraPolicyAssets::AlonzoCompatibleMint(x, _) => x, MultiEraPolicyAssets::AlonzoCompatibleOutput(x, _) => x, MultiEraPolicyAssets::ConwayMint(x, _) => x, + MultiEraPolicyAssets::ConwayOutput(x, _) => x, } } @@ -16,6 +17,7 @@ impl<'b> MultiEraPolicyAssets<'b> { MultiEraPolicyAssets::AlonzoCompatibleMint(_, _) => false, MultiEraPolicyAssets::AlonzoCompatibleOutput(_, _) => true, MultiEraPolicyAssets::ConwayMint(_, _) => false, + MultiEraPolicyAssets::ConwayOutput(_, _) => true, } } @@ -24,6 +26,7 @@ impl<'b> MultiEraPolicyAssets<'b> { MultiEraPolicyAssets::AlonzoCompatibleMint(_, _) => true, MultiEraPolicyAssets::AlonzoCompatibleOutput(_, _) => false, MultiEraPolicyAssets::ConwayMint(_, _) => true, + MultiEraPolicyAssets::ConwayOutput(_, _) => false, } } @@ -41,6 +44,10 @@ impl<'b> MultiEraPolicyAssets<'b> { .iter() .map(|(k, v)| MultiEraAsset::ConwayMint(p, k, *v)) .collect(), + MultiEraPolicyAssets::ConwayOutput(p, x) => x + .iter() + .map(|(k, v)| MultiEraAsset::ConwayOutput(p, k, *v)) + .collect(), } } @@ -57,7 +64,11 @@ impl<'b> MultiEraPolicyAssets<'b> { } MultiEraPolicyAssets::ConwayMint(_, x) => x .iter() - .map(|(k, v)| (k.as_slice(), i64::from(v) as i128)) + .map(|(k, v)| (k.as_slice(), i64::from(*v) as i128)) + .collect(), + MultiEraPolicyAssets::ConwayOutput(_, x) => x + .iter() + .map(|(k, v)| (k.as_slice(), u64::from(*v) as i128)) .collect(), } } @@ -69,6 +80,7 @@ impl<'b> MultiEraAsset<'b> { MultiEraAsset::AlonzoCompatibleMint(x, ..) => x, MultiEraAsset::AlonzoCompatibleOutput(x, ..) => x, MultiEraAsset::ConwayMint(x, ..) => x, + MultiEraAsset::ConwayOutput(x, ..) => x, } } @@ -77,6 +89,7 @@ impl<'b> MultiEraAsset<'b> { MultiEraAsset::AlonzoCompatibleMint(_, x, _) => x, MultiEraAsset::AlonzoCompatibleOutput(_, x, _) => x, MultiEraAsset::ConwayMint(_, x, _) => x, + MultiEraAsset::ConwayOutput(_, x, _) => x, } } @@ -85,6 +98,7 @@ impl<'b> MultiEraAsset<'b> { MultiEraAsset::AlonzoCompatibleMint(..) => false, MultiEraAsset::AlonzoCompatibleOutput(..) => true, MultiEraAsset::ConwayMint(..) => false, + MultiEraAsset::ConwayOutput(..) => true, } } @@ -93,6 +107,7 @@ impl<'b> MultiEraAsset<'b> { MultiEraAsset::AlonzoCompatibleMint(..) => true, MultiEraAsset::AlonzoCompatibleOutput(..) => false, MultiEraAsset::ConwayMint(..) => true, + MultiEraAsset::ConwayOutput(..) => false, } } @@ -101,6 +116,7 @@ impl<'b> MultiEraAsset<'b> { MultiEraAsset::AlonzoCompatibleMint(_, _, x) => Some(*x), MultiEraAsset::AlonzoCompatibleOutput(_, _, _) => None, MultiEraAsset::ConwayMint(_, _, x) => Some(x.into()), + MultiEraAsset::ConwayOutput(_, _, _) => None, } } @@ -109,6 +125,7 @@ impl<'b> MultiEraAsset<'b> { MultiEraAsset::AlonzoCompatibleMint(_, _, _) => None, MultiEraAsset::AlonzoCompatibleOutput(_, _, x) => Some(*x), MultiEraAsset::ConwayMint(_, _, _) => None, + MultiEraAsset::ConwayOutput(_, _, x) => Some(u64::from(x)), } } @@ -117,6 +134,7 @@ impl<'b> MultiEraAsset<'b> { MultiEraAsset::AlonzoCompatibleMint(_, _, x) => *x as i128, MultiEraAsset::AlonzoCompatibleOutput(_, _, x) => *x as i128, MultiEraAsset::ConwayMint(_, _, x) => i64::from(x) as i128, + MultiEraAsset::ConwayOutput(_, _, x) => u64::from(x) as i128, } } diff --git a/pallas-traverse/src/lib.rs b/pallas-traverse/src/lib.rs index 3a7fbcd..e18054b 100644 --- a/pallas-traverse/src/lib.rs +++ b/pallas-traverse/src/lib.rs @@ -1,11 +1,13 @@ //! Utilities to traverse over multi-era block data +use pallas_codec::utils::NonZeroInt; +use pallas_codec::utils::PositiveCoin; use std::{borrow::Cow, fmt::Display, hash::Hash as StdHash}; use serde::{Deserialize, Serialize}; use thiserror::Error; -use pallas_codec::utils::{KeepRaw, KeyValuePairs, NonEmptyKeyValuePairs, NonZeroInt}; +use pallas_codec::utils::{KeepRaw, KeyValuePairs, NonEmptyKeyValuePairs}; use pallas_crypto::hash::Hash; use pallas_primitives::{alonzo, babbage, byron, conway}; @@ -145,6 +147,10 @@ pub enum MultiEraPolicyAssets<'b> { &'b alonzo::PolicyId, &'b NonEmptyKeyValuePairs, ), + ConwayOutput( + &'b alonzo::PolicyId, + &'b NonEmptyKeyValuePairs, + ), } #[derive(Debug, Clone)] @@ -152,6 +158,7 @@ pub enum MultiEraPolicyAssets<'b> { pub enum MultiEraAsset<'b> { AlonzoCompatibleOutput(&'b alonzo::PolicyId, &'b alonzo::AssetName, u64), AlonzoCompatibleMint(&'b alonzo::PolicyId, &'b alonzo::AssetName, i64), + ConwayOutput(&'b alonzo::PolicyId, &'b alonzo::AssetName, PositiveCoin), ConwayMint(&'b alonzo::PolicyId, &'b alonzo::AssetName, NonZeroInt), } @@ -161,6 +168,7 @@ pub enum MultiEraWithdrawals<'b> { NotApplicable, Empty, AlonzoCompatible(&'b alonzo::Withdrawals), + Conway(&'b conway::Withdrawals), } #[derive(Debug, Clone)] diff --git a/pallas-traverse/src/output.rs b/pallas-traverse/src/output.rs index 1f7922e..70d4ed5 100644 --- a/pallas-traverse/src/output.rs +++ b/pallas-traverse/src/output.rs @@ -188,8 +188,8 @@ impl<'b> MultiEraOutput<'b> { babbage::Value::Multiasset(c, _) => c, }, conway::MintedTransactionOutput::PostAlonzo(x) => match x.value { - babbage::Value::Coin(c) => c, - babbage::Value::Multiasset(c, _) => c, + conway::Value::Coin(c) => c, + conway::Value::Multiasset(c, _) => c, }, }, } @@ -235,10 +235,10 @@ impl<'b> MultiEraOutput<'b> { .collect(), }, conway::MintedTransactionOutput::PostAlonzo(x) => match &x.value { - babbage::Value::Coin(_) => vec![], - babbage::Value::Multiasset(_, x) => x + conway::Value::Coin(_) => vec![], + conway::Value::Multiasset(_, x) => x .iter() - .map(|(k, v)| MultiEraPolicyAssets::AlonzoCompatibleOutput(k, v)) + .map(|(k, v)| MultiEraPolicyAssets::ConwayOutput(k, v)) .collect(), }, }, diff --git a/pallas-traverse/src/tx.rs b/pallas-traverse/src/tx.rs index d427980..5161fd8 100644 --- a/pallas-traverse/src/tx.rs +++ b/pallas-traverse/src/tx.rs @@ -228,6 +228,11 @@ impl<'b> MultiEraTx<'b> { .map(|(k, v)| (k.as_slice(), *v)) .sorted_by_key(|(k, _)| *k) .collect(), + MultiEraWithdrawals::Conway(x) => x + .iter() + .map(|(k, v)| (k.as_slice(), *v)) + .sorted_by_key(|(k, _)| *k) + .collect(), } } @@ -463,9 +468,8 @@ impl<'b> MultiEraTx<'b> { None => MultiEraWithdrawals::Empty, }, MultiEraTx::Byron(_) => MultiEraWithdrawals::NotApplicable, - // TODO: non empty still compatible? MultiEraTx::Conway(x) => match &x.transaction_body.withdrawals { - Some(x) => MultiEraWithdrawals::AlonzoCompatible(x), + Some(x) => MultiEraWithdrawals::Conway(x), None => MultiEraWithdrawals::Empty, }, } diff --git a/pallas-traverse/src/withdrawals.rs b/pallas-traverse/src/withdrawals.rs index 87736fd..e840c67 100644 --- a/pallas-traverse/src/withdrawals.rs +++ b/pallas-traverse/src/withdrawals.rs @@ -27,6 +27,7 @@ impl<'b> MultiEraWithdrawals<'b> { MultiEraWithdrawals::AlonzoCompatible(x) => { x.iter().map(|(k, v)| (k.as_slice(), *v)).collect() } + MultiEraWithdrawals::Conway(x) => x.iter().map(|(k, v)| (k.as_slice(), *v)).collect(), } } }