kec/web-client/tests/integration.rs

use common_api::crypto::prelude::*;
use near_primitives_core::account::id::AccountId;
use near_primitives_light::types::Finality;
use near_rpc::client::{NearClient, Signer};
use serde::{Deserialize, Serialize};
use std::str::FromStr;
use url::Url;
use wasm_bindgen::JsValue;
use wasm_bindgen_futures::JsFuture;
use wasm_bindgen_test::*;

use web_client::{KeyProvisioner, ProvisionerConfig};

wasm_bindgen_test_configure!(run_in_browser);

#[derive(Serialize, Deserialize)]
struct ValidatorKey {
    account_id: AccountId,
    public_key: Ed25519PublicKey,
    secret_key: String,
}

const ALICE_BYTES: [u8; 32] = [1; 32];
const BOB_BYTES: [u8; 32] = [2; 32];
const KARL_BYTES: [u8; 32] = [3; 32];
const MIKE_BYTES: [u8; 32] = [4; 32];
const CONTRACT_BYTES: [u8; 32] = [5; 32];

async fn create_account(
    client: &NearClient,
    validator: &Signer,
    sk_bytes: &[u8; 32],
    id_str: &str,
) -> Signer {
    let id = AccountId::from_str(id_str).unwrap();
    let sk = Ed25519SecretKey::try_from_bytes(sk_bytes).unwrap();
    let pk = Ed25519PublicKey::from(&sk);

    let amount = near_units::near::parse("200 N").unwrap();

    client
        .create_account(validator, &id, pk, amount)
        .commit(Finality::Final)
        .await
        .unwrap();

    let nonce = Result::from(
        client
            .view_access_key(&id, &pk, Finality::None)
            .await
            .unwrap(),
    )
    .map_err(|err| anyhow::anyhow!(err))
    .unwrap();

    Signer::from_secret(sk, id, nonce)
}

async fn drop_created_account(
    client: &NearClient,
    beneficiary_acc_id: &AccountId,
    sk_bytes: &[u8; 32],
    id_str: &str,
) {
    let id = AccountId::from_str(id_str).unwrap();
    let sk = Ed25519SecretKey::try_from_bytes(sk_bytes).unwrap();
    let pk = Ed25519PublicKey::from(&sk);

    if let Ok(access_key) = client.view_access_key(&id, &pk, Finality::Final).await {
        if let Ok(nonce) = access_key.into() {
            let signer = Signer::from_secret(sk, id.clone(), nonce);
            signer.update_nonce(nonce);

            client
                .delete_account(&signer, &id, beneficiary_acc_id)
                .commit(Finality::Final)
                .await
                .unwrap();
        };
    }
}

async fn validator_key() -> anyhow::Result<ValidatorKey> {
    Ok(
        reqwest::get("http://sandbox-artifact:3032/validator_key.json")
            .await?
            .json::<ValidatorKey>()
            .await?,
    )
}

async fn validator_account(
    client: &NearClient,
    validator_key: ValidatorKey,
) -> anyhow::Result<Signer> {
    let key_nonce = Result::from(
        client
            .view_access_key(
                &validator_key.account_id,
                &validator_key.public_key,
                Finality::Final,
            )
            .await?,
    )
    .map_err(|err| anyhow::anyhow!(err))?;

    let signer = Signer::from_secret_str(
        &validator_key.secret_key,
        validator_key.account_id.clone(),
        key_nonce,
    )?;

    Ok(signer)
}

async fn meeting_room_contract() -> anyhow::Result<Vec<u8>> {
    Ok(
        reqwest::get("http://contract-artifact:3033/meeting_room.wasm")
            .await?
            .bytes()
            .await?
            .to_vec(),
    )
}

#[wasm_bindgen_test]
async fn pass() {
    console_log!("Test Passed");
}

