It’s way too late, and listening to the three Cranberries songs I like, on repeat, can only get me so much further before I just fall asleep (at least I can sleep again… sometimes). But while that was working I managed to bash out the initial I/O on the function signatures and at least get the ball rolling.
Still a lot of gaps and TODO comments, but I’ll fill those in in the morning when it’s beans instead of flowers.
Anyway, I’ve left my comments in (some of them are nonsense), but I’m not gonna explain much other than that. There’s an /actions/mod.rs directory
that has a bunch of files corresponding to the RPCs in the proto file (i.e put_message_to_pods.rs).
So these are those files:
signup.rs
use crate::{store::SIGNING_KEY_ADDRESS, PASSCODE};
use crypto::generate_signing_keys;
pub fn signup(username: &String, password: &String) {
let (signing_key, verifying_key) = generate_signing_keys();
crate::store::write_key_pair_encrypted(
SIGNING_KEY_ADDRESS,
signing_key,
*PASSCODE.get().unwrap(),
)
.unwrap();
let signup_params = crate::app::SignupParams {
username: username.clone(),
password: password.clone(),
verifying_key: verifying_key.to_vec(),
signature: crypto::sign_content(username.as_bytes().to_vec(), signing_key),
};
wasm_bindgen_futures::spawn_local(async move {
let mut client = crate::get_app_client();
let logger = crate::logger::get_logger();
match client.signup(signup_params).await {
Ok(res) => {
let token = res.into_inner().token;
// TODO: write token to token space in database
}
Err(err) => {
logger.info("bad".to_string());
logger.info(err.message().to_string());
}
}
});
}
signin.rs
use crate::store::SIGNING_KEY_ADDRESS;
pub fn signin(username: &String, password: &String, signing_key: [u8; 32]) {
crate::store::write_key_pair_encrypted(
SIGNING_KEY_ADDRESS,
signing_key,
*crate::PASSCODE.get().unwrap(),
)
.unwrap();
let signin_params = crate::app::SigninParams {
username: username.clone(),
password: password.clone(),
signature: crypto::sign_content(username.as_bytes().to_vec(), signing_key),
};
wasm_bindgen_futures::spawn_local(async move {
let mut client = crate::get_app_client();
let logger = crate::logger::get_logger();
match client.signin(signin_params).await {
Ok(res) => {
let token = res.into_inner().token;
// TODO: write the `token` to the database
}
Err(err) => {
logger.info("bad".to_string());
logger.info(err.message().to_string());
}
}
});
}
put_message_to_pod.rs
use crate::app::PutMessageToPodParams;
use crate::{
store::{get_value_key_from_address_key_decrypted, SIGNING_KEY_ADDRESS},
PASSCODE,
};
// !! this `content` really should be a default protobuf message that we define and has a `bytes`
// !! field called `metadata` that is for a serialized protobuf message that can be used for your
// !! specific client.
pub fn put_message_to_pod(pod_id: String, content: Vec<u8>) {
let signing_key =
get_value_key_from_address_key_decrypted(SIGNING_KEY_ADDRESS, *PASSCODE.get().unwrap());
// TODO: swap out the `vec![]` with the public keys for the users for this pod from your routing table
let (nonce, key_sets, encrypted_content) =
crypto::encrypt_and_sign_content(signing_key, content, vec![]).unwrap();
let put_message_to_pod_params = PutMessageToPodParams {
pod_id,
key_sets,
nonce: nonce.to_vec(),
encrypted_content,
};
wasm_bindgen_futures::spawn_local(async move {
let mut client = crate::get_app_client();
let logger = crate::logger::get_logger();
match client.put_message_to_pod(put_message_to_pod_params).await {
Ok(res) => {
let _ = res.into_inner();
}
Err(err) => {
logger.info("bad".to_string());
logger.info(err.message().to_string());
}
}
});
}
get_messages_from_pod.rs
use crate::app::Message;
use parking_lot::Mutex;
use std::sync::Arc;
pub fn get_messages_from_pod(pod_id: String, max_count: u32, start: u64, end: u64) -> Vec<Message> {
// TODO: go get public keys from local cache that has the public key
// TODO: for that `start` / `end` date range.
let public_keys = vec![];
let get_messages_from_pod_params = crate::app::GetMessagesFromPodParams {
pod_id,
max_count,
start,
end,
public_keys,
};
let messages: Arc<Mutex<Vec<Message>>> = Arc::new(Mutex::new(Vec::new()));
let messages_clone = Arc::clone(&messages);
wasm_bindgen_futures::spawn_local(async move {
let mut client = crate::get_app_client();
let logger = crate::logger::get_logger();
match client
.get_messages_from_pod(get_messages_from_pod_params)
.await
{
Ok(res) => {
let mut messages_lock = messages_clone.lock();
*messages_lock = res.into_inner().messages;
}
Err(err) => {
logger.info("bad".to_string());
logger.info(err.message().to_string());
}
}
});
let messages_lock = messages.lock().clone();
messages_lock
}
delete_messages.rs
use crate::{
store::{get_value_key_from_address_key_decrypted, SIGNING_KEY_ADDRESS},
PASSCODE,
};
pub fn delete_messages(ids: Vec<String>) {
let mut signatures: Vec<u8> = vec![];
let signing_key =
get_value_key_from_address_key_decrypted(SIGNING_KEY_ADDRESS, *PASSCODE.get().unwrap());
for id in ids.clone() {
let id_sig = crypto::sign_content(id.as_bytes().to_vec(), signing_key);
signatures.extend(id_sig);
}
let delete_messages_params = crate::app::DeleteMessagesParams { ids, signatures };
wasm_bindgen_futures::spawn_local(async move {
let mut client = crate::get_app_client();
let logger = crate::logger::get_logger();
match client.delete_messages(delete_messages_params).await {
Ok(res) => {
let _ = res.into_inner();
}
Err(err) => {
logger.info("bad".to_string());
logger.info(err.message().to_string());
}
}
});
}
update_self.rs
use crate::app::UpdateSelfParams;
use crate::{
store::{get_value_key_from_address_key_decrypted, SIGNING_KEY_ADDRESS},
PASSCODE,
};
// !! same thing about this content being a protobuf message with metadata on it
pub fn update_self(content: Vec<u8>) {
let signing_key =
get_value_key_from_address_key_decrypted(SIGNING_KEY_ADDRESS, *PASSCODE.get().unwrap());
// TODO: get the public keys for this pod from the cache table
let (nonce, key_sets, encrypted_content) =
crypto::encrypt_and_sign_content(signing_key, content, vec![]).unwrap();
let update_self_params = UpdateSelfParams {
key_sets,
nonce: nonce.to_vec(),
encrypted_content,
};
wasm_bindgen_futures::spawn_local(async move {
let mut client = crate::get_app_client();
let logger = crate::logger::get_logger();
match client.update_self(update_self_params).await {
Ok(res) => {
let _ = res.into_inner();
}
Err(err) => {
logger.info("bad".to_string());
logger.info(err.message().to_string());
}
}
});
}
delete_self.rs
use crate::app::DeleteSelfParams;
use crate::{
store::{get_value_key_from_address_key_decrypted, SIGNING_KEY_ADDRESS},
PASSCODE,
};
pub fn delete_self(username: String, password: String) {
let signing_key =
get_value_key_from_address_key_decrypted(SIGNING_KEY_ADDRESS, *PASSCODE.get().unwrap());
let signature = crypto::sign_content(username.as_bytes().to_vec(), signing_key);
let delete_self_params = DeleteSelfParams {
username,
password,
signature,
};
wasm_bindgen_futures::spawn_local(async move {
let mut client = crate::get_app_client();
let logger = crate::logger::get_logger();
match client.delete_self(delete_self_params).await {
Ok(res) => {
let _ = res.into_inner();
}
Err(err) => {
logger.info("bad".to_string());
logger.info(err.message().to_string());
}
}
});
}
So a lot of it is pretty repetitive and there’s still work to do (also I straight up forgot to add the “get a user” functionality), so I’ll keep at it more in the morning.
Conclusion
I got some more stuff done…