soroban-auth 0.4.3

Soroban authorization sdk
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

#![cfg(any(test, feature = "testutils"))]
#![cfg_attr(feature = "docs", doc(cfg(feature = "testutils")))]

//! Utilities intended for use when testing contracts that use
//! [`soroban_auth`](crate).

pub mod ed25519 {
    use core::fmt::Debug;
    use core::panic;

    use soroban_sdk::{testutils::ed25519::Sign, BytesN, Env, IntoVal, RawVal, Symbol, Vec};

    use crate::{
        Ed25519Signature, Identifier as IdentifierValue, Signature, SignaturePayload,
        SignaturePayloadV0,
    };

    /// Identifier implementations have an identifier.
    pub trait Identifier {
        fn identifier(&self, env: &Env) -> IdentifierValue;
    }

    impl Identifier for ed25519_dalek::Keypair {
        fn identifier(&self, env: &Env) -> IdentifierValue {
            IdentifierValue::Ed25519(self.public.as_bytes().into_val(env))
        }
    }

    /// Generate an ed25519 identifier and signer that can sign
    /// [`SignaturePayload`]s for that identifier.
    pub fn generate(
        env: &Env,
    ) -> (
        IdentifierValue,
        impl Identifier + Sign<SignaturePayload, Signature = [u8; 64]> + Debug,
    ) {
        let signer = ed25519_dalek::Keypair::generate(&mut rand::thread_rng());
        (signer.identifier(env), signer)
    }

    /// Create a signer from a ed25519 secret key.
    pub fn signer(
        env: &Env,
        secret_key: &[u8; 32],
    ) -> (
        IdentifierValue,
        impl Identifier + Sign<SignaturePayload, Signature = [u8; 64]> + Debug,
    ) {
        let secret = ed25519_dalek::SecretKey::from_bytes(secret_key).unwrap();
        let public = ed25519_dalek::PublicKey::from(&secret);
        let signer = ed25519_dalek::Keypair { secret, public };
        (signer.identifier(env), signer)
    }

    /// Create an identifier from a ed25519 public key.
    pub fn identifier(env: &Env, public_key: &[u8; 32]) -> IdentifierValue {
        IdentifierValue::Ed25519(public_key.into_val(env))
    }

    /// Sign a [`SignaturePayload`] constructed using the arguments.
    ///
    /// The returned [`Signature`] can be verified by [`verify`](crate::verify)
    /// with the same arguments within the specified contract.
    pub fn sign(
        env: &Env,
        signer: &(impl Identifier + Sign<SignaturePayload, Signature = [u8; 64]>),
        contract: &BytesN<32>,
        name: Symbol,
        args: impl IntoVal<Env, Vec<RawVal>>,
    ) -> Signature {
        let identifier = signer.identifier(env);
        let public_key = if let IdentifierValue::Ed25519(public_key) = identifier {
            public_key
        } else {
            panic!("identifier must be ed25519")
        };
        let payload = SignaturePayload::V0(SignaturePayloadV0 {
            network: env.ledger().network_passphrase(),
            contract: contract.clone(),
            name,
            args: args.into_val(env),
        });
        let signature = match signer.sign(payload) {
            Ok(signature) => signature,
            Err(_) => panic!("error signing signature payload"),
        };
        Signature::Ed25519(Ed25519Signature {
            public_key: public_key.into_val(env),
            signature: signature.into_val(env),
        })
    }
}

// TODO: Add account module that contains utilities for producing signatures for
// accounts.
// pub mod account {
// }