Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Babbage Mint handle duplicate format #327

Merged
merged 3 commits into from
Apr 30, 2024
Merged

Babbage Mint handle duplicate format #327

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
d0a5263
Babbage Mint handle duplicate format
rooooooooob Apr 30, 2024
0e8c3e7
cargo fmt on wasm too
rooooooooob Apr 30, 2024
e4647bc
add comment to babbage.cddl
rooooooooob Apr 30, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 1 addition & 5 deletions multi-era/rust/src/babbage/cbor_encodings.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
// This file was code-generated using an experimental CDDL to rust tool:
// https://github.com/dcSpark/cddl-codegen

use cml_chain::{address::RewardAccount, assets::AssetName, PolicyId};
use cml_chain::address::RewardAccount;
use cml_core::serialization::{LenEncoding, StringEncoding};
use cml_crypto::GenesisHash;
use std::collections::BTreeMap;
Expand Down Expand Up @@ -117,10 +117,6 @@ pub struct BabbageTransactionBodyEncoding {
pub auxiliary_data_hash_key_encoding: Option<cbor_event::Sz>,
pub validity_interval_start_encoding: Option<cbor_event::Sz>,
pub validity_interval_start_key_encoding: Option<cbor_event::Sz>,
pub mint_encoding: LenEncoding,
pub mint_key_encodings: BTreeMap<PolicyId, StringEncoding>,
pub mint_value_encodings:
BTreeMap<PolicyId, (LenEncoding, BTreeMap<AssetName, Option<cbor_event::Sz>>)>,
pub mint_key_encoding: Option<cbor_event::Sz>,
pub script_data_hash_encoding: StringEncoding,
pub script_data_hash_key_encoding: Option<cbor_event::Sz>,
Expand Down
6 changes: 4 additions & 2 deletions multi-era/rust/src/babbage/mod.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,7 @@ use cbor_encodings::{
BabbageTransactionEncoding, BabbageTransactionWitnessSetEncoding, BabbageUpdateEncoding,
};
use cml_chain::address::Address;
use cml_chain::assets::{Coin, Mint, Value};
use cml_chain::assets::{Coin, Value};
use cml_chain::auxdata::{Metadata, ShelleyFormatAuxData, ShelleyMaFormatAuxData};
use cml_chain::block::Header;
use cml_chain::crypto::{
Expand All @@ -33,6 +33,8 @@ use cml_core::{Int, TransactionIndex};

use std::collections::BTreeMap;

use self::utils::BabbageMint;

#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
pub enum BabbageAuxiliaryData {
Shelley(ShelleyFormatAuxData),
Expand Down Expand Up @@ -316,7 +318,7 @@ pub struct BabbageTransactionBody {
pub update: Option<BabbageUpdate>,
pub auxiliary_data_hash: Option<AuxiliaryDataHash>,
pub validity_interval_start: Option<u64>,
pub mint: Option<Mint>,
pub mint: Option<BabbageMint>,
pub script_data_hash: Option<ScriptDataHash>,
pub collateral_inputs: Option<Vec<TransactionInput>>,
pub required_signers: Option<RequiredSigners>,
Expand Down
159 changes: 4 additions & 155 deletions multi-era/rust/src/babbage/serialization.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,8 +6,6 @@ use super::*;
use cbor_event::de::Deserializer;
use cbor_event::se::Serializer;
use cml_chain::address::RewardAccount;
use cml_chain::assets::AssetName;
use cml_chain::PolicyId;
use cml_core::error::*;
use cml_core::serialization::*;
use cml_crypto::Ed25519KeyHash;
Expand Down Expand Up @@ -3011,104 +3009,7 @@ impl Serialize for BabbageTransactionBody {
force_canonical,
),
)?;
serializer.write_map_sz(
self.encodings
.as_ref()
.map(|encs| encs.mint_encoding)
.unwrap_or_default()
.to_len_sz(field.len() as u64, force_canonical),
)?;
let mut key_order = field
.iter()
.map(|(k, v)| {
let mut buf = cbor_event::se::Serializer::new_vec();
let mint_key_encoding = self
.encodings
.as_ref()
.and_then(|encs| encs.mint_key_encodings.get(k))
.cloned()
.unwrap_or_default();
buf.write_bytes_sz(
k.to_raw_bytes(),
mint_key_encoding.to_str_len_sz(
k.to_raw_bytes().len() as u64,
force_canonical,
),
)?;
Ok((buf.finalize(), k, v))
})
.collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
if force_canonical {
key_order.sort_by(
|(lhs_bytes, _, _), (rhs_bytes, _, _)| match lhs_bytes
.len()
.cmp(&rhs_bytes.len())
{
std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
diff_ord => diff_ord,
},
);
}
for (key_bytes, key, value) in key_order {
serializer.write_raw_bytes(&key_bytes)?;
let (mint_value_encoding, mint_value_value_encodings) = self
.encodings
.as_ref()
.and_then(|encs| encs.mint_value_encodings.get(key))
.cloned()
.unwrap_or_else(|| (LenEncoding::default(), BTreeMap::new()));
serializer.write_map_sz(
mint_value_encoding.to_len_sz(value.len() as u64, force_canonical),
)?;
let mut key_order = value
.iter()
.map(|(k, v)| {
let mut buf = cbor_event::se::Serializer::new_vec();
k.serialize(&mut buf, force_canonical)?;
Ok((buf.finalize(), k, v))
})
.collect::<Result<Vec<(Vec<u8>, &_, &_)>, cbor_event::Error>>()?;
if force_canonical {
key_order.sort_by(|(lhs_bytes, _, _), (rhs_bytes, _, _)| {
match lhs_bytes.len().cmp(&rhs_bytes.len()) {
std::cmp::Ordering::Equal => lhs_bytes.cmp(rhs_bytes),
diff_ord => diff_ord,
}
});
}
for (key_bytes, key, value) in key_order {
serializer.write_raw_bytes(&key_bytes)?;
let mint_value_value_encoding = mint_value_value_encodings
.get(key)
.cloned()
.unwrap_or_default();
if *value >= 0 {
serializer.write_unsigned_integer_sz(
*value as u64,
fit_sz(
*value as u64,
mint_value_value_encoding,
force_canonical,
),
)?;
} else {
serializer.write_negative_integer_sz(
*value as i128,
fit_sz(
(*value + 1).unsigned_abs(),
mint_value_value_encoding,
force_canonical,
),
)?;
}
}
mint_value_encoding.end(serializer, force_canonical)?;
}
self.encodings
.as_ref()
.map(|encs| encs.mint_encoding)
.unwrap_or_default()
.end(serializer, force_canonical)?;
field.serialize(serializer, force_canonical)?;
}
}
10 => {
Expand Down Expand Up @@ -3340,9 +3241,6 @@ impl Deserialize for BabbageTransactionBody {
let mut validity_interval_start_encoding = None;
let mut validity_interval_start_key_encoding = None;
let mut validity_interval_start = None;
let mut mint_encoding = LenEncoding::default();
let mut mint_key_encodings = BTreeMap::new();
let mut mint_value_encodings = BTreeMap::new();
let mut mint_key_encoding = None;
let mut mint = None;
let mut script_data_hash_encoding = StringEncoding::default();
Expand Down Expand Up @@ -3531,57 +3429,11 @@ impl Deserialize for BabbageTransactionBody {
if mint.is_some() {
return Err(DeserializeFailure::DuplicateKey(Key::Uint(9)).into());
}
let (tmp_mint, tmp_mint_encoding, tmp_mint_key_encodings, tmp_mint_value_encodings) = (|| -> Result<_, DeserializeError> {
let tmp_mint = (|| -> Result<_, DeserializeError> {
read_len.read_elems(1)?;
let mut mint_table = OrderedHashMap::new();
let mint_len = raw.map_sz()?;
let mint_encoding = mint_len.into();
let mut mint_key_encodings = BTreeMap::new();
let mut mint_value_encodings = BTreeMap::new();
while match mint_len { cbor_event::LenSz::Len(n, _) => (mint_table.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
if raw.cbor_type()? == cbor_event::Type::Special {
assert_eq!(raw.special()?, cbor_event::Special::Break);
break;
}
let (mint_key, mint_key_encoding) = raw.bytes_sz().map_err(Into::<DeserializeError>::into).and_then(|(bytes, enc)| PolicyId::from_raw_bytes(&bytes).map(|bytes| (bytes, StringEncoding::from(enc))).map_err(|e| DeserializeFailure::InvalidStructure(Box::new(e)).into()))?;
let mut mint_value_table = OrderedHashMap::new();
let mint_value_len = raw.map_sz()?;
let mint_value_encoding = mint_value_len.into();
let mut mint_value_value_encodings = BTreeMap::new();
while match mint_value_len { cbor_event::LenSz::Len(n, _) => (mint_value_table.len() as u64) < n, cbor_event::LenSz::Indefinite => true, } {
if raw.cbor_type()? == cbor_event::Type::Special {
assert_eq!(raw.special()?, cbor_event::Special::Break);
break;
}
let mint_value_key = AssetName::deserialize(raw)?;
let (mint_value_value, mint_value_value_encoding) = match raw.cbor_type()? {
cbor_event::Type::UnsignedInteger => {
let (x, enc) = raw.unsigned_integer_sz()?;
(x as i64, Some(enc))
},
_ => {
let (x, enc) = raw.negative_integer_sz()?;
(x as i64, Some(enc))
},
};
if mint_value_table.insert(mint_value_key.clone(), mint_value_value).is_some() {
return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
}
mint_value_value_encodings.insert(mint_value_key, mint_value_value_encoding);
}
let (mint_value, mint_value_encoding, mint_value_value_encodings) = (mint_value_table, mint_value_encoding, mint_value_value_encodings);
if mint_table.insert(mint_key, mint_value).is_some() {
return Err(DeserializeFailure::DuplicateKey(Key::Str(String::from("some complicated/unsupported type"))).into());
}
mint_key_encodings.insert(mint_key, mint_key_encoding);
mint_value_encodings.insert(mint_key, (mint_value_encoding, mint_value_value_encodings));
}
Ok((mint_table, mint_encoding, mint_key_encodings, mint_value_encodings))
BabbageMint::deserialize(raw)
})().map_err(|e| e.annotate("mint"))?;
mint = Some(tmp_mint);
mint_encoding = tmp_mint_encoding;
mint_key_encodings = tmp_mint_key_encodings;
mint_value_encodings = tmp_mint_value_encodings;
mint_key_encoding = Some(key_enc);
orig_deser_order.push(9);
},
Expand Down Expand Up @@ -3745,7 +3597,7 @@ impl Deserialize for BabbageTransactionBody {
update,
auxiliary_data_hash,
validity_interval_start,
mint: mint.map(Into::into),
mint,
script_data_hash,
collateral_inputs,
required_signers,
Expand Down Expand Up @@ -3775,9 +3627,6 @@ impl Deserialize for BabbageTransactionBody {
validity_interval_start_key_encoding,
validity_interval_start_encoding,
mint_key_encoding,
mint_encoding,
mint_key_encodings,
mint_value_encodings,
script_data_hash_key_encoding,
script_data_hash_encoding,
collateral_inputs_key_encoding,
Expand Down
Loading
Loading