daml-grpc 0.3.0

Daml Ledger GRPC API
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use std::time::Duration;

use crate::grpc_protobuf::com::daml::ledger::api::v2::{
    ExperimentalCommandInspectionService, ExperimentalFeatures, ExperimentalStaticTime, FeaturesDescriptor,
    OffsetCheckpointFeature, PackageFeature, PartyManagementFeature, UserManagementFeature,
};

/// Response of `VersionService.GetLedgerApiVersion`: the participant's
/// reported version string plus its feature descriptor. `features` is
/// wrapped in `Option` because non-compliant servers may omit it even
/// though the v2 spec marks it required.
#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlLedgerApiVersion {
    pub version: String,
    pub features: Option<DamlFeaturesDescriptor>,
}

/// The features advertised by a Ledger API v2 endpoint, as returned by
/// `VersionService.GetLedgerApiVersion`.
///
/// All inner fields are `Option`-wrapped because the Ledger API spec marks
/// them as required: their absence indicates a server that predates the
/// feature being reported. Clients can therefore use `Option::is_some` to
/// gate behavior on whether the participant knows about a feature at all.
#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlFeaturesDescriptor {
    pub experimental: Option<DamlExperimentalFeatures>,
    pub user_management: Option<DamlUserManagementFeature>,
    pub party_management: Option<DamlPartyManagementFeature>,
    pub offset_checkpoint: Option<DamlOffsetCheckpointFeature>,
    pub package: Option<DamlPackageFeature>,
}

impl From<FeaturesDescriptor> for DamlFeaturesDescriptor {
    fn from(f: FeaturesDescriptor) -> Self {
        Self {
            experimental: f.experimental.map(DamlExperimentalFeatures::from),
            user_management: f.user_management.map(DamlUserManagementFeature::from),
            party_management: f.party_management.map(DamlPartyManagementFeature::from),
            offset_checkpoint: f.offset_checkpoint.map(DamlOffsetCheckpointFeature::from),
            package: f.package_feature.map(DamlPackageFeature::from),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlExperimentalFeatures {
    pub static_time: Option<DamlExperimentalStaticTime>,
    pub command_inspection_service: Option<DamlExperimentalCommandInspectionService>,
}

impl From<ExperimentalFeatures> for DamlExperimentalFeatures {
    fn from(f: ExperimentalFeatures) -> Self {
        Self {
            static_time: f.static_time.map(DamlExperimentalStaticTime::from),
            command_inspection_service: f
                .command_inspection_service
                .map(DamlExperimentalCommandInspectionService::from),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlExperimentalStaticTime {
    pub supported: bool,
}

impl From<ExperimentalStaticTime> for DamlExperimentalStaticTime {
    fn from(f: ExperimentalStaticTime) -> Self {
        Self {
            supported: f.supported,
        }
    }
}

#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlExperimentalCommandInspectionService {
    pub supported: bool,
}

impl From<ExperimentalCommandInspectionService> for DamlExperimentalCommandInspectionService {
    fn from(f: ExperimentalCommandInspectionService) -> Self {
        Self {
            supported: f.supported,
        }
    }
}

#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlUserManagementFeature {
    pub supported: bool,
    /// `0` means the server enforces no per-user rights limit.
    pub max_rights_per_user: i32,
    /// `0` means the server enforces no page-size limit.
    pub max_users_page_size: i32,
}

impl From<UserManagementFeature> for DamlUserManagementFeature {
    fn from(f: UserManagementFeature) -> Self {
        Self {
            supported: f.supported,
            max_rights_per_user: f.max_rights_per_user,
            max_users_page_size: f.max_users_page_size,
        }
    }
}

#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlPartyManagementFeature {
    pub max_parties_page_size: i32,
}

impl From<PartyManagementFeature> for DamlPartyManagementFeature {
    fn from(f: PartyManagementFeature) -> Self {
        Self {
            max_parties_page_size: f.max_parties_page_size,
        }
    }
}

#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlPackageFeature {
    pub max_vetted_packages_page_size: i32,
}

impl From<PackageFeature> for DamlPackageFeature {
    fn from(f: PackageFeature) -> Self {
        Self {
            max_vetted_packages_page_size: f.max_vetted_packages_page_size,
        }
    }
}

#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlOffsetCheckpointFeature {
    pub max_offset_checkpoint_emission_delay: Duration,
}

impl From<OffsetCheckpointFeature> for DamlOffsetCheckpointFeature {
    fn from(f: OffsetCheckpointFeature) -> Self {
        Self {
            max_offset_checkpoint_emission_delay: f
                .max_offset_checkpoint_emission_delay
                .and_then(|d| Duration::try_from(d).ok())
                .unwrap_or_default(),
        }
    }
}