error::{DeserializeError, DeserializeFailure, Key},
serialization::{fit_sz, Deserialize, Serialize, StringEncoding, LenEncoding, CBORReadLen},
-
ordered_hash_map::OrderedHashMap,
+
ordered_hash_map::OrderedHashMap, ArithmeticError,
use cml_crypto::RawBytesEncoding;
use std::{io::{BufRead, Seek, Write}};
+
#[derive(Debug, thiserror::Error)]
+
pub enum AssetArithmeticError {
+
#[error("Arithmetic failed: {0}")]
+
Arithmetic(#[from] ArithmeticError),
+
#[error("Asset {0:?} doesn't exist")]
+
AssetDoesntExist(AssetName),
+
#[error("PolicyId {0:?} doesn't exist")]
+
PolicyIdDoesntExist(PolicyId),
/// Bundle of assets within range of T, grouped by PolicyID then AssetName
-
#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
+
#[derive(Clone, Default, PartialEq, Hash, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
pub struct AssetBundle<T>(OrderedHashMap<PolicyId, OrderedHashMap<AssetName, T>>);
+
impl<T: std::fmt::Debug> std::fmt::Debug for AssetBundle<T> {
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+
let mut ds = f.debug_struct(if self.0.iter().any(|(_, a)| !a.is_empty()) { "" } else { "{}" });
+
for (pid, assets) in self.0.iter() {
+
let pid_hex = hex::encode(pid.to_raw_bytes());
+
for (an, val) in assets.iter() {
+
let an_hex = hex::encode(an.get());
+
let an_name = if an_hex.len() > 8 {
+
an_hex.get(0..3).unwrap(),
+
an_hex.get(an_hex.len() - 2 .. an_hex.len() - 1).unwrap())
+
pid_hex.get(0..3).unwrap(),
+
pid_hex.get(pid_hex.len() - 4..pid_hex.len() - 1).unwrap(),
+
impl<T: Default> AssetBundle<T> {
impl<T> From<OrderedHashMap<PolicyId, OrderedHashMap<AssetName, T>>> for AssetBundle<T> {
fn from(bundle: OrderedHashMap<PolicyId, OrderedHashMap<AssetName, T>>) -> Self {
/// Adds to bundles together, checking value bounds.
-
/// If an overflow would occur, returns None instead.
/// Does not modify self, and instead returns the result.
-
pub fn checked_add(&self, rhs: &Self) -> Option<Self> {
+
pub fn checked_add(&self, rhs: &Self) -> Result<Self, AssetArithmeticError> {
use linked_hash_map::Entry;
let mut bundle = self.0.clone();
-
for ma in &[&self.0, &rhs.0] {
-
for (policy, assets) in ma.iter() {
-
for (asset_name, amount) in assets.iter() {
-
match bundle.entry(policy.clone()) {
-
Entry::Occupied(mut assets) => {
-
match assets.get_mut().entry(asset_name.clone()) {
-
Entry::Occupied(mut assets) => {
-
let current = assets.get_mut();
-
*current = current.checked_add(amount)?;
-
Entry::Vacant(vacant_entry) => {
-
vacant_entry.insert(*amount);
+
for (policy, assets) in rhs.0.iter() {
+
for (asset_name, amount) in assets.iter() {
+
match bundle.entry(policy.clone()) {
+
Entry::Occupied(mut assets) => {
+
match assets.get_mut().entry(asset_name.clone()) {
+
Entry::Occupied(mut assets2) => {
+
let current = assets2.get_mut();
+
*current = current.checked_add(amount).ok_or(ArithmeticError::IntegerOverflow)?;
+
Entry::Vacant(vacant_entry) => {
+
vacant_entry.insert(*amount);
-
Entry::Vacant(entry) => {
-
let mut assets = OrderedHashMap::new();
-
assets.insert(asset_name.clone(), *amount);
+
Entry::Vacant(entry) => {
+
let mut assets = OrderedHashMap::new();
+
assets.insert(asset_name.clone(), *amount);
/// Subtracts rhs from this bundle.
/// This does not modify self, and instead returns the result.
-
/// If underflow would occur on any asset, or the asset didn't exist in self
-
/// then None is returned.
/// Use clamped_sub (ClampedSub trait) if you need to only try to remove assets when they exist
/// and ignore them when they don't.
-
pub fn checked_sub(&self, rhs: &Self) -> Option<Self> {
+
pub fn checked_sub(&self, rhs: &Self) -> Result<Self, AssetArithmeticError> {
let mut bundle = self.0.clone();
for (policy, rhs_assets) in rhs.iter() {
for (asset_name, rhs_amount) in rhs_assets.iter() {
+
return Err(ArithmeticError::IntegerUnderflow.into());
// asset name is missing from left hand side
+
return Err(AssetArithmeticError::AssetDoesntExist(asset_name.clone()));
// policy id missing from left hand side
+
return Err(AssetArithmeticError::PolicyIdDoesntExist(policy.clone()));
pub type Mint = AssetBundle<i64>;
pub type MultiAsset = AssetBundle<u64>;
-
#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
+
fn as_multiasset(&self, is_positive: bool) -> MultiAsset {
+
self.0.iter().fold(MultiAsset::default(), |mut acc, (policy, assets)| {
+
let new_assets = assets.iter().fold(OrderedHashMap::new(), |mut acc, (asset, value)| {
+
if (*value >= 0) == is_positive {
+
acc.insert(asset.clone(), value.abs() as u64);
+
if !assets.is_empty() {
+
acc.insert(policy.clone(), new_assets);
+
/// Returns the multiasset where only positive (minting) entries are present
+
pub fn as_positive_multiasset(&self) -> MultiAsset {
+
self.as_multiasset(true)
+
/// Returns the multiasset where only negative (burning) entries are present
+
pub fn as_negative_multiasset(&self) -> MultiAsset {
+
self.as_multiasset(false)
+
// note: we purposefully don't derive or implement Ord for Value to avoid potentially confusing
+
// orderings that don't obey Cardano semantics i.e. if x >= y then input x can cover cost y
+
// If you need to use Value or something in a tree map please consider using a hash map instead.
+
#[derive(Clone, Debug, derivative::Derivative, serde::Deserialize, serde::Serialize, schemars::JsonSchema)]
+
#[derivative(Hash, Eq, PartialEq, PartialOrd)]
pub multiasset: MultiAsset,
