radix-transactions 1.3.1

Various Radix transaction models and the manifest compiler/decompiler, from the Radix DLT project.
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use crate::internal_prelude::*;
use radix_common::prelude::*;

pub trait IsTransactionHashWithStaticHrp: IsHash {
    fn static_hrp(hrp_set: &HrpSet) -> &str;
}

pub enum HashCreationError {
    InvalidHrp,
}

pub trait IsTransactionHash: Sized {
    fn hrp<'h>(&self, hrp_set: &'h HrpSet) -> &'h str;
    fn create_from_hrp_and_hash(
        hrp: &str,
        hash: Hash,
        hrp_set: &HrpSet,
    ) -> Result<Self, HashCreationError>;
    fn as_inner_hash(&self) -> &Hash;
}

impl<H: IsTransactionHashWithStaticHrp> IsTransactionHash for H {
    fn hrp<'h>(&self, hrp_set: &'h HrpSet) -> &'h str {
        Self::static_hrp(hrp_set)
    }

    fn create_from_hrp_and_hash(
        hrp: &str,
        hash: Hash,
        hrp_set: &HrpSet,
    ) -> Result<Self, HashCreationError> {
        if Self::static_hrp(hrp_set) == hrp {
            Ok(Self::from(hash))
        } else {
            Err(HashCreationError::InvalidHrp)
        }
    }

    fn as_inner_hash(&self) -> &Hash {
        self.as_hash()
    }
}

impl IsTransactionHashWithStaticHrp for TransactionIntentHash {
    fn static_hrp(hrp_set: &HrpSet) -> &str {
        &hrp_set.transaction_intent
    }
}

impl IsTransactionHashWithStaticHrp for SignedTransactionIntentHash {
    fn static_hrp(hrp_set: &HrpSet) -> &str {
        &hrp_set.signed_transaction_intent
    }
}

impl IsTransactionHashWithStaticHrp for SubintentHash {
    fn static_hrp(hrp_set: &HrpSet) -> &str {
        &hrp_set.subintent
    }
}

impl IsTransactionHash for IntentHash {
    fn hrp<'h>(&self, hrp_set: &'h HrpSet) -> &'h str {
        match self {
            IntentHash::Transaction(_) => TransactionIntentHash::static_hrp(hrp_set),
            IntentHash::Subintent(_) => SubintentHash::static_hrp(hrp_set),
        }
    }

    fn create_from_hrp_and_hash(
        hrp: &str,
        hash: Hash,
        hrp_set: &HrpSet,
    ) -> Result<Self, HashCreationError> {
        if hrp == TransactionIntentHash::static_hrp(hrp_set) {
            Ok(IntentHash::Transaction(TransactionIntentHash::from(hash)))
        } else if hrp == SubintentHash::static_hrp(hrp_set) {
            Ok(IntentHash::Subintent(SubintentHash::from(hash)))
        } else {
            Err(HashCreationError::InvalidHrp)
        }
    }

    fn as_inner_hash(&self) -> &Hash {
        match self {
            IntentHash::Transaction(inner) => inner.as_hash(),
            IntentHash::Subintent(inner) => inner.as_hash(),
        }
    }
}

impl IsTransactionHashWithStaticHrp for NotarizedTransactionHash {
    fn static_hrp(hrp_set: &HrpSet) -> &str {
        &hrp_set.notarized_transaction
    }
}

impl IsTransactionHashWithStaticHrp for SystemTransactionHash {
    fn static_hrp(hrp_set: &HrpSet) -> &str {
        &hrp_set.system_transaction
    }
}