siws 0.0.3

Lightweight Sign in With Solana library adhering to the Solana Wallet Standard.
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

use crate::message::{ParseError, ValidateError};
use ed25519_dalek::{PublicKey, Signature};
use serde::{Deserialize, Serialize};
use thiserror::Error;

#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SiwsOutput {
    pub account: SolAccount,
    pub signed_message: Vec<u8>,
    pub signature: Vec<u8>,
}

#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SolAccount {
    pub public_key: Vec<u8>,
}

impl SiwsOutput {
    pub fn verify(&self) -> Result<bool, VerifyError> {
        let pubkey = PublicKey::from_bytes(&self.account.public_key)
            .map_err(|_| SiwsOutputError::InvalidPubkey)?;

        let signature = Signature::from_bytes(&self.signature)
            .map_err(|_| SiwsOutputError::InvalidSignature)?;

        // Verify signature
        pubkey
            .verify_strict(&self.signed_message, &signature)
            .map_err(|_| VerifyError::VerificationFailure)?;

        Ok(true)
    }
}

#[derive(Error, Debug)]
pub enum VerifyError {
    #[error("Message Parse Error: {0}")]
    MessageParse(#[from] ParseError),

    #[error("Invalid Message: {0}")]
    MessageValidate(#[from] ValidateError),

    #[error("Signature Parse Error: {0}")]
    SignatureParse(&'static str),

    #[error("Solana Error: {0}")]
    SiwsOutput(#[from] SiwsOutputError),

    #[error("Signature verification failed")]
    VerificationFailure,

    #[error("")]
    Infallible
}

#[derive(Debug, Error)]
pub enum SiwsOutputError {
    #[error("Invalid public key")]
    InvalidPubkey,
    #[error("Invalid signature")]
    InvalidSignature,
}