daml-json 0.2.2

Daml Ledger JSON 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

use serde::{Deserialize, Serialize};
use serde_json::Value;

/// Daml JSON API representation of a ledger event.
#[derive(Debug, Serialize, Deserialize)]
pub enum DamlJsonEvent {
    #[serde(rename = "created")]
    Created(DamlJsonCreatedEvent),
    #[serde(rename = "archived")]
    Archived(DamlJsonArchivedEvent),
}

/// Daml JSON API representation of a ledger contract created event.
#[derive(Debug, Serialize, Deserialize)]
pub struct DamlJsonCreatedEvent {
    pub observers: Vec<String>,
    #[serde(rename = "agreementText")]
    pub agreement_text: String,
    pub payload: Value,
    pub signatories: Vec<String>,
    #[serde(rename = "contractId")]
    pub contract_id: String,
    #[serde(rename = "templateId")]
    pub template_id: String,
}

impl DamlJsonCreatedEvent {
    pub fn new(
        observers: Vec<String>,
        agreement_text: String,
        payload: Value,
        signatories: Vec<String>,
        contract_id: String,
        template_id: impl Into<String>,
    ) -> Self {
        Self {
            observers,
            agreement_text,
            payload,
            signatories,
            contract_id,
            template_id: template_id.into(),
        }
    }
}

/// Daml JSON API representation of a ledger contract archived event.
#[derive(Debug, Serialize, Deserialize)]
pub struct DamlJsonArchivedEvent {
    #[serde(rename = "contractId")]
    pub contract_id: String,
    #[serde(rename = "templateId")]
    pub template_id: String,
}

impl DamlJsonArchivedEvent {
    pub const fn new(contract_id: String, template_id: String) -> Self {
        Self {
            contract_id,
            template_id,
        }
    }
}

/// Daml JSON API representation of a ledger exercise result.
#[derive(Debug, Serialize, Deserialize)]
pub struct DamlJsonExerciseResult {
    #[serde(rename = "exerciseResult")]
    pub exercise_result: Value,
    pub events: Vec<DamlJsonEvent>,
}

/// Daml JSON API representation of a ledger Party.
#[derive(Debug, Serialize, Deserialize, Eq, PartialEq)]
pub struct DamlJsonParty {
    pub identifier: String,
    #[serde(rename = "displayName")]
    pub display_name: Option<String>,
    #[serde(rename = "isLocal")]
    pub is_local: bool,
}

impl DamlJsonParty {
    pub fn new<S: Into<String>>(identifier: impl Into<String>, display_name: Option<S>, is_local: bool) -> Self {
        Self {
            identifier: identifier.into(),
            display_name: display_name.map(Into::into),
            is_local,
        }
    }
}

/// Daml JSON API representation of a query.
#[derive(Debug, Serialize, Deserialize)]
pub struct DamlJsonQuery {
    #[serde(rename = "templateIds")]
    pub template_ids: Vec<String>,
    pub query: Value,
}

impl DamlJsonQuery {
    pub fn new(template_ids: Vec<String>, query: Value) -> Self {
        Self {
            template_ids,
            query,
        }
    }
}