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

Renamed some variables for clarity + minor fixes

Browse Source
This commit is contained in:
NicolasCantu 2025-01-30 16:06:35 +01:00
parent 9dc7e62f8f
commit d99d4f0067
1 changed files with 29 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
src/api.rs
View File

@ -106,12 +106,11 @@ pub struct UserDiff {
#[tsify(into_wasm_abi)] #[tsify(into_wasm_abi)]
#[allow(non_camel_case_types)] #[allow(non_camel_case_types)]
pub struct UpdatedProcess { pub struct UpdatedProcess {
pub commitment_tx: OutPoint, pub process_id: OutPoint,
pub current_process: Process, pub current_process: Process,
pub up_to_date_roles: HashMap<String, RoleDefinition>, pub up_to_date_roles: HashMap<String, RoleDefinition>,
pub new_diffs: Vec<UserDiff>, // All diffs should have the same new_state_merkle_root pub diffs: Vec<UserDiff>, // All diffs should have the same state_id
pub modified_state: Option<String>, // basically when we add/receive validation proofs for a state pub validated_state: Option<String>, // when we add/receive validation proofs for a state
// I think we should never have both new_state and modified_state
} }
#[derive(Debug, PartialEq, Tsify, Serialize, Deserialize, Default)] #[derive(Debug, PartialEq, Tsify, Serialize, Deserialize, Default)]
@ -310,7 +309,7 @@ pub fn is_paired() -> ApiResult<bool> {
} }
#[wasm_bindgen] #[wasm_bindgen]
pub fn pair_device(commitment_tx: String, mut sp_addresses: Vec<String>) -> ApiResult<()> { pub fn pair_device(process_id: String, mut sp_addresses: Vec<String>) -> ApiResult<()> {
let mut local_device = lock_local_device()?; let mut local_device = lock_local_device()?;
if local_device.get_pairing_commitment().is_some() { if local_device.get_pairing_commitment().is_some() {
@ -327,7 +326,7 @@ pub fn pair_device(commitment_tx: String, mut sp_addresses: Vec<String>) -> ApiR
} }
local_device.pair( local_device.pair(
OutPoint::from_str(&commitment_tx)?, OutPoint::from_str(&process_id)?,
Member::new( Member::new(
sp_addresses sp_addresses
.into_iter() .into_iter()
@ -644,17 +643,17 @@ fn process_transaction(
let roles = if let Ok(roles) = new_state.encrypted_pcd.extract_roles() { roles } else { HashMap::new() }; let roles = if let Ok(roles) = new_state.encrypted_pcd.extract_roles() { roles } else { HashMap::new() };
let diffs = if let Ok(diffs) = create_diffs(process, new_state) { diffs } else { vec![] }; let diffs = if let Ok(diffs) = create_diffs(process, new_state) { diffs } else { vec![] };
let updated_process = UpdatedProcess { let updated_process = UpdatedProcess {
commitment_tx: outpoint, process_id: outpoint,
current_process: process.clone(), current_process: process.clone(),
up_to_date_roles: roles, up_to_date_roles: roles,
new_diffs: diffs, diffs: diffs,
..Default::default() ..Default::default()
}; };
let api_return = ApiReturn { let api_return = ApiReturn {
updated_process: Some(updated_process), updated_process: Some(updated_process),
..Default::default() ..Default::default()
}; };
debug!("Found an update for process {:?}", api_return.updated_process.as_ref().unwrap().commitment_tx); debug!("Found an update for process {:?}", api_return.updated_process.as_ref().unwrap().process_id);
return Ok(api_return); return Ok(api_return);
} }
Err(e) => debug!("Failed to find process update: {}", e) Err(e) => debug!("Failed to find process update: {}", e)
@ -706,7 +705,7 @@ fn confirm_prd(prd: &Prd, shared_secret: &AnkSharedSecretHash) -> AnyhowResult<S
_ => (), _ => (),
} }
let outpoint = OutPoint::from_str(&prd.root_commitment)?; let outpoint = OutPoint::from_str(&prd.process_id)?;
let local_device = lock_local_device()?; let local_device = lock_local_device()?;
let sender = local_device.to_member(); let sender = local_device.to_member();
@ -865,7 +864,7 @@ fn handle_prd(
return handle_prd_connect(prd, secret); return handle_prd_connect(prd, secret);
} }
let outpoint = OutPoint::from_str(&prd.root_commitment)?; let outpoint = OutPoint::from_str(&prd.process_id)?;
let mut processes = lock_processes()?; let mut processes = lock_processes()?;
let relevant_process = match processes.entry(outpoint) { let relevant_process = match processes.entry(outpoint) {
@ -885,7 +884,7 @@ fn handle_prd(
return Err(AnyhowError::msg("Received update for a state we already know")); return Err(AnyhowError::msg("Received update for a state we already know"));
} }
let commited_in = OutPoint::from_str(&prd.root_commitment)?; let commited_in = relevant_process.get_process_tip()?;
// Extract the roles from the payload // Extract the roles from the payload
let proposal_roles: HashMap<String, RoleDefinition> = serde_json::from_str(&prd.payload)?; let proposal_roles: HashMap<String, RoleDefinition> = serde_json::from_str(&prd.payload)?;
@ -917,9 +916,9 @@ fn handle_prd(
relevant_process.insert_concurrent_state(new_state)?; relevant_process.insert_concurrent_state(new_state)?;
let updated_process = UpdatedProcess { let updated_process = UpdatedProcess {
commitment_tx: outpoint, process_id: outpoint,
current_process: relevant_process.clone(), current_process: relevant_process.clone(),
new_diffs: diffs, diffs,
up_to_date_roles: roles, up_to_date_roles: roles,
..Default::default() ..Default::default()
}; };
@ -966,9 +965,9 @@ fn handle_prd(
let clear_state = to_update.decrypt_pcd()?; let clear_state = to_update.decrypt_pcd()?;
let roles = Value::Object(clear_state).extract_roles()?; let roles = Value::Object(clear_state).extract_roles()?;
let modified_state = Some(to_update.state_id.clone()); let validated_state = Some(to_update.state_id.clone());
let mut commit_msg = CommitMessage::new_update_commitment( let mut commit_msg = CommitMessage::new_update_commitment(
OutPoint::from_str(&prd.root_commitment)?, OutPoint::from_str(&prd.process_id)?,
updated_state.pcd_commitment, updated_state.pcd_commitment,
roles roles
); );
@ -977,9 +976,9 @@ fn handle_prd(
// We must return an update of the process // We must return an update of the process
let updated_process = UpdatedProcess { let updated_process = UpdatedProcess {
commitment_tx: OutPoint::from_str(&prd.root_commitment)?, process_id: OutPoint::from_str(&prd.process_id)?,
current_process: relevant_process.clone(), current_process: relevant_process.clone(),
modified_state, validated_state,
..Default::default() ..Default::default()
}; };
@ -1008,11 +1007,11 @@ fn handle_decrypted_message(
#[wasm_bindgen] #[wasm_bindgen]
/// Use the provided Map to update a state /// Use the provided Map to update a state
/// The map uses hash commitment as keys, as in storage /// The map uses hash commitment as keys, as in storage
pub fn update_process_state(init_commitment: String, state_id: String, hash2values: String) -> ApiResult<ApiReturn> { pub fn update_process_state(process_id: String, state_id: String, hash2values: String) -> ApiResult<ApiReturn> {
let hash2values_map = serde_json::from_str::<Value>(&hash2values)?.to_value_object()?; let hash2values_map = serde_json::from_str::<Value>(&hash2values)?.to_value_object()?;
// Get the process // Get the process
let outpoint = OutPoint::from_str(&init_commitment)?; let outpoint = OutPoint::from_str(&process_id)?;
let mut processes = lock_processes()?; let mut processes = lock_processes()?;
{ {
@ -1021,10 +1020,7 @@ pub fn update_process_state(init_commitment: String, state_id: String, hash2valu
.ok_or(ApiError::new("Unknown process".to_owned()))?; .ok_or(ApiError::new("Unknown process".to_owned()))?;
// Get the state // Get the state
let state = process.get_latest_concurrent_states_mut()? let state = process.get_state_for_id_mut(&state_id)?;
.into_iter()
.find(|state| state.state_id == state_id)
.ok_or(ApiError::new("Unknown state".to_owned()))?;
// Update each value // Update each value
// Check if there's already something // Check if there's already something
@ -1081,13 +1077,13 @@ pub fn update_process_state(init_commitment: String, state_id: String, hash2valu
// If every value we can decrypt is valid, then we return the new state and diffs // If every value we can decrypt is valid, then we return the new state and diffs
// We borrow it again immutably // We borrow it again immutably
let process = processes.get(&outpoint).unwrap(); let process = processes.get(&outpoint).unwrap();
let state = process.get_latest_concurrent_states()?.into_iter().find(|s| s.state_id == state_id).unwrap(); let state = process.get_state_for_id(&state_id)?;
let diffs = create_diffs(&process, &state)?; let diffs = create_diffs(&process, &state)?;
let udpated_process = UpdatedProcess { let udpated_process = UpdatedProcess {
commitment_tx: outpoint, process_id: outpoint,
current_process: process.clone(), current_process: process.clone(),
new_diffs: diffs, diffs: diffs,
..Default::default() ..Default::default()
}; };
@ -1278,10 +1274,10 @@ pub fn create_new_process(
let commit_msg = CommitMessage::new_first_commitment(transaction, new_state.pcd_commitment, roles.clone()); let commit_msg = CommitMessage::new_first_commitment(transaction, new_state.pcd_commitment, roles.clone());
let updated_process = UpdatedProcess { let updated_process = UpdatedProcess {
commitment_tx: outpoint, process_id: outpoint,
current_process: process, current_process: process,
up_to_date_roles: roles, up_to_date_roles: roles,
new_diffs: diffs, diffs: diffs,
..Default::default() ..Default::default()
}; };
@ -1339,10 +1335,10 @@ pub fn update_process(
process.insert_concurrent_state(new_state.clone())?; process.insert_concurrent_state(new_state.clone())?;
let updated_process = UpdatedProcess { let updated_process = UpdatedProcess {
commitment_tx: outpoint, process_id: outpoint,
current_process: process.clone(), current_process: process.clone(),
up_to_date_roles: roles.clone(), up_to_date_roles: roles.clone(),
new_diffs: diffs, diffs,
..Default::default() ..Default::default()
}; };
@ -1536,9 +1532,9 @@ fn add_validation_token(init_commitment: String, merkle_root_hex: String, approv
}; };
let updated_process = UpdatedProcess { let updated_process = UpdatedProcess {
commitment_tx: OutPoint::from_str(&init_commitment)?, process_id: OutPoint::from_str(&init_commitment)?,
current_process: process.clone(), current_process: process.clone(),
modified_state: Some(merkle_root_hex), validated_state: Some(merkle_root_hex),
..Default::default() ..Default::default()
}; };