4nk/sdk_client
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Process initial update

Browse Source
This commit is contained in:
Sosthene 2024-09-21 18:27:08 +02:00
parent b7bffe7678
commit b904f4ec81
5 changed files with 1047 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1125
src/api.rs
View File

File diff suppressed because it is too large Load Diff

35
src/lib.rs
View File

@ -2,12 +2,13 @@
use anyhow::Error;
use sdk_common::crypto::AnkSharedSecret;
use sdk_common::network::CachedMessage;
use sdk_common::pcd::AnkPcdHash;
use sdk_common::prd::{Prd, ValidationToken};
use sdk_common::process::Process;
use sdk_common::sp_client::bitcoin::OutPoint;
use sdk_common::uuid::Uuid;
use sdk_common::prd::ValidationToken;
use serde::{Deserialize, Serialize};
use serde_json::{Value, Map};
use serde_json::{Map, Value};
use std::collections::{HashMap, HashSet};
use std::fmt::Debug;
use std::ops::Index;
@ -27,40 +28,34 @@ pub fn lock_messages() -> Result<MutexGuard<'static, Vec<CachedMessage>>, Error>
.lock_anyhow()
}
#[derive(Debug)]
pub enum ProcessStatus {
Sealed,
Active(Vec<String>), // shared_secrets used to communicate on current session
}
#[derive(Debug, Clone)]
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct ProcessState {
pub commited_in: OutPoint,
pub encrypted_pcd: Value,
pub encrypted_pcd: Value,
pub keys: Map<String, Value>, // We may not always have all the keys
pub validation_token: Vec<ValidationToken> // This signs the encrypted pcd
pub validation_token: Vec<ValidationToken>, // This signs the encrypted pcd
}
#[derive(Debug)]
#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
pub struct RelevantProcess {
process: Process,
states: Vec<ProcessState>,
current_status: ProcessStatus,
shared_secrets: HashMap<String, String>,
impending_requests: Vec<Prd>,
}
impl RelevantProcess {
pub fn get_process(&self) -> Process {
self.process.clone()
}
pub fn get_status_at(&self, index: usize) -> Option<ProcessState> {
self.states.get(index).cloned()
}
pub fn get_latest_state(&self) -> Option<ProcessState> {
self.states.last().cloned()
}
}
pub static CACHEDPROCESSES: OnceLock<Mutex<HashMap<Uuid, RelevantProcess>>> = OnceLock::new();
pub static CACHEDPROCESSES: OnceLock<Mutex<HashMap<OutPoint, RelevantProcess>>> = OnceLock::new();
pub fn lock_processes() -> Result<MutexGuard<'static, HashMap<Uuid, RelevantProcess>>, Error> {
pub fn lock_processes() -> Result<MutexGuard<'static, HashMap<OutPoint, RelevantProcess>>, Error> {
CACHEDPROCESSES
.get_or_init(|| Mutex::new(HashMap::new()))
.lock_anyhow()

2
src/user.rs
View File

@ -22,11 +22,11 @@ use std::io::{Cursor, Read, Write};
use std::str::FromStr;
use std::sync::{Mutex, MutexGuard, OnceLock};
use sdk_common::device::Device;
use sdk_common::sp_client::bitcoin::secp256k1::constants::SECRET_KEY_SIZE;
use sdk_common::sp_client::silentpayments::bitcoin_hashes::sha256;
use sdk_common::sp_client::silentpayments::utils::{Network as SpNetwork, SilentPaymentAddress};
use sdk_common::sp_client::spclient::{OutputList, SpWallet, SpendKey};
use sdk_common::device::Device;
use crate::peers::Peer;
use crate::wallet::generate_sp_wallet;

233
tests/pairing.rs
View File

