radix_transactions/model/v1/
notarized_transaction_v1.rs

1use super::*;
2use crate::internal_prelude::*;
3
4//=================================================================================
5// NOTE:
6// See versioned.rs for tests and a demonstration for the calculation of hashes etc
7//=================================================================================
8
9#[derive(Debug, Clone, Eq, PartialEq, ManifestSbor, ScryptoDescribe, ScryptoSborAssertion)]
10#[sbor_assert(
11    fixed("FILE:notarized_transaction_v1_schema.txt"),
12    settings(allow_name_changes)
13)]
14pub struct NotarizedTransactionV1 {
15    pub signed_intent: SignedIntentV1,
16    pub notary_signature: NotarySignatureV1,
17}
18
19impl NotarizedTransactionV1 {
20    pub fn prepare_and_validate(
21        &self,
22        validator: &TransactionValidator,
23    ) -> Result<ValidatedNotarizedTransactionV1, TransactionValidationError> {
24        self.prepare(validator.preparation_settings())?
25            .validate(validator)
26    }
27
28    pub fn extract_manifests_with_names(
29        &self,
30        names: TransactionObjectNames,
31    ) -> (UserTransactionManifest, Vec<UserSubintentManifest>) {
32        let mut transaction_manifest =
33            TransactionManifestV1::from_intent(&self.signed_intent.intent);
34        transaction_manifest.set_names_if_known(names.root_intent);
35        let subintent_manifests = vec![];
36        (transaction_manifest.into(), subintent_manifests)
37    }
38}
39
40impl ResolveAsRawNotarizedTransaction for NotarizedTransactionV1 {
41    type Intermediate = RawNotarizedTransaction;
42
43    fn resolve_raw_notarized_transaction(self) -> Self::Intermediate {
44        self.to_raw().expect("Transaction should be encodable")
45    }
46}
47
48impl<'a> ResolveAsRawNotarizedTransaction for &'a NotarizedTransactionV1 {
49    type Intermediate = RawNotarizedTransaction;
50
51    fn resolve_raw_notarized_transaction(self) -> Self::Intermediate {
52        self.to_raw().expect("Transaction should be encodable")
53    }
54}
55
56impl IntoExecutable for NotarizedTransactionV1 {
57    type Error = TransactionValidationError;
58
59    fn into_executable(
60        self,
61        validator: &TransactionValidator,
62    ) -> Result<ExecutableTransaction, Self::Error> {
63        let executable = self.prepare_and_validate(validator)?.create_executable();
64        Ok(executable)
65    }
66}
67
68define_transaction_payload!(
69    NotarizedTransactionV1,
70    RawNotarizedTransaction,
71    PreparedNotarizedTransactionV1 {
72        signed_intent: PreparedSignedIntentV1,
73        notary_signature: PreparedNotarySignatureV1,
74    },
75    TransactionDiscriminator::V1Notarized,
76);
77
78impl PreparedNotarizedTransactionV1 {
79    #[allow(deprecated)]
80    pub fn end_epoch_exclusive(&self) -> Epoch {
81        self.signed_intent.intent.header.inner.end_epoch_exclusive
82    }
83
84    pub fn hashes(&self) -> UserTransactionHashes {
85        UserTransactionHashes {
86            transaction_intent_hash: self.transaction_intent_hash(),
87            signed_transaction_intent_hash: self.signed_transaction_intent_hash(),
88            notarized_transaction_hash: self.notarized_transaction_hash(),
89            non_root_subintent_hashes: Default::default(),
90        }
91    }
92
93    pub fn validate(
94        self,
95        validator: &TransactionValidator,
96    ) -> Result<ValidatedNotarizedTransactionV1, TransactionValidationError> {
97        validator.validate_notarized_v1(self)
98    }
99}
100
101impl HasTransactionIntentHash for PreparedNotarizedTransactionV1 {
102    fn transaction_intent_hash(&self) -> TransactionIntentHash {
103        self.signed_intent.transaction_intent_hash()
104    }
105}
106
107impl HasSignedTransactionIntentHash for PreparedNotarizedTransactionV1 {
108    fn signed_transaction_intent_hash(&self) -> SignedTransactionIntentHash {
109        self.signed_intent.signed_transaction_intent_hash()
110    }
111}
112
113impl HasNotarizedTransactionHash for PreparedNotarizedTransactionV1 {
114    fn notarized_transaction_hash(&self) -> NotarizedTransactionHash {
115        NotarizedTransactionHash::from_hash(self.summary.hash)
116    }
117}