cml-chain 6.2.0

Multiplatform SDK for main Cardano blockchain functionality
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

use crate::assets::Coin;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Parsing of the JSON representation of the Shelley genesis block
/// Note: for a lot of these fields, I didn't check what the max valid size is in the Haskell code
///       so I just used u64 everywhere

#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisData {
    // convert lossless JSON floats to string to avoid lossy Rust f64
    pub activeSlotsCoeff: serde_json::Number,
    pub epochLength: u64,
    pub genDelegs: HashMap<String, ShelleyGenesisDelegations>,
    pub initialFunds: HashMap<String, Coin>,
    pub maxKESEvolutions: u64,
    pub maxLovelaceSupply: Coin,
    pub networkId: String,
    pub networkMagic: u64,
    pub protocolParams: ShelleyGenesisProtocolParameters,
    pub securityParam: u64,
    pub slotLength: serde_json::Number,
    pub slotsPerKESPeriod: u64,
    pub staking: Option<ShelleyGenesisStaking>,
    pub systemStart: String,
    pub updateQuorum: u64,
}

#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisDelegations {
    pub delegate: String,
    pub vrf: String,
}

#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisProtocolParameters {
    // this uses the serde_json arbitrary_precision feature to avoid lossy Rust f64
    pub a0: serde_json::Number,
    // this uses the serde_json arbitrary_precision feature to avoid lossy Rust f64
    pub decentralisationParam: serde_json::Number,
    pub eMax: u64,
    pub extraEntropy: ShelleyGenesisExtraEntropy,
    pub keyDeposit: Coin,
    pub maxBlockBodySize: u64,
    pub maxBlockHeaderSize: u64,
    pub maxTxSize: u64,
    pub minFeeA: Coin,
    pub minFeeB: Coin,
    pub minPoolCost: Coin,
    pub minUTxOValue: Coin,
    pub nOpt: u64,
    pub poolDeposit: Coin,
    pub protocolVersion: ShelleyGenesisProtocolVersion,
    // this uses the serde_json arbitrary_precision feature to avoid lossy Rust f64
    pub rho: serde_json::Number,
    // this uses the serde_json arbitrary_precision feature to avoid lossy Rust f64
    pub tau: serde_json::Number,
}

#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisExtraEntropy {
    pub tag: String,
}

#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisProtocolVersion {
    pub major: u64,
    pub minor: u64,
}

#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisStaking {
    pub pools: HashMap<String, ShelleyGenesisPool>,
    pub stake: HashMap<String, String>,
}

#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisPool {
    pub cost: Coin,
    // this uses the serde_json arbitrary_precision feature to avoid lossy Rust f64
    pub margin: serde_json::Number,
    pub metadata: Option<ShelleyGenesisPoolMetadata>,
    pub owners: Vec<String>,
    pub pledge: Coin,
    pub publicKey: String,
    pub relays: Vec<RelayTypeMap>,
    pub rewardAccount: ShelleyGenesisRewardAccount,
    pub vrf: String,
}

// TODO: there are other relay types, but I can't find the JSON type for them
//       and I can't find any usage of them in the wild anyway
// The key here defines the relay type
// ex:
// - single host address
type RelayTypeMap = HashMap<String, ShelleyGenesisPoolSingleHotsRelay>;

#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisPoolSingleHotsRelay {
    pub IPv6: Option<String>,
    pub port: Option<u16>,
    pub IPv4: Option<String>,
}

#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisPoolMetadata {
    pub hash: String,
    pub url: String,
}
#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisRewardAccount {
    pub network: String,
    pub credential: ShelleyGenesisCredential,
}
#[allow(non_snake_case)]
#[derive(Serialize, Deserialize, Debug)]
pub struct ShelleyGenesisCredential {
    // for some reason there actually is a space in the JSON key emitted by the Haskell node
    // both key hash and keyHash are accepted
    #[serde(alias = "key hash")]
    pub keyHash: String,
}