#[wasm_bindgen_test]
async fn key_exchange() {
    let rpc_url = Url::parse("http://sandbox:3030").unwrap();
    let client = NearClient::new(rpc_url).unwrap();

    let validator_key = validator_key().await.unwrap();
    let validator = validator_account(&client, validator_key).await.unwrap();

    // delete accounts if any to be sure there are no dublicates
    drop_created_account(
        &client,
        validator.account(),
        &ALICE_BYTES,
        "alice.test.near",
    )
    .await;
    drop_created_account(&client, validator.account(), &BOB_BYTES, "bob.test.near").await;
    drop_created_account(&client, validator.account(), &KARL_BYTES, "karl.test.near").await;
    drop_created_account(&client, validator.account(), &MIKE_BYTES, "mike.test.near").await;
    drop_created_account(
        &client,
        validator.account(),
        &CONTRACT_BYTES,
        "contract.test.near",
    )
    .await;

    // create account for key-exchange
    // Alice is an initiator account
    let alice_sg = create_account(&client, &validator, &ALICE_BYTES, "alice.test.near").await;
    let bob_sg = create_account(&client, &validator, &BOB_BYTES, "bob.test.near").await;
    let karl_sg = create_account(&client, &validator, &KARL_BYTES, "karl.test.near").await;
    let mike_sg = create_account(&client, &validator, &MIKE_BYTES, "mike.test.near").await;
    let contract_sg =
        create_account(&client, &validator, &CONTRACT_BYTES, "contract.test.near").await;

    // Contract byte code
    let contract_wasm = meeting_room_contract().await.unwrap();
    let contract_id = contract_sg.account().clone();

    client
        .deploy_contract(&contract_sg, &contract_id, contract_wasm)
        .commit(Finality::Final)
        .await
        .unwrap();

    // config with endpoints
    let config = ProvisionerConfig::new(
        contract_id.to_string(),
        "http://sandbox:3030",
        "http://key-exchange:3000",
    )
    .unwrap();

    // Create provisioners for each user
    let keypair_str = alice_sg.secret_key().string();
    let provisioner = KeyProvisioner::new(
        keypair_str,
        alice_sg.nonce(),
        alice_sg.account().to_string(),
        config.clone(),
    )
    .unwrap();

    let arr = JsValue::from(
        &[
            bob_sg.account().to_string(),
            karl_sg.account().to_string(),
            mike_sg.account().to_string(),
        ]
        .into_iter()
        .map(|it| JsValue::from_str(&it))
        .collect::<js_sys::Array>(),
    );

    let set = js_sys::Set::new(&arr);

    // Init meeting
    let meeting_id = JsFuture::from(provisioner.init(set, 3000))
        .await
        .unwrap()
        .as_string()
        .unwrap();

    // Then each user push own key to blockchain
    let keypair_str = bob_sg.secret_key().string();
    let provisioner_bob = KeyProvisioner::new(
        keypair_str,
        bob_sg.nonce(),
        bob_sg.account().to_string(),
        config.clone(),
    )
    .unwrap();

    let _ = JsFuture::from(provisioner_bob.push_to_near(meeting_id.clone(), 3000))
        .await
        .unwrap();

    let keypair_str = karl_sg.secret_key().string();
    let provisioner_karl = KeyProvisioner::new(
        keypair_str,
        karl_sg.nonce(),
        karl_sg.account().to_string(),
        config.clone(),
    )
    .unwrap();

    let _ = JsFuture::from(provisioner_karl.push_to_near(meeting_id.clone(), 3000))
        .await
        .unwrap();

    let keypair_str = mike_sg.secret_key().string();
    let provisioner_mike = KeyProvisioner::new(
        keypair_str,
        mike_sg.nonce(),
        mike_sg.account().to_string(),
        config.clone(),
    )
    .unwrap();

    let _ = JsFuture::from(provisioner_mike.push_to_near(meeting_id.clone(), 3000))
        .await
        .unwrap();

    // Send encrypted keys to participants
    // timeout in millis
    let alice_key = JsFuture::from(provisioner.send_keys(meeting_id.clone(), 200))
        .await
        .unwrap()
        .as_string()
        .unwrap();

    // Fetch encrypted keys
    let bob_key = JsFuture::from(provisioner_bob.get_key(meeting_id.clone(), 200))
        .await
        .unwrap()
        .as_string()
        .unwrap();

    let karl_key = JsFuture::from(provisioner_karl.get_key(meeting_id.clone(), 200))
        .await
        .unwrap()
        .as_string()
        .unwrap();

    let mike_key = JsFuture::from(provisioner_mike.get_key(meeting_id.clone(), 200))
        .await
        .unwrap()
        .as_string()
        .unwrap();

    assert!(&[mike_key, bob_key, karl_key]
        .into_iter()
        .all(|key| key == alice_key));

    // delete all accounts
    drop_created_account(
        &client,
        validator.account(),
        &ALICE_BYTES,
        "alice.test.near",
    )
    .await;
    drop_created_account(&client, validator.account(), &BOB_BYTES, "bob.test.near").await;
    drop_created_account(&client, validator.account(), &KARL_BYTES, "karl.test.near").await;
    drop_created_account(&client, validator.account(), &MIKE_BYTES, "mike.test.near").await;
    drop_created_account(
        &client,
        validator.account(),
        &CONTRACT_BYTES,
        "contract.test.near",
    )
    .await;
}

#[wasm_bindgen_test]
async fn sandbox() {}