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

use crate::{
    common::AuthorizeTarget,
    did::*,
    util::{StorageRef, WithNonce},
};
use codec::{Decode, Encode, MaxEncodedLen};
use core::ops::{Index, RangeFull};
use frame_support::ensure;

use self::common::TypesAndLimits;

/// The `public_key` in `did:key:<public_key>`.
#[derive(Encode, Decode, Clone, Debug, PartialEq, Eq, Copy, Ord, PartialOrd, MaxEncodedLen)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
#[derive(scale_info_derive::TypeInfo)]
#[scale_info(omit_prefix)]
pub enum DidMethodKey {
    /// Public key for Ed25519 is 32 bytes
    Ed25519(Bytes32),
    /// Compressed public key for Secp256k1 is 33 bytes
    Secp256k1(Bytes33),
}

impl From<sp_core::ed25519::Public> for DidMethodKey {
    fn from(key: sp_core::ed25519::Public) -> Self {
        Self::Ed25519(key.0.into())
    }
}

impl<T: TypesAndLimits> Associated<T> for DidMethodKey {
    type Value = WithNonce<T, ()>;
}

impl<T: Config> StorageRef<T> for DidMethodKey {
    fn try_mutate_associated<F, R, E>(self, f: F) -> Result<R, E>
    where
        F: FnOnce(&mut Option<WithNonce<T, ()>>) -> Result<R, E>,
    {
        DidMethodKeys::<T>::try_mutate_exists(self, f)
    }

    fn view_associated<F, R>(self, f: F) -> R
    where
        F: FnOnce(Option<WithNonce<T, ()>>) -> R,
    {
        f(DidMethodKeys::<T>::get(self))
    }
}

impl<T, Target> AuthorizeTarget<T, Target, Self> for DidMethodKey
where
    Target: Associated<T>,
    T: crate::did::Config,
{
    fn ensure_authorizes_target<A>(
        &self,
        key: &Self,
        _: &A,
        _: Option<&Target::Value>,
    ) -> sp_runtime::DispatchResult
    where
        A: Action<Target = Target>,
    {
        ensure!(self == key, Error::<T>::InvalidSigner);

        Ok(())
    }
}

impl Index<RangeFull> for DidMethodKey {
    type Output = [u8];

    fn index(&self, _: RangeFull) -> &Self::Output {
        match self {
            Self::Ed25519(bytes) => &bytes[..],
            Self::Secp256k1(bytes) => &bytes[..],
        }
    }
}

impl<T: Config> Pallet<T> {
    pub(crate) fn new_did_method_key_(did_key: DidMethodKey) -> Result<(), Error<T>> {
        ensure!(
            !DidMethodKeys::<T>::contains_key(did_key),
            Error::<T>::DidMethodKeyExists
        );

        DidMethodKeys::<T>::insert(did_key, WithNonce::new(()));

        crate::deposit_indexed_event!(DidMethodKeyAdded(did_key));
        Ok(())
    }
}