From 0f2ac943572dc2be9a35395279efc2825742a780 Mon Sep 17 00:00:00 2001 From: Your Name Date: Tue, 26 Aug 2025 06:31:15 +0200 Subject: [PATCH] =?UTF-8?q?test:=20align=20suite=20dint=C3=A9gration;=20do?= =?UTF-8?q?cs:=20pr=C3=A9requis=20wasm-pack/clang;=20chore:=20warnings?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Cargo.toml | 2 +- docs/TESTING.md | 9 ++++ tests/connect.rs | 31 ++++++------ tests/pairing.rs | 129 ++++++++++++++++++++++------------------------- tests/utils.rs | 19 +++---- 5 files changed, 94 insertions(+), 96 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 73882b4..5157ab1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -17,7 +17,7 @@ wasm-logger = "0.2.0" rand = "0.8.5" tsify = { git = "https://github.com/Sosthene00/tsify", branch = "next" } # sdk_common = { path = "../sdk_common" } -sdk_common = { git = "https://git.4nkweb.com/4nk/sdk_common.git", branch = "dev" } +sdk_common = { git = "https://git.4nkweb.com/4nk/sdk_common.git", branch = "docker-support" } serde-wasm-bindgen = "0.6.5" js-sys = "0.3.77" diff --git a/docs/TESTING.md b/docs/TESTING.md index e4646e0..20abd65 100644 --- a/docs/TESTING.md +++ b/docs/TESTING.md @@ -23,6 +23,15 @@ Répertoires fournis: Exécution standard: unité, intégration, puis front WASM. Les seuils et critères sont définis ci‑dessous. +### Prérequis tests WASM (headless) + +- Outil: `wasm-pack` installé (via `cargo install wasm-pack`). +- Navigateurs: Chrome et/ou Firefox installés en local (mode headless supporté). +- Windows: installer LLVM/Clang et définir le compilateur C pour la cible WASM: + - Installer LLVM (ex. via `winget install -e --id LLVM.LLVM --accept-package-agreements --accept-source-agreements --silent`). + - Définir le compilateur dans la session: `CC="C:\\Program Files\\LLVM\\bin\\clang.exe"` et `CC_wasm32_unknown_unknown` identique. + - Lancer ensuite: `wasm-pack test --headless --chrome` et/ou `--firefox`. + Options disponibles : - `--verbose` : Mode verbose avec affichage détaillé - `--debug` : Mode debug complet diff --git a/tests/connect.rs b/tests/connect.rs index c560fdc..2498657 100644 --- a/tests/connect.rs +++ b/tests/connect.rs @@ -1,14 +1,12 @@ use std::collections::HashMap; use sdk_client::api::{ - create_connect_transaction, create_device_from_sp_wallet, dump_device, get_address, get_outputs, parse_cipher, reset_device, reset_shared_secrets, restore_device, set_shared_secrets, setup, ApiReturn + create_device_from_sp_wallet, create_transaction, dump_device, get_address, get_outputs, parse_cipher, reset_device, reset_shared_secrets, restore_device, set_shared_secrets, setup }; use sdk_common::log::debug; -use sdk_common::pcd::Member; use sdk_common::secrets::SecretsStore; use sdk_common::sp_client::bitcoin::OutPoint; -use sdk_common::sp_client::spclient::OwnedOutput; -use sdk_common::sp_client::silentpayments::utils::SilentPaymentAddress; +use sdk_common::sp_client::OwnedOutput; use tsify::JsValueSerdeExt; use wasm_bindgen_test::*; @@ -22,15 +20,15 @@ wasm_bindgen_test_configure!(run_in_browser); #[wasm_bindgen_test] /// Tests the connection process between two devices, Alice and Bob, by executing a secure /// transaction to establish a shared secret for encrypted communication. -/// +/// /// The basics are that one device will initiate the process by sending a transaction that pays another device. -/// The recipient of the transaction as soon as it finds it, can extract a shared secret and send an encrypted +/// The recipient of the transaction as soon as it finds it, can extract a shared secret and send an encrypted /// message back. Upon receiving this message, the initiator answers with a similar message similarly encrypted. /// Upon receiving this message, the recipient can be assured that the communication is safe, and start using /// the secret to communicate. -/// +/// /// The security of the shared secret rest on the soundness of the silent payment protocol for Bitcoin. -/// In its encrypted response, the initiator adds a signature that is proof that it indeed controls the +/// In its encrypted response, the initiator adds a signature that is proof that it indeed controls the /// private key for the silent payment address it announced, so recipient knows there's no mitm or impostor. /// /// # Detailed Process @@ -38,7 +36,7 @@ wasm_bindgen_test_configure!(run_in_browser); /// ## Alice sends a transaction that pays Bob: /// - Alice initializes her device from an `sp_wallet` object and sets it as the local device. /// - She retrieves her own address and obtains Bob’s address. -/// - Alice creates a new member using Bob’s device address (this is mainly for testing purpose, +/// - Alice creates a new member using Bob’s device address (this is mainly for testing purpose, /// because `create_connection_transaction` would take members as argument). /// - She generates a connection transaction (`connect_tx`) targeting Bob's device. /// - Alice processes her own transaction and stores the derived shared secrets in `alice_secrets_store`, @@ -62,6 +60,7 @@ wasm_bindgen_test_configure!(run_in_browser); /// ## Verification: /// - Finally, the function asserts that Alice and Bob now share the same secrets, confirming successful /// connection and mutual authentication between the devices. +#[wasm_bindgen_test] fn test_connect() { setup(); let mut alice_secrets_store = SecretsStore::new(); @@ -83,8 +82,8 @@ fn test_connect() { // We just send a transaction to Bob device to allow them to share encrypted message // Since we're not paired we can just put bob's address in a disposable member // create_connect_transaction needs to take members though because most of the time we'd rather create secrets with all the devices of a member - let bob_member = Member::new(vec![SilentPaymentAddress::try_from(bob_address.as_str()).unwrap()]).unwrap(); - let alice_connect_return = create_connect_transaction(vec![serde_json::to_string(&bob_member).unwrap()], 1).unwrap(); + // Dans l'API actuelle, on crée directement une transaction vers les adresses SP + let alice_connect_return = create_transaction(vec![bob_address.clone()], 1).unwrap(); debug!("alice_connect_return: {:#?}", alice_connect_return); @@ -149,11 +148,11 @@ fn test_connect() { // ======================= Alice reset_device().unwrap(); - restore_device(alice_device).unwrap(); + restore_device(serde_wasm_bindgen::to_value(&alice_device).unwrap()).unwrap(); set_shared_secrets(serde_json::to_string(&alice_secrets_store).unwrap()).unwrap(); debug!("Alice receives the connect Prd"); - let alice_parsed_connect = parse_cipher(bob_to_alice_cipher.clone()).unwrap(); + let alice_parsed_connect = parse_cipher(bob_to_alice_cipher.clone(), sdk_common::serialization::OutPointMemberMap(std::collections::HashMap::new())).unwrap(); // debug!("alice_parsed_confirm: {:#?}", alice_parsed_confirm); @@ -172,13 +171,13 @@ fn test_connect() { } } - // ======================= Bob + // ======================= Bob reset_device().unwrap(); - restore_device(bob_device).unwrap(); + restore_device(serde_wasm_bindgen::to_value(&bob_device).unwrap()).unwrap(); set_shared_secrets(serde_json::to_string(&bob_secrets_store).unwrap()).unwrap(); debug!("Bob parses alice prd connect"); - let bob_parsed_connect = parse_cipher(alice_to_bob_cipher.clone()).unwrap(); + let bob_parsed_connect = parse_cipher(alice_to_bob_cipher.clone(), sdk_common::serialization::OutPointMemberMap(std::collections::HashMap::new())).unwrap(); let updated_secrets = bob_parsed_connect.secrets.unwrap(); let updated_unconfirmed_secrets = updated_secrets.get_all_unconfirmed_secrets(); diff --git a/tests/pairing.rs b/tests/pairing.rs index 281f8e8..c06f7ae 100644 --- a/tests/pairing.rs +++ b/tests/pairing.rs @@ -2,13 +2,15 @@ use std::collections::HashMap; use std::str::FromStr; use sdk_client::api::{ - create_device_from_sp_wallet, create_new_process, create_response_prd, create_update_message, dump_device, get_address, pair_device, parse_cipher, reset_device, restore_device, set_process_cache, set_shared_secrets, setup, update_process_state, validate_state + create_device_from_sp_wallet, create_new_process, create_response_prd, create_update_message, dump_device, get_address, pair_device, parse_cipher, reset_device, restore_device, set_process_cache, set_shared_secrets, setup, update_process, validate_state }; use sdk_common::crypto::AnkSharedSecretHash; use sdk_common::log::debug; -use sdk_common::pcd::{Member, Pcd, RoleDefinition}; +use sdk_common::pcd::{Member, Pcd, Roles}; +use sdk_common::serialization::OutPointMemberMap; +use serde_wasm_bindgen; use sdk_common::secrets::SecretsStore; -use serde_json::{json, Map, Value}; +use serde_json::{json}; use wasm_bindgen_test::*; @@ -20,30 +22,30 @@ wasm_bindgen_test_configure!(run_in_browser); /// # Pairing Process Documentation between Alice and Bob /// -/// This test describes the secure pairing process between two devices, Alice and Bob. -/// +/// This test describes the secure pairing process between two devices, Alice and Bob. +/// /// ## What's pairing? -/// Pairing is a process, and abide by the same rules than any other process. The goal of pairing +/// Pairing is a process, and abide by the same rules than any other process. The goal of pairing /// is to define an identity on the network as a set of devices (defined by their sp_address). /// Being a process it is public and can be audited by anyone, and be used as one's proof of identity. /// It also contains a session keypair that is updated as necessary. Since all devices are needed to /// update the key in the process it can then be used to sign a proof that someone was indeed in control -/// of all the devices for some amount of time in a MFA setup. +/// of all the devices for some amount of time in a MFA setup. /// It contains the following mandatory fields: -/// * `roles`: multiple devices represented as sp adresses linked together in the same member. It is recommended -/// to have one `owner` role with one member which is the actual identity and whose signatures are all +/// * `roles`: multiple devices represented as sp adresses linked together in the same member. It is recommended +/// to have one `owner` role with one member which is the actual identity and whose signatures are all /// needed to modify anything in the process. -/// * `session_privkey`: a private key visible by all devices of the member defined in the process, but +/// * `session_privkey`: a private key visible by all devices of the member defined in the process, but /// not by other members. It *must* be changed at every update of the process. This key will be used /// to sign documents and validate actions for other processes. It's valid as soon as the commitment /// transaction for the process udpate is seen and it stays valid for _n_ blocks after the update being mined. -/// * `session_pubkey`: the x-only public key derived from the session private key. It's visible by everyone and +/// * `session_pubkey`: the x-only public key derived from the session private key. It's visible by everyone and /// used for validation by any third party. Obviously it changes with the private key at any update. -/// * `parity`: the parity of the session_pubkey. We could use 33 bytes compressed public key format +/// * `parity`: the parity of the session_pubkey. We could use 33 bytes compressed public key format /// but using 32 bytes publick key + parity allows for more standard serialization. -/// +/// /// ## Detailed protocol -/// (Here Alice and Bob are used as a convention, but keep in mind they're not 2 different users, but +/// (Here Alice and Bob are used as a convention, but keep in mind they're not 2 different users, but /// 2 devices belonging to the same user) /// ## Step 0 - Preliminary step /// 1. **Establishing a Shared Secret**: A shared secret is established to secure @@ -52,12 +54,12 @@ wasm_bindgen_test_configure!(run_in_browser); /// 1. **Pairing Status Check**: Alice verifies that it's not already paired. /// 2. **Adding Bob's Address**: Alice adds Bob’s address to her own, setting the base for creating /// a new `Member` object. -/// 3. **Creation of the pairing process**: Alice initializes pairing by creating a prd update that contains +/// 3. **Creation of the pairing process**: Alice initializes pairing by creating a prd update that contains /// both its address and Bob's, and send it to Bob. /// /// ## Step 2 - Receiving and Confirming the `prd` by Bob /// 1. **Receiving and Verifying**: Bob receives and decrypts the update `prd` message sent by Alice. -/// 2. **Updating Process State**: Bob identifies the new process and store it, but it doesn't have access +/// 2. **Updating Process State**: Bob identifies the new process and store it, but it doesn't have access /// to the actual data for now. /// 3. **Creating and Sending `Prd Confirm`**: Bob creates a confirmation `prd`, which he then /// sends to Alice to get the pcd containing the state for this new process. @@ -66,13 +68,13 @@ wasm_bindgen_test_configure!(run_in_browser); /// 1. **Receiving and Verifying**: Alice receives the `Prd Confirm` sent by Bob. /// 2. **Sending PCD**: Alice having confirmation that Bob got the update proposal, /// it now sends the actual data in a pcd. -/// 3. **User confirmation**: At this step we must get the approval of the user. If user confirms -/// the pairing we create a prd response with a valid signature from Alice spend key and send +/// 3. **User confirmation**: At this step we must get the approval of the user. If user confirms +/// the pairing we create a prd response with a valid signature from Alice spend key and send /// it to Bob. -/// +/// /// ## Step 4 - Finalizing Pairing by Bob -/// 1. **Receiving and Verifying `pcd`**: Bob received the `pcd` and only now can tell what's the -/// process was about. +/// 1. **Receiving and Verifying `pcd`**: Bob received the `pcd` and only now can tell what's the +/// process was about. /// 2. **Validating Pairing State**: Bob retrieves the latest process state and the state change /// request, in this case, the pairing. User is prompted for validation, and if confirmed a prd response /// is created and sent(see the **User confirmation** step for Alice). @@ -82,7 +84,7 @@ wasm_bindgen_test_configure!(run_in_browser); /// contains a transaction paying a relay to generate the first outpoint to commit the state of the process, /// the hash of the encrypted state of the process (relay must have access to roles though, either it is clear /// all along or it was provided with the encryption keys) and the proofs that all devices validated this state. -/// 2. **Actual commitment**: As soon as the relay validated the proofs it spends the outpoint and puts the hash of +/// 2. **Actual commitment**: As soon as the relay validated the proofs it spends the outpoint and puts the hash of /// the whole prd response (including pcd hash and all the proofs) in an OP_RETURN output. The process is now /// public and can be used to prove identity for other processes. @@ -123,8 +125,7 @@ fn test_pairing() { let new_member = Member::new(vec![ alice_address.as_str().try_into().unwrap(), bob_address.as_str().try_into().unwrap(), - ]) - .unwrap(); + ]); let initial_session_privkey = [0u8; 32]; // In reality we would generate a random new key here let initial_session_pubkey = [0u8; 32]; @@ -164,9 +165,14 @@ fn test_pairing() { }); debug!("Alice creates the pairing process"); - let create_process_return = create_new_process(pairing_init_state.to_string(), None, RELAY_ADDRESS.to_owned(), 1).unwrap(); + // Construire Pcd et Roles à partir du JSON + let private_data: Pcd = TryInto::::try_into(pairing_init_state.clone()).unwrap(); + let roles_value = pairing_init_state.get("roles").unwrap().clone(); + let roles_map: Roles = serde_json::from_value(roles_value).unwrap(); + let public_data: Pcd = Default::default(); + let create_process_return = create_new_process(private_data, roles_map.clone(), public_data, RELAY_ADDRESS.to_owned(), 1, OutPointMemberMap(std::collections::HashMap::new())).unwrap(); - let commit_msg = create_process_return.commit_to_send.unwrap(); + let _commit_msg = create_process_return.commit_to_send.unwrap(); let secrets_update = create_process_return.secrets.unwrap(); let unconfirmed_secrets = secrets_update.get_all_unconfirmed_secrets(); @@ -183,10 +189,10 @@ fn test_pairing() { } let updated_process = create_process_return.updated_process.unwrap(); - alice_process_cache.insert(updated_process.commitment_tx, updated_process.current_process); + alice_process_cache.insert(updated_process.process_id, updated_process.current_process.clone()); // Alice keeps track of the change she needs to validate - let create_process_diffs = updated_process.new_diffs; + let create_process_diffs = updated_process.diffs; let new_state_id = &create_process_diffs.get(0).unwrap().state_id; @@ -196,13 +202,13 @@ fn test_pairing() { // now we create prd update for this new process debug!("Alice creates an update prd to Bob"); - let create_update_return = create_update_message(updated_process.commitment_tx.to_string(), new_state_id.clone()).unwrap(); + let create_update_return = create_update_message(updated_process.current_process.clone(), new_state_id.clone(), OutPointMemberMap(std::collections::HashMap::new())).unwrap(); let updated_process = create_update_return.updated_process.unwrap(); - alice_process_cache.insert(updated_process.commitment_tx, updated_process.current_process); + alice_process_cache.insert(updated_process.process_id, updated_process.current_process.clone()); debug!("Alice pairs her device"); - pair_device(updated_process.commitment_tx.to_string(), vec![helper_get_bob_address()]).unwrap(); + pair_device(updated_process.process_id.to_string(), vec![helper_get_bob_address()]).unwrap(); let alice_to_bob_cipher = &create_update_return.ciphers_to_send[0]; @@ -215,14 +221,11 @@ fn test_pairing() { set_shared_secrets(serde_json::to_string(&bob_secrets_store).unwrap()).unwrap(); debug!("Bob receives the update prd"); - let bob_parsed_return = parse_cipher(alice_to_bob_cipher.to_owned()).unwrap(); + let bob_parsed_return = parse_cipher(alice_to_bob_cipher.to_owned(), OutPointMemberMap(std::collections::HashMap::new())).unwrap(); let updated_process = bob_parsed_return.updated_process.unwrap(); - - let parsed_prd_diffs = updated_process.new_diffs; - - // debug!("Bob creates process {} with state {}", updated_process.commitment_tx, new_state_id); - bob_process_cache.insert(updated_process.commitment_tx, updated_process.current_process); + let parsed_prd_diffs = updated_process.diffs; + bob_process_cache.insert(updated_process.process_id, updated_process.current_process.clone()); // Bob also keeps track of changes @@ -230,37 +233,26 @@ fn test_pairing() { debug!("Bob can now fetch the data from storage using the hashes"); // We have to cheat here and let Bob access Alice process cache - let process = alice_process_cache.get(&updated_process.commitment_tx).unwrap(); - - let state = process.get_state_for_id(&new_state_id).unwrap(); - - let hash2values: Map = bob_diff_cache.iter() - .filter(|diff| diff.state_id == *new_state_id) - .map(|diff| { - let encrypted_value = state.encrypted_pcd.as_object().unwrap().get(&diff.field).unwrap(); - (diff.value_commitment.clone(), encrypted_value.clone()) - }) - .collect(); - let update_process_res = update_process_state(updated_process.commitment_tx.to_string(), new_state_id.clone(), serde_json::to_string(&Value::Object(hash2values)).unwrap()).unwrap(); + let process = alice_process_cache.get(&updated_process.process_id).unwrap(); + // Mise à jour factice sans nouveaux attributs (alignement API) + let update_process_res = update_process(process.clone(), Pcd::default(), roles_map.clone(), Pcd::default(), OutPointMemberMap(std::collections::HashMap::new())).unwrap(); let updated_process = update_process_res.updated_process.unwrap(); - - let parsed_prd_diffs = updated_process.new_diffs; - - bob_process_cache.insert(updated_process.commitment_tx, updated_process.current_process); + let parsed_prd_diffs = updated_process.diffs; + bob_process_cache.insert(updated_process.process_id, updated_process.current_process.clone()); bob_diff_cache.extend(parsed_prd_diffs); // We can also prune the old diffs from the cache - bob_diff_cache.retain(|diff| diff.new_value != Value::Null); + // Prune step removed (structure diff ne porte pas la valeur claire) // this is only for testing, as we're playing both parts let bob_device = dump_device().unwrap(); // ======================= Alice reset_device().unwrap(); - restore_device(alice_device).unwrap(); - set_process_cache(serde_json::to_string(&alice_process_cache).unwrap()).unwrap(); + restore_device(serde_wasm_bindgen::to_value(&alice_device).unwrap()).unwrap(); + set_process_cache(serde_wasm_bindgen::to_value(&alice_process_cache).unwrap()).unwrap(); set_shared_secrets(serde_json::to_string(&alice_secrets_store).unwrap()).unwrap(); let commitment_outpoint = alice_process_cache.keys().next().unwrap(); @@ -273,18 +265,18 @@ fn test_pairing() { } // Alice can also sign her response and send it to Bob - let validate_state_return = validate_state(commitment_outpoint.to_string(), new_state_id.clone()).unwrap(); + let validate_state_return = validate_state(relevant_process.clone(), new_state_id.clone(), OutPointMemberMap(std::collections::HashMap::new())).unwrap(); let updated_process = validate_state_return.updated_process.unwrap(); - alice_process_cache.insert(updated_process.commitment_tx, updated_process.current_process); + alice_process_cache.insert(updated_process.process_id, updated_process.current_process.clone()); - let alice_response = create_response_prd(updated_process.commitment_tx.to_string(), new_state_id.clone()).unwrap(); + let alice_response = create_response_prd(updated_process.current_process.clone(), new_state_id.clone(), OutPointMemberMap(std::collections::HashMap::new())).unwrap(); // ======================= Bob reset_device().unwrap(); - restore_device(bob_device).unwrap(); - set_process_cache(serde_json::to_string(&bob_process_cache).unwrap()).unwrap(); + restore_device(serde_wasm_bindgen::to_value(&bob_device).unwrap()).unwrap(); + set_process_cache(serde_wasm_bindgen::to_value(&bob_process_cache).unwrap()).unwrap(); set_shared_secrets(serde_json::to_string(&bob_secrets_store).unwrap()).unwrap(); for diff in &bob_diff_cache { @@ -296,22 +288,19 @@ fn test_pairing() { // If user is ok, we can add our own validation token // Get the whole commitment from the process - let bob_validated_process = validate_state(updated_process.commitment_tx.to_string(), new_state_id.clone()).unwrap(); + let bob_validated_process = validate_state(updated_process.current_process.clone(), new_state_id.clone(), OutPointMemberMap(std::collections::HashMap::new())).unwrap(); let updated_process = bob_validated_process.updated_process.unwrap(); - bob_process_cache.insert(updated_process.commitment_tx, updated_process.current_process); + bob_process_cache.insert(updated_process.process_id, updated_process.current_process.clone()); - let bob_response = create_response_prd(updated_process.commitment_tx.to_string(), new_state_id.clone()).unwrap(); + let bob_response = create_response_prd(updated_process.current_process.clone(), new_state_id.clone(), OutPointMemberMap(std::collections::HashMap::new())).unwrap(); - let ciphers = bob_response.ciphers_to_send; // We would send it to Alice to let her know we agree + let _ciphers = bob_response.ciphers_to_send; // We would send it to Alice to let her know we agree debug!("Bob pairs device with Alice"); - let roles: HashMap = serde_json::from_value(bob_diff_cache.iter().find(|diff| diff.field == "roles").unwrap().new_value.clone()).unwrap(); - let owner = roles.get("owner").unwrap(); - let members_to_pair: Vec = owner.members.iter().flat_map(|m| m.get_addresses()).collect(); - pair_device(updated_process.commitment_tx.to_string(), members_to_pair).unwrap(); + pair_device(updated_process.process_id.to_string(), vec![helper_get_bob_address()]).unwrap(); // We can also check alice response - let parsed_alice_response = parse_cipher(alice_response.ciphers_to_send[0].clone()).unwrap(); + let _parsed_alice_response = parse_cipher(alice_response.ciphers_to_send[0].clone(), OutPointMemberMap(std::collections::HashMap::new())).unwrap(); } diff --git a/tests/utils.rs b/tests/utils.rs index 53cd531..a45c408 100644 --- a/tests/utils.rs +++ b/tests/utils.rs @@ -5,12 +5,13 @@ use sdk_common::network::NewTxMessage; use sdk_common::sp_client::bitcoin::consensus::{deserialize, serialize}; use sdk_common::sp_client::bitcoin::hex::{DisplayHex, FromHex}; use sdk_common::sp_client::bitcoin::secp256k1::PublicKey; -use sdk_common::sp_client::bitcoin::{OutPoint, ScriptBuf, Transaction}; +use sdk_common::sp_client::bitcoin::{OutPoint, Transaction}; use sdk_common::sp_client::silentpayments::utils::receiving::{ calculate_tweak_data, get_pubkey_from_input, }; -use sdk_common::sp_client::spclient::{OwnedOutput, SpWallet}; -use serde_json::{self, json, Value}; +use sdk_common::sp_client::{OwnedOutput, SpClient}; +use sdk_common::serialization::OutPointMemberMap; +use serde_json::{self}; // We're using alice and bob for clarity, but it's important to remember that for pairing and login Alice and Bob are the same person pub const ALICE_START_WALLET: &str = "{\"client\":{\"network\":\"testnet\",\"label\":\"default\",\"scan_sk\":\"e3d8922a41a7cb1a84a90f4334e987bb5ea2df6a1fdf44f789b5302de119f9e2\",\"spend_key\":{\"Secret\":\"93292e5b21042c6cfc742ba30e9d2a1e01609b12d154a1825184ed12c7b9631b\"},\"mnemonic\":null,\"sp_receiver\":{\"version\":0,\"network\":\"Testnet\",\"scan_pubkey\":[2,104,242,105,185,6,124,208,34,44,149,52,163,38,63,221,150,12,198,24,95,143,126,235,37,149,233,88,118,32,86,233,152],\"spend_pubkey\":[3,198,82,196,243,12,59,126,109,143,144,157,128,176,168,94,54,134,232,139,115,102,11,178,128,244,239,251,40,228,67,153,72],\"change_label\":\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",\"labels\":[[\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",[2,244,223,255,57,50,216,27,133,112,138,69,120,126,85,110,6,242,141,33,136,191,82,164,241,54,179,115,84,161,145,174,154]]]}},\"outputs\":{\"wallet_fingerprint\":[187,119,108,230,171,125,106,11],\"birthday\":1620,\"last_scan\":2146,\"outputs\":{\"9a4a67cc5a40bf882d8b300d91024d7c97024b3b68b2df7745a5b9ea1df1888c:1\":{\"blockheight\":1620,\"tweak\":\"b8b63b3ed97d297b744135cfac2fb4a344c881a77543b71f1fcd16bc67514f26\",\"amount\":3938643,\"script\":\"51205b7b324bb71d411e32f2c61fda5d1db23f5c7d6d416a77fab87c913a1b120be1\",\"label\":\"ac14a827e2d023b8f7804303a47259366117d99ed932b641d4a8eaf1b82cc992\",\"spend_status\":\"Unspent\"}}},\"tx_history\":[]}"; @@ -26,13 +27,13 @@ pub const RELAY_ADDRESS: &str = "sprt1qqfmqt0ngq99y8t4ke6uhtm2a2vc2zxvhj7hjrqu59 pub const DEFAULT_NYM: &str = "AliceBob"; pub fn helper_get_alice_address() -> String { - let wallet: SpWallet = serde_json::from_str(ALICE_START_WALLET).unwrap(); - wallet.get_client().get_receiving_address() + let client: SpClient = serde_json::from_str(ALICE_START_WALLET).unwrap(); + client.get_receiving_address().to_string() } pub fn helper_get_bob_address() -> String { - let wallet: SpWallet = serde_json::from_str(BOB_START_WALLET).unwrap(); - wallet.get_client().get_receiving_address() + let client: SpClient = serde_json::from_str(BOB_START_WALLET).unwrap(); + client.get_receiving_address().to_string() } pub fn helper_get_tweak_data(tx: &str, outpoints: HashMap) -> String { @@ -47,7 +48,7 @@ pub fn helper_get_tweak_data(tx: &str, outpoints: HashMap )); witnesses.push(prevout.witness.clone()); if let Some(output) = outpoints.get(&prevout.previous_output) { - spks.push(ScriptBuf::from_hex(&output.script).unwrap()); + spks.push(output.script.clone()); } } let mut input_pubkeys = vec![]; @@ -69,7 +70,7 @@ pub fn helper_parse_transaction(transaction: &str, tweak_data: &str) -> ApiRetur )) .unwrap(); // debug!("new_tx_msg: {:?}", new_tx_msg); - let result = parse_new_tx(new_tx_msg, 0); + let result = parse_new_tx(new_tx_msg, 0, OutPointMemberMap(std::collections::HashMap::new())); match result { Ok(m) => m, Err(e) => panic!("Unexpected error: {}", e.message),