calimero-node-primitives 0.10.0

Core Calimero infrastructure and tools
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

use core::str::FromStr;

use calimero_primitives::alias::Alias;
use calimero_store::key::{self as key, Aliasable, StoreScopeCompat};
use eyre::{bail, OptionExt};

use super::NodeClient;

impl NodeClient {
    pub fn create_alias<T>(
        &self,
        alias: Alias<T>,
        scope: Option<T::Scope>,
        value: T,
    ) -> eyre::Result<()>
    where
        T: Aliasable<Scope: StoreScopeCompat> + AsRef<[u8; 32]>,
    {
        let mut handle = self.datastore.handle();

        let key = key::Alias::new(scope, alias).ok_or_eyre("alias requires scope to be present")?;

        if handle.has(&key)? {
            bail!("alias already exists");
        }

        let value = (*value.as_ref()).into();

        handle.put(&key, &value)?;

        Ok(())
    }

    pub fn delete_alias<T>(&self, alias: Alias<T>, scope: Option<T::Scope>) -> eyre::Result<()>
    where
        T: Aliasable<Scope: StoreScopeCompat>,
    {
        let mut handle = self.datastore.handle();

        let key = key::Alias::new(scope, alias).ok_or_eyre("alias requires scope to be present")?;

        handle.delete(&key)?;

        Ok(())
    }

    pub fn lookup_alias<T>(
        &self,
        alias: Alias<T>,
        scope: Option<T::Scope>,
    ) -> eyre::Result<Option<T>>
    where
        T: Aliasable<Scope: StoreScopeCompat> + From<[u8; 32]>,
    {
        let handle = self.datastore.handle();

        let key = key::Alias::new(scope, alias).ok_or_eyre("alias requires scope to be present")?;

        let Some(value) = handle.get(&key)? else {
            return Ok(None);
        };

        Ok(Some((*value).into()))
    }

    pub fn resolve_alias<T>(
        &self,
        alias: Alias<T>,
        scope: Option<T::Scope>,
    ) -> eyre::Result<Option<T>>
    where
        T: Aliasable<Scope: StoreScopeCompat> + From<[u8; 32]> + FromStr<Err: Into<eyre::Report>>,
    {
        if let Some(value) = self.lookup_alias(alias, scope)? {
            return Ok(Some(value));
        }

        Ok(alias.as_str().parse().ok())
    }

    pub fn list_aliases<T>(
        &self,
        scope: Option<T::Scope>,
    ) -> eyre::Result<Vec<(Alias<T>, T, Option<T::Scope>)>>
    where
        T: Aliasable + From<[u8; 32]>,
        T::Scope: Copy + PartialEq + StoreScopeCompat,
    {
        let handle = self.datastore.handle();

        let mut iter = handle.iter::<key::Alias>()?;

        let first = scope.and_then(|scope| {
            iter.seek(key::Alias::new_unchecked::<T>(Some(scope), [0; 50]))
                .transpose()
                .map(|k| (k, iter.read()))
        });

        let mut aliases = vec![];

        for (k, v) in first.into_iter().chain(iter.entries()) {
            let (k, v) = (k?, v?);

            if let Some(expected_scope) = &scope {
                if let Some(found_scope) = k.scope::<T>() {
                    if found_scope != *expected_scope {
                        break;
                    }
                }
            }

            let Some(alias) = k.alias() else {
                continue;
            };

            aliases.push((alias, (*v).into(), k.scope::<T>()));
        }

        Ok(aliases)
    }
}