@ -1,17 +1,16 @@
use std::collections::HashMap;
use std::str::FromStr;
use sdk_client::api::{
create_device_from_sp_wallet, create_process_from_template, create_process_init_transaction, get_address, get_outputs, pair_device, reset_device, setup
create_device_from_sp_wallet, create_update_transaction, dump_device, dump_process_cache,
get_address, get_outputs, get_update_proposals, pair_device, parse_cipher, reset_device,
restore_device, set_process_cache, setup, ApiReturn,
};
use sdk_client::lock_processes;
use sdk_common::network::CachedMessage;
use sdk_common::pcd::{Member, Pcd};
use sdk_common::prd::Prd;
use sdk_common::log::debug;
use sdk_common::pcd::{Member, RoleDefinition};
use sdk_common::sp_client::bitcoin::OutPoint;
use sdk_common::sp_client::spclient::OwnedOutput;
use sdk_common::uuid::Uuid;
use sdk_common::log::debug;
use serde_json::{self, json};
use serde_json::{json, Value};
use tsify::JsValueSerdeExt;
use wasm_bindgen_test::*;
@ -38,117 +37,181 @@ fn test_pairing() {
let paired_device = helper_get_bob_address();
// Alice creates the new member with Bob address
let new_member = Member::new(
vec![
device_address.as_str().try_into().unwrap(),
paired_device.as_str().try_into().unwrap(),
]
).unwrap();
let new_member = Member::new(vec![
device_address.as_str().try_into().unwrap(),
paired_device.as_str().try_into().unwrap(),
])
.unwrap();
// We get the template for the pairing
// We don't really care how we get it, we can even imagine user writing it himself
// It just have to respect the basic Process struct, i.e. have all the fields below and the right type for the value
let pairing_template = json!({
"uuid": "",
let pairing_init_state = json!({
"html": "",
"script": "",
"style": "",
"init_state": {
"roles": {
"owner": {
"members":
[
new_member
],
"validation_rules":
[
{
"quorum": 0.0,
"fields": [
"roles",
"pairing_tx"
],
"min_sig_member": 0.0
}
]
}
},
"pairing_tx": "",
"script": "",
"roles": {
"owner": {
"members":
[
new_member
],
"validation_rules":
[
{
"quorum": 0.0,
"fields": [
"roles",
"pairing_tx"
],
"min_sig_member": 0.0
}
]
}
},
"commited_in": OutPoint::null()
"pairing_tx": OutPoint::null(),
});
let new_process = create_process_from_template(pairing_template.to_string()).unwrap();
debug!("Alice pairs her device");
// we can update our local device now, first with an empty txid
pair_device(OutPoint::null().to_string(), vec![helper_get_bob_address()]).unwrap();
// we can update our local device now
pair_device(new_process.uuid.clone(), vec![helper_get_bob_address()]).unwrap();
debug!("Alice sends a transaction commiting to an update prd to Bob");
let alice_pairing_return =
create_update_transaction(None, pairing_init_state.to_string(), 1).unwrap();
debug!("Alice sends a transaction commiting to an init prd to Bob");
let alice_pairing_return = create_process_init_transaction(new_process, 1).unwrap();
// debug!("{:?}", alice_pairing_return);
// todo must take all the necessary validation before commiting
// debug!("Alice prepares the commit message for the relay");
// let (outpoint, process) = alice_pairing_return.updated_process.unwrap();
// let to_commit = process.get_status_at(0).unwrap().encrypted_pcd;
// let init_return = create_commit_message(serde_json::to_string(&to_commit).unwrap(), RELAY_ADDRESS.to_owned(), None, 1).unwrap();
// todo send the commit message to the relay
let pairing_tx = alice_pairing_return.new_tx_to_send.unwrap();
// We can update the local device with the actual pairing outpoint
pair_device(
OutPoint::new(pairing_tx.txid(), 0).to_string(),
vec![helper_get_bob_address()],
)
.unwrap();
// This is only for testing, the relay takes care of that in prod
let get_outputs_result = get_outputs().unwrap();
let alice_outputs: HashMap<OutPoint, OwnedOutput> = get_outputs_result.into_serde().unwrap();
let alice_pairing_tweak_data =
helper_get_tweak_data(&alice_pairing_return.transaction, alice_outputs);
let alice_pairing_tweak_data = helper_get_tweak_data(&pairing_tx, alice_outputs);
// Alice parse her own transaction
helper_parse_transaction(&alice_pairing_return.transaction, &alice_pairing_tweak_data).id;
// End of the test only part
// Alice parses her own transaction
helper_parse_transaction(&pairing_tx, &alice_pairing_tweak_data);
// Notify user that we're waiting for confirmation from the other device
let alice_device = dump_device().unwrap();
let alice_processes = dump_process_cache().unwrap();
debug!("Alice processes: {:#?}", alice_processes);
// ======================= Bob
reset_device().unwrap();
create_device_from_sp_wallet(BOB_LOGIN_WALLET.to_owned()).unwrap();
// Bob receives Alice pairing transaction
debug!("Bob parses Alice pairing transaction");
helper_parse_transaction(&alice_pairing_return.transaction, &alice_pairing_tweak_data);
helper_parse_transaction(&pairing_tx, &alice_pairing_tweak_data);
debug!("Bob receives the prd");
let mut bob_retrieved_prd = CachedMessage::default();
for message in alice_pairing_return.new_messages.iter() {
for cipher in message.cipher.iter() {
match helper_parse_cipher(cipher.clone()) {
Ok(res) => bob_retrieved_prd = res,
Err(_) => continue
let mut bob_retrieved_prd: ApiReturn = ApiReturn::default();
for cipher in alice_pairing_return.ciphers_to_send.iter() {
// debug!("Parsing cipher: {:#?}", cipher);
match parse_cipher(cipher.clone()) {
Ok(res) => bob_retrieved_prd = res,
Err(e) => {
debug!("Error parsing cipher: {:#?}", e);
continue;
}
}
}
if bob_retrieved_prd == CachedMessage::default() {
panic!("Bob failed to retrieve Alice message");
}
assert!(bob_retrieved_prd != ApiReturn::default());
debug!("Bob receives the pcd");
let mut bob_retrieved_pcd = CachedMessage::default();
for message in alice_pairing_return.new_messages {
for cipher in message.cipher {
match helper_parse_cipher(cipher) {
Ok(res) => bob_retrieved_pcd = res,
Err(_) => continue
}
}
}
debug!("Bob retrieved prd: {:#?}", bob_retrieved_prd);
if bob_retrieved_pcd == CachedMessage::default() {
panic!("Bob failed to retrieve Alice message");
}
debug!("Bob sends a Confirm Prd to Alice");
let bob_device = dump_device().unwrap();
let bob_processes = dump_process_cache().unwrap();
// ======================= Alice
reset_device().unwrap();
restore_device(alice_device).unwrap();
set_process_cache(alice_processes).unwrap();
debug!("Alice receives the Confirm Prd");
let alice_parsed_prd = parse_cipher(bob_retrieved_prd.ciphers_to_send[0].clone()).unwrap();
debug!("Alice parsed Bob's Confirm Prd: {:#?}", alice_parsed_prd);
// ======================= Bob
reset_device().unwrap();
restore_device(bob_device).unwrap();
set_process_cache(bob_processes).unwrap();
let bob_parsed_pcd_return = parse_cipher(alice_parsed_prd.ciphers_to_send[0].clone()).unwrap();
debug!("bob_parsed_pcd: {:#?}", bob_parsed_pcd_return);
// At this point, user must validate the pairing proposal received from Alice
// We decrypt the content of the pcd so that we can display to user what matters
let alice_proposal =
get_update_proposals(bob_parsed_pcd_return.updated_process.unwrap().0).unwrap();
debug!("Bob pairs device with Alice");
let process = lock_processes().unwrap();
let prd: Prd = serde_json::from_str(&bob_retrieved_prd.prd.unwrap()).unwrap();
let relevant_process = process.get(&Uuid::parse_str(&prd.process_uuid).unwrap()).unwrap();
// decrypt the pcd and update bob device
if let Some(initial_state) = relevant_process.get_status_at(0) {
let keys = initial_state.keys;
let mut pcd = initial_state.encrypted_pcd;
pcd.decrypt_fields(&keys).unwrap();
pair_device(relevant_process.get_process().uuid, vec![device_address]).unwrap();
}
debug!("Alice proposal: {:#?}", alice_proposal);
// get the pairing tx from the proposal
let proposal = Value::from_str(&alice_proposal.get(0).unwrap()).unwrap();
let pairing_tx = proposal.get("pairing_tx").unwrap().as_str().unwrap();
let roles: RoleDefinition =
serde_json::from_str(proposal.get("roles").unwrap().as_str().unwrap()).unwrap();
// we check that the proposal contains only one member
assert!(roles.members.len() == 1);
// we get all the addresses of the members of the proposal
let proposal_members = roles
.members
.iter()
.flat_map(|member| member.get_addresses())
.collect::<Vec<String>>();
// we can automatically check that a pairing member contains local device address + the one that sent the proposal
assert!(proposal_members.contains(&device_address));
assert!(proposal_members.contains(&paired_device));
assert!(proposal_members.len() == 2); // no free riders
// we can now show all the addresses + pairing tx to the user on device to prompt confirmation
pair_device(pairing_tx.to_owned(), proposal_members).unwrap();
// Bob signs the proposal and send a prd response to Alice
// debug!("Bob pairs device with Alice");
// let process = lock_processes().unwrap();
// let prd: Prd = serde_json::from_str(&bob_retrieved_prd.prd.unwrap()).unwrap();
// let relevant_process = process.get(&Uuid::parse_str(&prd.process_uuid).unwrap()).unwrap();
// // decrypt the pcd and update bob device
// let pairing_tx: Txid;
// if let Some(initial_state) = relevant_process.get_status_at(0) {
// let keys = initial_state.keys;
// let mut pcd = initial_state.encrypted_pcd;
// pcd.decrypt_fields(&keys).unwrap();
// debug!("decrypted pcd: {:?}", pcd);
// pairing_tx = Txid::from_str(pcd.get("pairing_tx").unwrap().as_str().unwrap()).unwrap();
// pair_device(relevant_process.get_process().uuid, vec![device_address]).unwrap();
// }
// To make the pairing effective, alice and bob must now spend their respective output into a new transaction
// login();

40
tests/utils.rs
View File

File diff suppressed because one or more lines are too long