nym-api-requests 1.22.0

Nym API request types and functions
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

// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
// SPDX-License-Identifier: Apache-2.0

use crate::signable::{SignableMessageBody, SignedMessage};
use nym_crypto::asymmetric::ed25519;
use serde::{Deserialize, Serialize};
use std::time::Duration;
use utoipa::ToSchema;

#[derive(Clone, Copy, Debug, Serialize, Deserialize, schemars::JsonSchema, ToSchema)]
pub struct ApiHealthResponse {
    pub status: ApiStatus,
    #[serde(default)]
    pub chain_status: ChainStatus,
    pub uptime: u64,
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize, schemars::JsonSchema, ToSchema)]
#[serde(rename_all = "lowercase")]
pub enum ApiStatus {
    Up,
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize, Default, schemars::JsonSchema, ToSchema)]
#[serde(rename_all = "snake_case")]
pub enum ChainStatus {
    Synced,
    #[default]
    Unknown,
    Stalled {
        #[serde(
            serialize_with = "humantime_serde::serialize",
            deserialize_with = "humantime_serde::deserialize"
        )]
        approximate_amount: Duration,
    },
}

impl ChainStatus {
    pub fn is_synced(&self) -> bool {
        matches!(self, ChainStatus::Synced)
    }
}

impl ApiHealthResponse {
    pub fn new_healthy(uptime: Duration) -> Self {
        ApiHealthResponse {
            status: ApiStatus::Up,
            chain_status: ChainStatus::Synced,
            uptime: uptime.as_secs(),
        }
    }
}

impl ApiStatus {
    pub fn is_up(&self) -> bool {
        matches!(self, ApiStatus::Up)
    }
}

#[derive(Clone, Debug, Serialize, Deserialize, schemars::JsonSchema, ToSchema)]
pub struct SignerInformationResponse {
    pub cosmos_address: String,

    pub identity: String,

    pub announce_address: String,

    pub verification_key: Option<String>,
}

// we only allow json and yaml responses so we can easily add additional fields later
#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct ApiInformationResponse {
    #[schema(value_type = String)]
    #[serde(with = "ed25519::bs58_ed25519_pubkey")]
    pub identity: ed25519::PublicKey,
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct KeyPossessionChallenge {
    pub nonce: [u8; 32],
}

#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct KeyPossessionChallengePlaintext {
    version: u8,

    #[serde(flatten)]
    challenge: KeyPossessionChallenge,

    purpose: &'static str,
}

impl KeyPossessionChallenge {
    pub fn sign(&self, key: &ed25519::PrivateKey) -> KeyPossessionChallengeResponse {
        self.plaintext_message().sign(key)
    }

    #[allow(clippy::expect_used)]
    pub fn plaintext_message(&self) -> KeyPossessionChallengePlaintext {
        KeyPossessionChallengePlaintext {
            version: 1,
            challenge: *self,
            purpose: "key-possession-challenge",
        }
    }
}

pub type KeyPossessionChallengeResponse = SignedMessage<KeyPossessionChallengePlaintext>;