did-ethr 0.5.0

did:ethr DID method, using the ssi crate
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

use ssi_dids_core::{
    document::representation,
    ssi_json_ld::{
        syntax::context::{
            term_definition::{Expanded, Id, Type, TypeKeyword},
            Definition, TermDefinition,
        },
        Nullable,
    },
};
use static_iref::iri;

use crate::VerificationMethodType;

#[derive(Debug, Default)]
pub struct JsonLdContext {
    ecdsa_secp256k1_verification_key_2019: bool,
    ecdsa_secp256k1_recovery_method_2020: bool,
    eip712_method_2021: bool,
}

impl JsonLdContext {
    pub fn add_verification_method_type(&mut self, vm_type: VerificationMethodType) {
        match vm_type {
            VerificationMethodType::EcdsaSecp256k1VerificationKey2019 => {
                self.ecdsa_secp256k1_verification_key_2019 = true
            }
            VerificationMethodType::EcdsaSecp256k1RecoveryMethod2020 => {
                self.ecdsa_secp256k1_recovery_method_2020 = true
            }
            VerificationMethodType::Eip712Method2021 => self.eip712_method_2021 = true,
        }
    }

    pub fn into_entries(self) -> Vec<representation::json_ld::ContextEntry> {
        let mut def = Definition::new();

        let mut public_key_jwk = false;
        let mut blockchain_account_id = false;
        // let mut public_key_base_58 = false;
        // let mut public_key_multibase = false;

        // if self.ed25519_verification_key_2018 {
        //     let ty = VerificationMethodType::Ed25519VerificationKey2018;
        //     def.bindings.insert(
        //         ty.name().into(),
        //         TermDefinition::Simple(ty.iri().to_owned().into()).into(),
        //     );

        //     public_key_base_58 = true;
        // }

        if self.ecdsa_secp256k1_verification_key_2019 {
            let ty = VerificationMethodType::EcdsaSecp256k1VerificationKey2019;
            def.bindings.insert(
                ty.name().into(),
                TermDefinition::Simple(ty.iri().to_owned().into()).into(),
            );

            public_key_jwk = true;
        }

        if self.ecdsa_secp256k1_recovery_method_2020 {
            let ty = VerificationMethodType::EcdsaSecp256k1RecoveryMethod2020;
            def.bindings.insert(
                ty.name().into(),
                TermDefinition::Simple(ty.iri().to_owned().into()).into(),
            );

            blockchain_account_id = true;
        }

        if self.eip712_method_2021 {
            let ty = VerificationMethodType::Eip712Method2021;
            def.bindings.insert(
                ty.name().into(),
                TermDefinition::Simple(ty.iri().to_owned().into()).into(),
            );

            blockchain_account_id = true;
        }

        if public_key_jwk {
            def.bindings.insert(
                "publicKeyJwk".into(),
                TermDefinition::Expanded(Box::new(Expanded {
                    id: Some(Nullable::Some(Id::Term(
                        iri!("https://w3id.org/security#publicKeyJwk")
                            .to_owned()
                            .into_string(),
                    ))),
                    type_: Some(Nullable::Some(Type::Keyword(TypeKeyword::Json))),
                    ..Default::default()
                }))
                .into(),
            );
        }

        if blockchain_account_id {
            def.bindings.insert(
                "blockchainAccountId".into(),
                TermDefinition::Simple(
                    iri!("https://w3id.org/security#blockchainAccountId")
                        .to_owned()
                        .into(),
                )
                .into(),
            );
        }

        vec![representation::json_ld::ContextEntry::Definition(def)]
    }
}