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

use crate::internal_prelude::*;
use sbor::traversal::*;

pub fn extract_references(
    encoded: &[u8],
    expected_start: ExpectedStart<ManifestCustomValueKind>,
) -> IndexSet<Reference> {
    let mut references = index_set_new();
    let mut traverser = ManifestTraverser::new(
        encoded,
        expected_start,
        VecTraverserConfig {
            max_depth: MANIFEST_SBOR_V1_MAX_DEPTH,
            check_exact_end: true,
        },
    );
    loop {
        let event = traverser.next_event();
        match event.event {
            TraversalEvent::ContainerStart(_) => {}
            TraversalEvent::ContainerEnd(_) => {}
            TraversalEvent::TerminalValue(r) => {
                if let TerminalValueRef::Custom(c) = r {
                    match c.0 {
                        ManifestCustomValue::Address(address) => {
                            if let ManifestAddress::Static(node_id) = address {
                                references.insert(Reference(node_id));
                            }
                        }
                        ManifestCustomValue::Bucket(_)
                        | ManifestCustomValue::Proof(_)
                        | ManifestCustomValue::AddressReservation(_)
                        | ManifestCustomValue::Expression(_)
                        | ManifestCustomValue::Blob(_)
                        | ManifestCustomValue::Decimal(_)
                        | ManifestCustomValue::PreciseDecimal(_)
                        | ManifestCustomValue::NonFungibleLocalId(_) => {}
                    }
                }
            }
            TraversalEvent::TerminalValueBatch(_) => {}
            TraversalEvent::End => {
                break;
            }
            TraversalEvent::DecodeError(e) => {
                panic!("Unexpected decoding error: {:?}", e);
            }
        }
    }
    references
}