Sulkta-Coop/pallas
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

fix(traverse): use Conway types in places they are meant to (#499)

Browse source
This commit is contained in:
Matthias Benkort 2024-08-08 13:33:10 +02:00 • committed by GitHub
parent 3e2c657f20
commit 5c18f06fa2
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
8 changed files with 78 additions and 22 deletions
Download patch file Download diff file Expand all files Collapse all files

22
pallas-codec/src/utils.rs
View file

@ -175,6 +175,22 @@ where
Indef(Vec<(K, V)>),
}
impl<K, V> IntoIterator for NonEmptyKeyValuePairs<K, V>
where
K: Clone,
V: Clone,
{
type Item = (K, V);
type IntoIter = std::vec::IntoIter<Self::Item>;
fn into_iter(self) -> Self::IntoIter {
match self {
NonEmptyKeyValuePairs::Def(pairs) => pairs.into_iter(),
NonEmptyKeyValuePairs::Indef(pairs) => pairs.into_iter(),
}
}
}
impl<K, V> NonEmptyKeyValuePairs<K, V>
where
K: Clone,
@ -911,6 +927,12 @@ impl From<PositiveCoin> 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<Self, minicbor::decode::Error> {
let n = d.decode_with(ctx)?;

13
pallas-primitives/src/babbage/model.rs
View file

@ -370,24 +370,25 @@ impl<'b> From<MintedTransactionOutput<'b>> for TransactionOutput {
#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone)]
#[cbor(map)]
pub struct PseudoPostAlonzoTransactionOutput<T1, T2> {
pub struct PseudoPostAlonzoTransactionOutput<T1, T2, T3> {
#[n(0)]
pub address: Bytes,
#[n(1)]
pub value: Value,
pub value: T1,
#[n(2)]
pub datum_option: Option<T1>,
pub datum_option: Option<T2>,
#[n(3)]
pub script_ref: Option<CborWrap<T2>>,
pub script_ref: Option<CborWrap<T3>>,
}
pub type PostAlonzoTransactionOutput = PseudoPostAlonzoTransactionOutput<DatumOption, ScriptRef>;
pub type PostAlonzoTransactionOutput =
PseudoPostAlonzoTransactionOutput<Value, DatumOption, ScriptRef>;
pub type MintedPostAlonzoTransactionOutput<'b> =
PseudoPostAlonzoTransactionOutput<MintedDatumOption<'b>, MintedScriptRef<'b>>;
PseudoPostAlonzoTransactionOutput<Value, MintedDatumOption<'b>, MintedScriptRef<'b>>;
impl<'b> From<MintedPostAlonzoTransactionOutput<'b>> for PostAlonzoTransactionOutput {
fn from(value: MintedPostAlonzoTransactionOutput<'b>) -> Self {

16
pallas-primitives/src/conway/model.rs
View file

@ -45,7 +45,7 @@ pub use crate::alonzo::AssetName;
pub type Multiasset<A> = NonEmptyKeyValuePairs<PolicyId, NonEmptyKeyValuePairs<AssetName, A>>;
pub use crate::alonzo::Mint;
pub type Mint = Multiasset<NonZeroInt>;
pub use crate::alonzo::Coin;
@ -720,7 +720,7 @@ pub struct PseudoTransactionBody<T1> {
pub certificates: Option<NonEmptySet<Certificate>>,
#[n(5)]
pub withdrawals: Option<KeyValuePairs<RewardAccount, Coin>>, // TODO: NON EMPTY
pub withdrawals: Option<NonEmptyKeyValuePairs<RewardAccount, Coin>>,
#[n(7)]
pub auxiliary_data_hash: Option<Bytes>,
@ -1220,7 +1220,8 @@ where
}
}
pub use crate::babbage::PseudoPostAlonzoTransactionOutput;
pub type PostAlonzoTransactionOutput =
crate::babbage::PseudoPostAlonzoTransactionOutput<Value, DatumOption, ScriptRef>;
pub type TransactionOutput = PseudoTransactionOutput<PostAlonzoTransactionOutput>;
@ -1236,10 +1237,11 @@ impl<'b> From<MintedTransactionOutput<'b>> for TransactionOutput {
}
}
pub type PostAlonzoTransactionOutput = PseudoPostAlonzoTransactionOutput<DatumOption, ScriptRef>;
pub type MintedPostAlonzoTransactionOutput<'b> =
PseudoPostAlonzoTransactionOutput<MintedDatumOption<'b>, MintedScriptRef<'b>>;
pub type MintedPostAlonzoTransactionOutput<'b> = crate::babbage::PseudoPostAlonzoTransactionOutput<
Value,
MintedDatumOption<'b>,
MintedScriptRef<'b>,
>;
impl<'b> From<MintedPostAlonzoTransactionOutput<'b>> for PostAlonzoTransactionOutput {
fn from(value: MintedPostAlonzoTransactionOutput<'b>) -> Self {

20
pallas-traverse/src/assets.rs
View file

@ -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,
}
}

10
pallas-traverse/src/lib.rs
View file

@ -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<alonzo::AssetName, NonZeroInt>,
),
ConwayOutput(
&'b alonzo::PolicyId,
&'b NonEmptyKeyValuePairs<alonzo::AssetName, PositiveCoin>,
),
}
#[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)]

10
pallas-traverse/src/output.rs
View file

@ -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(),
},
},

8
pallas-traverse/src/tx.rs
View file

@ -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,
},
}

1
pallas-traverse/src/withdrawals.rs
View file

@ -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(),
}
}
}