etopay-wallet 0.16.1

Functionality for interacting with DLTs used in the ETOPay Wallet
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

// Copyright (c) Mysten Labs, Inc.
// Modifications Copyright (c) 2024 IOTA Stiftung
// Modifications Copyright (c) 2025 ETO GRUPPE TECHNOLOGIES GmbH
// SPDX-License-Identifier: Apache-2.0

use bip32::DerivationPath;
use bip39::{Mnemonic, Seed};
use serde::Serialize;
use std::collections::BTreeMap;

use super::crypto::{Ed25519KeyPair, Ed25519PrivateKey, Ed25519PublicKey};
use super::hash::{Blake2b256, HashFunction};
use super::traits::ToFromBytes;
use super::{Intent, IntentMessage, IotaAddress, RebasedError, Signature};

#[derive(Default)]
pub struct InMemKeystore {
    keys: BTreeMap<IotaAddress, Ed25519KeyPair>,
}
impl InMemKeystore {
    pub fn import_from_mnemonic(
        &mut self,
        mnemonic: Mnemonic,
        derivation_path: DerivationPath,
    ) -> Result<IotaAddress, RebasedError> {
        let seed = Seed::new(&mnemonic, "");

        let indexes = derivation_path.into_iter().map(|i| i.into()).collect::<Vec<_>>();
        let derived = slip10_ed25519::derive_ed25519_private_key(seed.as_bytes(), &indexes);
        let sk = Ed25519PrivateKey::from_bytes(&derived)?;

        let kp: Ed25519KeyPair = sk.into();

        let (address, kp) = (kp.public().into(), kp);

        self.keys.insert(address, kp);
        Ok(address)
    }
    pub fn addresses(&self) -> Vec<IotaAddress> {
        self.keys.keys().cloned().collect::<Vec<_>>()
    }

    pub fn sign_secure<T>(&self, address: &IotaAddress, msg: &T, intent: Intent) -> Result<Signature, RebasedError>
    where
        T: Serialize,
    {
        Signature::new_secure(
            &IntentMessage::new(intent, msg),
            self.keys
                .get(address)
                .ok_or_else(|| RebasedError::KeyNotFound { address: *address })?,
        )
    }
}

impl From<&Ed25519PublicKey> for IotaAddress {
    fn from(pk: &Ed25519PublicKey) -> Self {
        let mut hasher = Blake2b256::default();
        hasher.update(pk);
        let g_arr = hasher.finalize();
        IotaAddress(g_arr.digest)
    }
}

// #[serde_as]
// #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq, Hash, AsRef, AsMut)]
// #[as_ref(forward)]
// #[as_mut(forward)]
// pub struct Ed25519IotaSignature(
//     #[schemars(with = "Base64")]
//     #[serde_as(as = "Readable<Base64, Bytes>")]
//     [u8; Ed25519PublicKey::LENGTH + Ed25519Signature::LENGTH + 1],
// );