vectis-wallet 1.0.0-rc2

Vectis library for common messages, states and functions
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

use cosmwasm_std::{from_binary, Addr, CosmosMsg, Deps, StdResult};
use sha2::{Digest, Sha256};

use crate::{
    interface::authenticator_trait,
    types::{
        authenticator::AuthenticatorType,
        entity::Entity,
        error::RelayTxError,
        wallet::{Nonce, RelayTransaction, VectisRelayedTx, WebauthnRelayedTxMsg},
    },
};

pub fn verify_cosmos_sign(
    deps: Deps,
    transaction: &RelayTransaction,
    pubkey: &[u8],
) -> StdResult<bool> {
    let hash = Sha256::digest(&transaction.message);
    let result = deps
        .api
        .secp256k1_verify(hash.as_ref(), &transaction.signature, pubkey)?;
    Ok(result)
}

pub(crate) fn check_cosmos_relayed_tx(
    msg: &VectisRelayedTx,
    nonce: Nonce,
) -> Result<(), RelayTxError> {
    if msg.nonce != nonce {
        Err(RelayTxError::NoncesAreNotEqual)
    } else if msg.messages.is_empty() {
        Err(RelayTxError::EmptyMsg)
    } else {
        Ok(())
    }
}

pub fn relay_tx_auth_check(
    deps: Deps,
    controller: Entity,
    transaction: RelayTransaction,
    auth_addr: Option<Addr>,
) -> Result<Vec<CosmosMsg>, RelayTxError> {
    let msgs = match controller.auth.ty() {
        AuthenticatorType::Webauthn => {
            let webauthn_tx_msg: WebauthnRelayedTxMsg = from_binary(&transaction.message)?;

            let msg = authenticator_trait::sv::QueryMsg::Authenticate {
                // this is the JSON string of the VectisRelayTx, containing the Vec<CosmosMsg>
                signed_data: webauthn_tx_msg.signed_data.as_bytes().to_vec(),
                controller_data: controller.data.0,
                metadata: vec![webauthn_tx_msg.auth_data.0, webauthn_tx_msg.client_data.0],
                signature: transaction.signature.0,
            };

            if !deps
                .querier
                .query_wasm_smart(auth_addr.ok_or(RelayTxError::AuthenticatorNotFound)?, &msg)?
            {
                return Err(RelayTxError::SignatureVerificationError);
            }

            let vectis_relayed_tx: VectisRelayedTx =
                serde_json_wasm::from_str(&webauthn_tx_msg.signed_data)
                    .map_err(|_| RelayTxError::SerdeVectisRelayedTx)?;
            check_cosmos_relayed_tx(&vectis_relayed_tx, controller.nonce)?;
            vectis_relayed_tx.messages
        }
        _ => {
            return Err(RelayTxError::AuthenticatorNotSupported);
        }
    };
    Ok(msgs)
}