griffin-core 0.3.0

UTXO framework for Substrate and Polkadot.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use core::ops::Deref;

use crate::pallas_primitives::{alonzo, conway};
use alloc::vec::Vec;

use crate::pallas_traverse::{MultiEraPolicyAssets, MultiEraValue};

impl MultiEraValue<'_> {
    pub fn into_alonzo(&self) -> alonzo::Value {
        match self {
            Self::Byron(x) => alonzo::Value::Coin(*x),
            Self::AlonzoCompatible(x) => x.deref().clone(),
            Self::Conway(x) => match x.deref() {
                conway::Value::Coin(x) => alonzo::Value::Coin(*x),
                conway::Value::Multiasset(x, assets) => {
                    let coin = *x;
                    let assets = assets
                        .iter()
                        .map(|(k, v)| {
                            let v = v.iter().map(|(k, v)| (k.clone(), v.into())).collect();
                            (*k, v)
                        })
                        .collect();

                    alonzo::Value::Multiasset(coin, assets)
                }
            },
        }
    }

    /// The amount of ADA asset expressed in Lovelace unit
    ///
    /// The value returned provides the amount of the ADA in a particular
    /// output. The value is expressed in 'lovelace' (1 ADA = 1,000,000
    /// lovelace).
    pub fn coin(&self) -> u64 {
        match self {
            Self::Byron(x) => *x,
            Self::AlonzoCompatible(x) => match x.deref() {
                alonzo::Value::Coin(c) => *c,
                alonzo::Value::Multiasset(c, _) => *c,
            },
            Self::Conway(x) => match x.deref() {
                conway::Value::Coin(c) => *c,
                conway::Value::Multiasset(c, _) => *c,
            },
        }
    }

    /// List of native assets in the output
    ///
    /// Returns a list of Asset structs where each one represent a native asset
    /// present in the output of the tx. ADA assets are not included in this
    /// list.
    pub fn assets(&self) -> Vec<MultiEraPolicyAssets<'_>> {
        match self {
            Self::Byron(_) => vec![],
            Self::AlonzoCompatible(x) => match x.deref() {
                alonzo::Value::Coin(_) => vec![],
                alonzo::Value::Multiasset(_, x) => x
                    .iter()
                    .map(|(k, v)| MultiEraPolicyAssets::AlonzoCompatibleOutput(k, v))
                    .collect(),
            },
            Self::Conway(x) => match x.deref() {
                conway::Value::Coin(_) => vec![],
                conway::Value::Multiasset(_, x) => x
                    .iter()
                    .map(|(k, v)| MultiEraPolicyAssets::ConwayOutput(k, v))
                    .collect(),
            },
        }
    }
}