chio-settle 0.1.2

Settlement runtime for Chio web3 escrow and bond execution
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

use chio_core::canonical::canonical_json_bytes;
use chio_core::crypto::sha256_hex;
use serde::{Deserialize, Deserializer, Serialize};

use super::ChannelError;

pub(super) const I_JSON_MAX_SAFE_INTEGER: u64 = (1_u64 << 53) - 1;
pub(super) const MAX_TEXT_BYTES: usize = 2_048;

pub(super) fn digest<T: Serialize>(domain: &[u8], value: &T) -> Result<String, ChannelError> {
    let canonical = canonical_json_bytes(value)
        .map_err(|error| ChannelError::Canonicalization(error.to_string()))?;
    let mut bytes = Vec::with_capacity(domain.len() + canonical.len());
    bytes.extend_from_slice(domain);
    bytes.extend_from_slice(&canonical);
    Ok(sha256_hex(&bytes))
}

pub(super) fn deserialize_present_option<'de, D, T>(deserializer: D) -> Result<Option<T>, D::Error>
where
    D: Deserializer<'de>,
    T: Deserialize<'de>,
{
    T::deserialize(deserializer).map(Some)
}

pub(super) fn validate_text(field: &'static str, value: &str) -> Result<(), ChannelError> {
    if value.is_empty()
        || value.len() > MAX_TEXT_BYTES
        || value.trim() != value
        || value.chars().any(char::is_control)
    {
        return Err(ChannelError::InvalidField(field));
    }
    Ok(())
}

pub(super) fn validate_digest(field: &'static str, value: &str) -> Result<(), ChannelError> {
    if value.len() != 64
        || !value
            .bytes()
            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
    {
        return Err(ChannelError::InvalidField(field));
    }
    Ok(())
}

pub(super) fn validate_currency(currency: &str) -> Result<(), ChannelError> {
    if currency.len() != 3 || !currency.bytes().all(|byte| byte.is_ascii_uppercase()) {
        return Err(ChannelError::InvalidField("currency"));
    }
    Ok(())
}

pub(super) fn validate_positive(field: &'static str, value: u64) -> Result<(), ChannelError> {
    if value == 0 || value > I_JSON_MAX_SAFE_INTEGER {
        return Err(ChannelError::InvalidField(field));
    }
    Ok(())
}

pub(super) fn validate_chain_id(value: &str) -> Result<(), ChannelError> {
    let Some(numeric) = value.strip_prefix("eip155:") else {
        return Err(ChannelError::InvalidField("chain_id"));
    };
    if numeric.starts_with('0')
        || numeric
            .parse::<u64>()
            .ok()
            .filter(|value| *value != 0)
            .is_none()
    {
        return Err(ChannelError::InvalidField("chain_id"));
    }
    Ok(())
}

pub(super) fn validate_evm_address(field: &'static str, value: &str) -> Result<(), ChannelError> {
    if value.len() != 42
        || !value.starts_with("0x")
        || !value[2..]
            .bytes()
            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
    {
        return Err(ChannelError::InvalidField(field));
    }
    Ok(())
}

pub(super) fn validate_evm_hash(field: &'static str, value: &str) -> Result<(), ChannelError> {
    if value.len() != 66
        || !value.starts_with("0x")
        || !value[2..]
            .bytes()
            .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
    {
        return Err(ChannelError::InvalidField(field));
    }
    Ok(())
}

pub(super) fn parse_base_units(value: &str) -> Result<u128, ChannelError> {
    if value.is_empty()
        || value.len() > 39
        || value.len() > 1 && value.starts_with('0')
        || !value.bytes().all(|byte| byte.is_ascii_digit())
    {
        return Err(ChannelError::InvalidField("token_base_units"));
    }
    value
        .parse::<u128>()
        .map_err(|_| ChannelError::InvalidField("token_base_units"))
}