From 7be7ac81d775fb3688134bac404e9824a609ed34 Mon Sep 17 00:00:00 2001 From: bayk Date: Thu, 26 Sep 2024 16:18:34 -0700 Subject: [PATCH 1/5] Viewing key, QT wallet intergation --- controller/src/command.rs | 97 +++++++++++++++++++++++++++++++-------- src/cmd/wallet_args.rs | 3 +- 2 files changed, 81 insertions(+), 19 deletions(-) diff --git a/controller/src/command.rs b/controller/src/command.rs index 05e3fe6c..4e711aca 100644 --- a/controller/src/command.rs +++ b/controller/src/command.rs @@ -48,7 +48,7 @@ use grin_wallet_libwallet::swap::fsm::state::StateId; use grin_wallet_libwallet::swap::trades; use grin_wallet_libwallet::swap::types::Action; use grin_wallet_libwallet::swap::{message, Swap}; -use grin_wallet_libwallet::{Slate, TxLogEntry, WalletInst}; +use grin_wallet_libwallet::{Slate, StatusMessage, TxLogEntry, WalletInst}; use grin_wallet_util::grin_core::consensus::MWC_BASE; use grin_wallet_util::grin_core::core::{amount_to_hr_string, Transaction}; use grin_wallet_util::grin_core::global::{FLOONET_DNS_SEEDS, MAINNET_DNS_SEEDS}; @@ -67,8 +67,11 @@ use std::io; use std::io::{Read, Write}; use std::path::{Path, PathBuf}; use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::mpsc; +use std::sync::mpsc::Sender; use std::sync::Arc; use std::thread; +use std::thread::JoinHandle; use std::time::Duration; use uuid::Uuid; @@ -152,6 +155,7 @@ where pub fn rewind_hash<'a, L, C, K>( owner_api: &mut Owner, keychain_mask: Option<&SecretKey>, + mwc713print: bool, ) -> Result<(), Error> where L: WalletLCProvider<'static, C, K>, @@ -160,11 +164,15 @@ where { controller::owner_single_use(None, keychain_mask, Some(owner_api), |api, m| { let rewind_hash = api.get_rewind_hash(m)?; - println!(); - println!("Wallet Rewind Hash"); - println!("-------------------------------------"); - println!("{}", rewind_hash); - println!(); + if mwc713print { + println!("Wallet Rewind Hash: {}", rewind_hash); + } else { + println!(); + println!("Wallet Rewind Hash"); + println!("-------------------------------------"); + println!("{}", rewind_hash); + println!(); + } Ok(()) })?; Ok(()) @@ -181,6 +189,7 @@ pub fn scan_rewind_hash( owner_api: &mut Owner, args: ViewWalletScanArgs, dark_scheme: bool, + show_progress: bool, ) -> Result<(), Error> where L: WalletLCProvider<'static, C, K> + 'static, @@ -201,21 +210,73 @@ where "Starting view wallet output scan from height {} ...", start_height ); - let result = api.scan_rewind_hash(rewind_hash, Some(start_height)); + + let mut status_send_channel: Option> = None; + let running = Arc::new(AtomicBool::new(true)); + let mut updater: Option> = None; + if show_progress { + let (tx, rx) = mpsc::channel(); + // Starting printing to console thread. + updater = Some( + grin_wallet_libwallet::api_impl::owner_updater::start_updater_console_thread( + rx, + running.clone(), + )?, + ); + status_send_channel = Some(tx); + } + + let result = owner::scan_rewind_hash( + api.wallet_inst.clone(), + rewind_hash, + Some(start_height), + &status_send_channel, + ); + let deci_sec = time::Duration::from_millis(100); - thread::sleep(deci_sec); - match result { - Ok(res) => { - warn!("View wallet check complete"); - if res.total_balance != 0 { - display::view_wallet_output(res.clone(), tip_height, dark_scheme)?; + if show_progress { + running.store(false, Ordering::Relaxed); + let _ = updater.unwrap().join(); + // Printing for parser + match result { + Ok(res) => { + println!("View wallet check complete"); + for m in res.output_result { + println!( + "ViewOutput: {},{},{},{},{},{},{}", + m.commit, + m.mmr_index, + m.height, + m.lock_height, + m.is_coinbase, + m.num_confirmations(tip_height), + m.value + ); + } + println!("ViewTotal: {}", res.total_balance); + Ok(()) + } + Err(e) => { + println!("View wallet check failed: {}", e); + Err(e.into()) } - display::view_wallet_balance(res.clone(), tip_height, dark_scheme); - Ok(()) } - Err(e) => { - error!("View wallet check failed: {}", e); - Err(e.into()) + } else { + // nice printing + thread::sleep(deci_sec); + match result { + Ok(res) => { + warn!("View wallet check complete"); + if res.total_balance != 0 { + display::view_wallet_output(res.clone(), tip_height, dark_scheme)?; + } + display::view_wallet_balance(res.clone(), tip_height, dark_scheme); + Ok(()) + } + Err(e) => { + error!("View wallet check failed: {}", e); + Err(e.into()) + } } } })?; diff --git a/src/cmd/wallet_args.rs b/src/cmd/wallet_args.rs index acf832e4..9d7a6258 100644 --- a/src/cmd/wallet_args.rs +++ b/src/cmd/wallet_args.rs @@ -1726,13 +1726,14 @@ where mqs_config, global_wallet_args, ), - ("rewind_hash", Some(_)) => command::rewind_hash(owner_api, km), + ("rewind_hash", Some(_)) => command::rewind_hash(owner_api, km, false), ("scan_rewind_hash", Some(args)) => { let a = arg_parse!(parse_scan_rewind_hash_args(&args)); command::scan_rewind_hash( owner_api, a, wallet_config.dark_background_color_scheme.unwrap_or(true), + false, ) } ("account", Some(args)) => { From 240afb353486935db4e0b8651fae2e408738bcfa Mon Sep 17 00:00:00 2001 From: bayk Date: Mon, 30 Sep 2024 15:15:24 -0700 Subject: [PATCH 2/5] Ownership proof --- api/src/owner.rs | 50 ++++- controller/src/command.rs | 78 +++++++- controller/tests/ownership_proofs.rs | 237 +++++++++++++++++++++++ libwallet/src/api_impl/owner.rs | 279 ++++++++++++++++++++++++++- libwallet/src/api_impl/types.rs | 54 ++++++ libwallet/src/error.rs | 4 + libwallet/src/lib.rs | 6 +- libwallet/src/proof/crypto.rs | 34 ++++ libwallet/src/slate.rs | 2 +- src/bin/mwc-wallet.yml | 28 +++ src/cmd/wallet_args.rs | 19 ++ 11 files changed, 782 insertions(+), 9 deletions(-) create mode 100644 controller/tests/ownership_proofs.rs diff --git a/api/src/owner.rs b/api/src/owner.rs index 23ce91e2..0c70ceef 100644 --- a/api/src/owner.rs +++ b/api/src/owner.rs @@ -43,7 +43,7 @@ use crate::util::secp::key::SecretKey; use crate::util::{from_hex, Mutex, ZeroingString}; use grin_wallet_util::grin_util::secp::key::PublicKey; use grin_wallet_util::grin_util::static_secp_instance; -use libwallet::RetrieveTxQueryArgs; +use libwallet::{OwnershipProof, OwnershipProofValidation, RetrieveTxQueryArgs}; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::mpsc::{channel, Sender}; use std::sync::Arc; @@ -2435,6 +2435,31 @@ where owner::verify_payment_proof(self.wallet_inst.clone(), keychain_mask, proof) } + pub fn retrieve_ownership_proof( + &self, + keychain_mask: Option<&SecretKey>, + message: String, + include_public_root_key: bool, + include_tor_address: bool, + include_mqs_address: bool, + ) -> Result { + owner::generate_ownership_proof( + self.wallet_inst.clone(), + keychain_mask, + message, + include_public_root_key, + include_tor_address, + include_mqs_address, + ) + } + + pub fn validate_ownership_proof( + &self, + proof: OwnershipProof, + ) -> Result { + owner::validate_ownership_proof(proof) + } + /// Start swap trade process. Return SwapID that can be used to check the status or perform further action. pub fn swap_start( &self, @@ -2796,3 +2821,26 @@ macro_rules! doctest_helper_setup_doc_env { let mut $wallet = Arc::new(Mutex::new(wallet)); }; } + +/*#[test] +#[allow(unused_mut)] +fn test_api() { + use crate as grin_wallet_api; + global::set_local_chain_type(global::ChainTypes::AutomatedTesting); + grin_wallet_api::doctest_helper_setup_doc_env!(wallet, wallet_config); + let mut api_owner = Owner::new(wallet.clone(), None, None); + + let proof = api_owner.retrieve_ownership_proof(None, + "my message to sign".to_string(), + true, + true, + true).unwrap(); + + let valiation = api_owner.validate_ownership_proof(proof).unwrap(); + + assert_eq!(valiation.network, "floonet"); + assert_eq!(valiation.message, "my message to sign".to_string()); + assert!(valiation.viewing_key.is_some()); + assert!(valiation.tor_address.is_some()); + assert!(valiation.mqs_address.is_some()); +}*/ diff --git a/controller/src/command.rs b/controller/src/command.rs index 4e711aca..946f73ff 100644 --- a/controller/src/command.rs +++ b/controller/src/command.rs @@ -48,7 +48,7 @@ use grin_wallet_libwallet::swap::fsm::state::StateId; use grin_wallet_libwallet::swap::trades; use grin_wallet_libwallet::swap::types::Action; use grin_wallet_libwallet::swap::{message, Swap}; -use grin_wallet_libwallet::{Slate, StatusMessage, TxLogEntry, WalletInst}; +use grin_wallet_libwallet::{OwnershipProof, Slate, StatusMessage, TxLogEntry, WalletInst}; use grin_wallet_util::grin_core::consensus::MWC_BASE; use grin_wallet_util::grin_core::core::{amount_to_hr_string, Transaction}; use grin_wallet_util::grin_core::global::{FLOONET_DNS_SEEDS, MAINNET_DNS_SEEDS}; @@ -178,6 +178,82 @@ where Ok(()) } +/// Arguments for generate_ownership_proof command +pub struct GenerateOwnershipProofArgs { + /// Message to sign + pub message: String, + /// does need to include public root key + pub include_public_root_key: bool, + /// does need to include tor address + pub include_tor_address: bool, + /// does need to include MQS address + pub include_mqs_address: bool, +} + +pub fn generate_ownership_proof<'a, L, C, K>( + owner_api: &mut Owner, + keychain_mask: Option<&SecretKey>, + args: GenerateOwnershipProofArgs, +) -> Result<(), Error> +where + L: WalletLCProvider<'static, C, K>, + C: NodeClient + 'static, + K: keychain::Keychain + 'static, +{ + controller::owner_single_use(None, keychain_mask, Some(owner_api), |api, m| { + let proof = api.retrieve_ownership_proof( + m, + args.message, + args.include_public_root_key, + args.include_tor_address, + args.include_mqs_address, + )?; + + let proof_json = serde_json::to_string(&proof).map_err(|e| { + Error::GenericError(format!("Failed convert proof result into json, {}", e)) + })?; + + println!("Ownership Proof: {}", proof_json); + Ok(()) + })?; + Ok(()) +} + +pub fn validate_ownership_proof<'a, L, C, K>( + owner_api: &mut Owner, + keychain_mask: Option<&SecretKey>, + proof: &str, +) -> Result<(), Error> +where + L: WalletLCProvider<'static, C, K>, + C: NodeClient + 'static, + K: keychain::Keychain + 'static, +{ + controller::owner_single_use(None, keychain_mask, Some(owner_api), |api, _m| { + let proof = serde_json::from_str::(proof).map_err(|e| { + Error::ArgumentError(format!("Unable to decode proof from json, {}", e)) + })?; + + let validation = api.validate_ownership_proof(proof)?; + println!("Network: {}", validation.network); + println!("Message: {}", validation.message); + println!( + "Viewing Key: {}", + validation.viewing_key.unwrap_or("Not provided".to_string()) + ); + println!( + "Tor Address: {}", + validation.tor_address.unwrap_or("Not provided".to_string()) + ); + println!( + "MWCMQS Address: {}", + validation.mqs_address.unwrap_or("Not provided".to_string()) + ); + Ok(()) + })?; + Ok(()) +} + /// Arguments for rewind hash view wallet scan command pub struct ViewWalletScanArgs { pub rewind_hash: String, diff --git a/controller/tests/ownership_proofs.rs b/controller/tests/ownership_proofs.rs new file mode 100644 index 00000000..b5faeb52 --- /dev/null +++ b/controller/tests/ownership_proofs.rs @@ -0,0 +1,237 @@ +// Copyright 2024 The Grin Developers +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Test a wallet sending to self +#[macro_use] +extern crate log; +extern crate grin_wallet_controller as wallet; +extern crate grin_wallet_impls as impls; + +use grin_wallet_util::grin_core::global; + +use impls::test_framework::{self, LocalWalletClient}; +use std::sync::atomic::Ordering; +use std::thread; +use std::time::Duration; + +#[macro_use] +mod common; +use common::{clean_output_dir, create_wallet_proxy, setup}; +use grin_wallet_libwallet::PubKeySignature; +use grin_wallet_util::grin_util::ZeroingString; + +/// self send impl +fn ownership_proof_impl(test_dir: &'static str) -> Result<(), wallet::Error> { + // Create a new proxy to simulate server and wallet responses + global::set_local_chain_type(global::ChainTypes::AutomatedTesting); + let mut wallet_proxy = create_wallet_proxy(test_dir); + let chain = wallet_proxy.chain.clone(); + let stopper = wallet_proxy.running.clone(); + + // Create a new wallet test client, and set its queues to communicate with the + // proxy + create_wallet_and_add!( + client1, + wallet1, + mask1_i, + test_dir, + "wallet1", + Some(ZeroingString::from( + "room plastic there over junior comfort drip envelope hope divide cake trophy" + )), + &mut wallet_proxy, + true + ); + let mask1 = (&mask1_i).as_ref(); + + // Set the wallet proxy listener running + thread::spawn(move || { + global::set_local_chain_type(global::ChainTypes::AutomatedTesting); + if let Err(e) = wallet_proxy.run() { + error!("Wallet Proxy error: {}", e); + } + }); + + let _ = + test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, 10 as usize, false); + + wallet::controller::owner_single_use(Some(wallet1.clone()), mask1, None, |api, m| { + let (wallet1_refreshed, wallet1_info) = api.retrieve_summary_info(m, true, 1)?; + assert!(wallet1_refreshed); + assert!(wallet1_info.last_confirmed_height > 0); + assert!(wallet1_info.total > 0); + + let proof = + api.retrieve_ownership_proof(m, "my message to sign".to_string(), true, true, true)?; + + assert_eq!(proof.message, "my message to sign"); + assert_eq!(proof.network, "floonet"); + assert!(proof.wallet_root.is_some()); + assert!(proof.tor_address.is_some()); + assert!(proof.mqs_address.is_some()); + + assert_eq!(format!("{:?}", proof), "OwnershipProof { network: \"floonet\", message: \"my message to sign\", wallet_root: Some(PubKeySignature { public_key: \"022e4a08245fc03ca5da9c717c1b29c589413fac96150a400500eff613d05dd34d\", signature: \"3045022100e12d078b67446cc83ab46918b5a641a61b4a02bcdfac03b8978865ca6740def302202f463ec8dea18921942e20452d15ddd2fbcf590aa36b0c414d45078a83d38b92\" }), tor_address: Some(PubKeySignature { public_key: \"fa30d0726b505d6304d93a4ed6c4a428d467b1da13a7826cfdd4131046ca27a4\", signature: \"1cb237ca781f0868752dcc0e503eb70904fd208c7b64c3d23ed6830c808663cae723ac909709f1c16495b2162ec9028a225f7074863172246930eaaee3853706\" }), mqs_address: Some(PubKeySignature { public_key: \"0214f727d0503231f7dd4797509b3e7cde3f7cfdf8c32a3b562c8bd3f650bb2509\", signature: \"30440220035e56caa572ade99ebbffdc2d166c943fe433418269cb156d21f4a0e02557520220628e9e530e662ca1632774106f37a1404873f6bc482bc603a8cfee6c3e92f2f6\" }) }"); + + let validate_res = api.validate_ownership_proof(proof.clone()); + assert!(validate_res.is_ok()); + let validate_res = validate_res.unwrap(); + + assert_eq!(proof.message, validate_res.message); + assert_eq!(proof.network, validate_res.network); + assert_eq!(format!("{:?}", validate_res), "OwnershipProofValidation { network: \"floonet\", message: \"my message to sign\", viewing_key: Some(\"60a98a5d7d1823743b9c3993a31bec49fc7114d3cdbe6bf9e81f53a7f7e02727\"), tor_address: Some(\"7iyna4tlkbowgbgzhjhnnrfefdkgpmo2cotye3h52qjrarwke6saswid\"), mqs_address: Some(\"xmfmGjJU6hLUtndfwDSQmxtYckgDQEquMwXxxCW8D2zUN1uvdrkN\") }"); + + // Now let's try to adjust something and validate that it will fail + let mut invalid_proof = proof.clone(); + invalid_proof.network = "mainnet".to_string(); + let validate_res = api.validate_ownership_proof(invalid_proof); + assert!(validate_res.is_err()); + + let mut invalid_proof = proof.clone(); + invalid_proof.message = "another message".to_string(); + let validate_res = api.validate_ownership_proof(invalid_proof); + assert!(validate_res.is_err()); + + let mut invalid_proof = proof.clone(); + invalid_proof.tor_address = None; + let validate_res = api.validate_ownership_proof(invalid_proof); + assert!(validate_res.is_err()); + + let mut invalid_proof = proof.clone(); + invalid_proof.wallet_root = None; + let validate_res = api.validate_ownership_proof(invalid_proof); + assert!(validate_res.is_err()); + + let mut invalid_proof = proof.clone(); + invalid_proof.mqs_address = None; + let validate_res = api.validate_ownership_proof(invalid_proof); + assert!(validate_res.is_err()); + + let mut invalid_proof = proof.clone(); + invalid_proof.wallet_root = Some(PubKeySignature{ + public_key: "022e4a08245fc03ca5da9c717c1b29c589413fac96150a400500eff613d15dd34d".to_string(), // PK is changed + signature: "3045022100e12d078b67446cc83ab46918b5a641a61b4a02bcdfac03b8978865ca6740def302202f463ec8dea18921942e20452d15ddd2fbcf590aa36b0c414d45078a83d38b92".to_string(), + }); + let validate_res = api.validate_ownership_proof(invalid_proof); + assert!(validate_res.is_err()); + + let mut invalid_proof = proof.clone(); + invalid_proof.wallet_root = Some(PubKeySignature{ + public_key: "022e4a08245fc03ca5da9c717c1b29c589413fac96150a400500eff613d05dd34d".to_string(), + signature: "3045022100e12d078b67446cc83ab46918b5a641a61b4a02bcdfac03b8978865ca6740def302202f453ec8dea18921942e20452d15ddd2fbcf590aa36b0c414d45078a83d38b92".to_string(), // signature is changed + }); + let validate_res = api.validate_ownership_proof(invalid_proof); + assert!(validate_res.is_err()); + + // Now let try not full proofs + let proof = + api.retrieve_ownership_proof(m, "my message to sign".to_string(), true, false, false)?; + + assert_eq!(proof.message, "my message to sign"); + assert_eq!(proof.network, "floonet"); + assert!(proof.wallet_root.is_some()); + assert!(proof.tor_address.is_none()); + assert!(proof.mqs_address.is_none()); + + let validate_res = api.validate_ownership_proof(proof).unwrap(); + assert_eq!("my message to sign", validate_res.message); + assert_eq!("floonet", validate_res.network); + assert!(validate_res.viewing_key.is_some()); + assert!(validate_res.tor_address.is_none()); + assert!(validate_res.mqs_address.is_none()); + + // Now let try not full proofs + let proof = + api.retrieve_ownership_proof(m, "my message to sign".to_string(), false, true, false)?; + + assert_eq!(proof.message, "my message to sign"); + assert_eq!(proof.network, "floonet"); + assert!(proof.wallet_root.is_none()); + assert!(proof.tor_address.is_some()); + assert!(proof.mqs_address.is_none()); + + let validate_res = api.validate_ownership_proof(proof).unwrap(); + assert_eq!("my message to sign", validate_res.message); + assert_eq!("floonet", validate_res.network); + assert!(validate_res.viewing_key.is_none()); + assert!(validate_res.tor_address.is_some()); + assert!(validate_res.mqs_address.is_none()); + + // Now let try not full proofs + let proof = + api.retrieve_ownership_proof(m, "my message to sign".to_string(), false, false, true)?; + + assert_eq!(proof.message, "my message to sign"); + assert_eq!(proof.network, "floonet"); + assert!(proof.wallet_root.is_none()); + assert!(proof.tor_address.is_none()); + assert!(proof.mqs_address.is_some()); + + let validate_res = api.validate_ownership_proof(proof).unwrap(); + assert_eq!("my message to sign", validate_res.message); + assert_eq!("floonet", validate_res.network); + assert!(validate_res.viewing_key.is_none()); + assert!(validate_res.tor_address.is_none()); + assert!(validate_res.mqs_address.is_some()); + + // Now let try not full proofs + let proof = + api.retrieve_ownership_proof(m, "my message to sign".to_string(), true, false, true)?; + + assert_eq!(proof.message, "my message to sign"); + assert_eq!(proof.network, "floonet"); + assert!(proof.wallet_root.is_some()); + assert!(proof.tor_address.is_none()); + assert!(proof.mqs_address.is_some()); + + let validate_res = api.validate_ownership_proof(proof).unwrap(); + assert_eq!("my message to sign", validate_res.message); + assert_eq!("floonet", validate_res.network); + assert!(validate_res.viewing_key.is_some()); + assert!(validate_res.tor_address.is_none()); + assert!(validate_res.mqs_address.is_some()); + + // Now let try not full proofs + let proof = + api.retrieve_ownership_proof(m, "my message to sign".to_string(), true, true, false)?; + + assert_eq!(proof.message, "my message to sign"); + assert_eq!(proof.network, "floonet"); + assert!(proof.wallet_root.is_some()); + assert!(proof.tor_address.is_some()); + assert!(proof.mqs_address.is_none()); + + let validate_res = api.validate_ownership_proof(proof).unwrap(); + assert_eq!("my message to sign", validate_res.message); + assert_eq!("floonet", validate_res.network); + assert!(validate_res.viewing_key.is_some()); + assert!(validate_res.tor_address.is_some()); + assert!(validate_res.mqs_address.is_none()); + + Ok(()) + })?; + + // let logging finish + stopper.store(false, Ordering::Relaxed); + thread::sleep(Duration::from_millis(1000)); + Ok(()) +} + +#[test] +fn wallet_ownership_proof() { + let test_dir = "test_output/ownership_proof"; + setup(test_dir); + if let Err(e) = ownership_proof_impl(test_dir) { + panic!("ownership_proof_impl Error: {}", e); + } + clean_output_dir(test_dir); +} diff --git a/libwallet/src/api_impl/owner.rs b/libwallet/src/api_impl/owner.rs index 11c97c60..e0ae4f5a 100644 --- a/libwallet/src/api_impl/owner.rs +++ b/libwallet/src/api_impl/owner.rs @@ -22,11 +22,14 @@ use crate::grin_core::libtx::proof; use crate::grin_keychain::ViewKey; use crate::grin_util::secp::key::SecretKey; use crate::grin_util::Mutex; -use crate::grin_util::ToHex; +use crate::proof::crypto::Hex; use crate::api_impl::owner_updater::StatusMessage; use crate::grin_keychain::{BlindingFactor, Identifier, Keychain, SwitchCommitmentType}; use crate::grin_util::secp::key::PublicKey; +use crate::grin_util::secp::Message; +use crate::grin_util::secp::Secp256k1; +use crate::grin_util::secp::Signature; use crate::internal::{keys, scan, selection, tx, updater}; use crate::slate::{PaymentInfo, Slate}; @@ -37,12 +40,20 @@ use crate::types::{ use crate::Error; use crate::{ wallet_lock, BuiltOutput, InitTxArgs, IssueInvoiceTxArgs, NodeHeightResult, - OutputCommitMapping, PaymentProof, RetrieveTxQueryArgs, ScannedBlockInfo, TxLogEntryType, - ViewWallet, WalletInst, WalletLCProvider, + OutputCommitMapping, OwnershipProof, OwnershipProofValidation, PaymentProof, PubKeySignature, + RetrieveTxQueryArgs, ScannedBlockInfo, TxLogEntryType, ViewWallet, WalletInst, + WalletLCProvider, }; use crate::proof::tx_proof::{pop_proof_for_slate, TxProof}; +use digest::Digest; +use ed25519_dalek::Keypair as DalekKeypair; use ed25519_dalek::PublicKey as DalekPublicKey; +use ed25519_dalek::SecretKey as DalekSecretKey; +use ed25519_dalek::Signature as DalekSignature; +use ed25519_dalek::Signer; +use sha2::Sha256; +use signature::Verifier; use std::cmp; use std::fs::File; use std::io::Write; @@ -52,7 +63,10 @@ use std::sync::Arc; const USER_MESSAGE_MAX_LEN: usize = 1000; // We can keep messages as long as we need unless the slate will be too large to operate. 1000 symbols should be enough to keep everybody happy use crate::proof::crypto; use crate::proof::proofaddress; +use crate::proof::proofaddress::ProvableAddress; use grin_wallet_util::grin_core::core::Committed; +use grin_wallet_util::grin_core::global; +use grin_wallet_util::grin_util::from_hex; /// List of accounts pub fn accounts<'a, T: ?Sized, C, K>(w: &mut T) -> Result, Error> @@ -98,6 +112,8 @@ where C: NodeClient + 'a, K: Keychain + 'a, { + use grin_wallet_util::grin_util::ToHex; + wallet_lock!(wallet_inst, w); let keychain = w.keychain(keychain_mask)?; let root_public_key = keychain.public_root_key(); @@ -1542,6 +1558,263 @@ where Ok((sender_mine, recipient_mine)) } +/// Generate signatures for root public keym tor address PK and MQS PK. +pub fn generate_ownership_proof<'a, L, C, K>( + wallet_inst: Arc>>>, + keychain_mask: Option<&SecretKey>, + message: String, + include_public_root_key: bool, + include_tor_address: bool, + include_mqs_address: bool, +) -> Result +where + L: WalletLCProvider<'a, C, K>, + C: NodeClient + 'a, + K: Keychain + 'a, +{ + if message.is_empty() { + return Err(Error::GenericError( + "Not defines message to sign".to_string(), + )); + } + + if !include_public_root_key && !include_tor_address && !include_mqs_address { + return Err(Error::GenericError( + "No keys are selected to include into the ownership proof".to_string(), + )); + } + + let network = if global::is_mainnet() { + "mainnet" + } else { + "floonet" + }; + let mut message2sign = String::new(); + message2sign.push_str(network); + message2sign.push('|'); + message2sign.push_str(message.as_str()); + + wallet_lock!(wallet_inst, w); + let keychain = w.keychain(keychain_mask)?; + let secp = keychain.secp(); + + if include_public_root_key { + let root_public_key = keychain.public_root_key(); + let root_public_key = root_public_key.to_hex(); + message2sign.push('|'); + message2sign.push_str(root_public_key.as_str()); + } + + if include_tor_address { + let secret = proofaddress::payment_proof_address_secret(&keychain, None)?; + let tor_pk = proofaddress::secret_2_tor_pub(&secret)?; + let tor_pk = tor_pk.to_hex(); + message2sign.push('|'); + message2sign.push_str(tor_pk.as_str()); + } + + if include_mqs_address { + let mqs_pub_key: PublicKey = proofaddress::payment_proof_address_pubkey(&keychain)?; + let mqs_pub_key = mqs_pub_key.to_hex(); + message2sign.push('|'); + message2sign.push_str(mqs_pub_key.as_str()); + } + + // message to sign is ready. Now we can go forward and generate signatures for all public keys + let mut hasher = Sha256::new(); + hasher.update(message2sign.as_bytes()); + let message_hash = hasher.finalize(); + + // generating the signatures for message + let wallet_root = if include_public_root_key { + let secret = keychain.private_root_key(); + let signature = secp + .sign( + &Message::from_slice(message_hash.as_slice()).map_err(|e| { + Error::GenericError(format!("Unable to build a message, {}", e)) + })?, + &secret, + ) + .map_err(|e| Error::from(e))?; + Some(PubKeySignature { + public_key: keychain.public_root_key().to_hex(), + signature: signature.to_hex(), + }) + } else { + None + }; + + let tor_address = if include_tor_address { + let secret = proofaddress::payment_proof_address_secret(&keychain, None)?; + let secret = DalekSecretKey::from_bytes(&secret.0) + .map_err(|e| Error::GenericError(format!("Unable build dalek public key, {}", e)))?; + let public = DalekPublicKey::from(&secret); + let keypair = DalekKeypair { secret, public }; + let signature = keypair + .try_sign(message_hash.as_slice()) + .map_err(|e| Error::GenericError(format!("Unable build dalek signature, {}", e)))?; + Some(PubKeySignature { + public_key: public.to_hex(), + signature: signature.to_hex(), + }) + } else { + None + }; + + let mqs_address = if include_mqs_address { + let secret = proofaddress::payment_proof_address_secret(&keychain, None)?; + let signature = secp + .sign( + &Message::from_slice(message_hash.as_slice()).map_err(|e| { + Error::GenericError(format!("Unable to build a message, {}", e)) + })?, + &secret, + ) + .map_err(|e| Error::from(e))?; + let mqs_pub_key = PublicKey::from_secret_key(&secp, &secret)?; + Some(PubKeySignature { + public_key: mqs_pub_key.to_hex(), + signature: signature.to_hex(), + }) + } else { + None + }; + + Ok(OwnershipProof { + network: network.to_string(), + message, + wallet_root, + tor_address, + mqs_address, + }) +} + +/// Generate signatures for root public keym tor address PK and MQS PK. +pub fn validate_ownership_proof(proof: OwnershipProof) -> Result +where +{ + if proof.message.is_empty() { + return Err(Error::InvalidOwnershipProof( + "message value is empty".to_string(), + )); + } + + let mut result = OwnershipProofValidation::empty(proof.message.clone()); + + let network = if global::is_mainnet() { + "mainnet" + } else { + "floonet" + }; + + if proof.network != network { + return Err(Error::InvalidOwnershipProof(format!( + "This proof is generated for wrong network: {}", + proof.network + ))); + } + + result.network = network.to_string(); + + let mut message2sign = String::new(); + message2sign.push_str(network); + message2sign.push('|'); + message2sign.push_str(proof.message.as_str()); + + let secp = Secp256k1::new(); + + if let Some(wallet_root) = &proof.wallet_root { + message2sign.push('|'); + message2sign.push_str(wallet_root.public_key.as_str()); + } + if let Some(tor_address) = &proof.tor_address { + message2sign.push('|'); + message2sign.push_str(tor_address.public_key.as_str()); + } + if let Some(mqs_address) = &proof.mqs_address { + message2sign.push('|'); + message2sign.push_str(mqs_address.public_key.as_str()); + } + + // message to sign is ready. Now we can go forward and generate signatures for all public keys + let mut hasher = Sha256::new(); + hasher.update(message2sign.as_bytes()); + let message_hash = hasher.finalize(); + + if let Some(wallet_root) = &proof.wallet_root { + let public_key = PublicKey::from_hex(&wallet_root.public_key).map_err(|e| { + Error::InvalidOwnershipProof(format!("Unable to decode wallet root public key, {}", e)) + })?; + let signature = Signature::from_hex(&wallet_root.signature).map_err(|e| { + Error::InvalidOwnershipProof(format!("Unable to decode wallet root signature, {}", e)) + })?; + secp.verify( + &Message::from_slice(message_hash.as_slice()) + .map_err(|e| Error::GenericError(format!("Unable to build a message, {}", e)))?, + &signature, + &public_key, + ) + .map_err(|e| { + Error::InvalidOwnershipProof(format!("wallet root signature is invalid, {}", e)) + })?; + + use grin_wallet_util::grin_util::ToHex; + // we are good so far, reporting viewing key + result.viewing_key = Some(ViewKey::rewind_hash(&secp, public_key).to_hex()); + } + + if let Some(mqs_address) = &proof.mqs_address { + let public_key = PublicKey::from_hex(&mqs_address.public_key).map_err(|e| { + Error::InvalidOwnershipProof(format!("Unable to decode mqs address public key, {}", e)) + })?; + let signature = Signature::from_hex(&mqs_address.signature).map_err(|e| { + Error::InvalidOwnershipProof(format!("Unable to decode mqs address signature, {}", e)) + })?; + secp.verify( + &Message::from_slice(message_hash.as_slice()) + .map_err(|e| Error::GenericError(format!("Unable to build a message, {}", e)))?, + &signature, + &public_key, + ) + .map_err(|e| { + Error::InvalidOwnershipProof(format!("mqs address signature is invalid, {}", e)) + })?; + + // we are good so far, reporting mwqs address + let mqs_address = ProvableAddress::from_pub_key(&public_key); + result.mqs_address = Some(mqs_address.public_key); + } + + if let Some(tor_address) = &proof.tor_address { + let public_key = from_hex(&tor_address.public_key).map_err(|e| { + Error::InvalidOwnershipProof(format!("Unable to decode tor address public key, {}", e)) + })?; + + let public_key = DalekPublicKey::from_bytes(&public_key).map_err(|e| { + Error::InvalidOwnershipProof(format!("Unable to decode tor address public key, {}", e)) + })?; + + let signature = from_hex(&tor_address.signature).map_err(|e| { + Error::InvalidOwnershipProof(format!("Unable to decode tor address signature, {}", e)) + })?; + let signature = DalekSignature::from_bytes(&signature).map_err(|e| { + Error::InvalidOwnershipProof(format!("Unable to decode tor address signature, {}", e)) + })?; + + public_key + .verify(message_hash.as_slice(), &signature) + .map_err(|e| { + Error::InvalidOwnershipProof(format!("tor address signature is invalid, {}", e)) + })?; + + // we are good so far, reporting tor address + let tor_address = ProvableAddress::from_tor_pub_key(&public_key); + result.tor_address = Some(tor_address.public_key); + } + + return Ok(result); +} + /// pub fn self_spend_particular_output<'a, L, C, K>( wallet_inst: Arc>>>, diff --git a/libwallet/src/api_impl/types.rs b/libwallet/src/api_impl/types.rs index 06440fc2..08be9891 100644 --- a/libwallet/src/api_impl/types.rs +++ b/libwallet/src/api_impl/types.rs @@ -469,6 +469,60 @@ pub struct PaymentProof { pub sender_sig: String, } +/// Ownership proof for addresses & root public keys +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct PubKeySignature { + /// Public key + pub public_key: String, + /// Signature + pub signature: String, +} + +/// Ownership proof for addresses & root public keys +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct OwnershipProof { + /// Name of the network + pub network: String, + /// Message to sign + pub message: String, + + /// Proof for the root public key (viewing key) + pub wallet_root: Option, + /// Proof for the tor address + pub tor_address: Option, + /// Proof for MQS address + pub mqs_address: Option, +} + +/// Ownership validation results +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct OwnershipProofValidation { + /// Network name + pub network: String, + /// Message that was signed + pub message: String, + + /// Viewing key + pub viewing_key: Option, + /// Tor address + pub tor_address: Option, + /// MQS address + pub mqs_address: Option, +} + +impl OwnershipProofValidation { + /// Build empty instance + pub fn empty(message: String) -> Self { + OwnershipProofValidation { + network: String::new(), + message, + viewing_key: None, + tor_address: None, + mqs_address: None, + } + } +} + /// Init swap operation #[derive(Serialize, Deserialize, Debug, Clone)] pub struct SwapStartArgs { diff --git a/libwallet/src/error.rs b/libwallet/src/error.rs index f41a5173..58952745 100644 --- a/libwallet/src/error.rs +++ b/libwallet/src/error.rs @@ -357,6 +357,10 @@ pub enum Error { /// Nonce creation error #[error("Nonce error: {0}")] Nonce(String), + + /// Invalid ownership proof + #[error("Invalid ownership proof: {0}")] + InvalidOwnershipProof(String), } impl From for Error { diff --git a/libwallet/src/lib.rs b/libwallet/src/lib.rs index 13031b2c..c15bc63d 100644 --- a/libwallet/src/lib.rs +++ b/libwallet/src/lib.rs @@ -83,9 +83,9 @@ pub use api_impl::owner_swap; pub use api_impl::owner_updater::StatusMessage; pub use api_impl::types::{ Amount, BlockFees, BuiltOutput, InitTxArgs, InitTxSendArgs, IssueInvoiceTxArgs, - NodeHeightResult, OutputCommitMapping, PaymentProof, ReplayMitigationConfig, - RetrieveTxQueryArgs, RetrieveTxQuerySortField, RetrieveTxQuerySortOrder, SendTXArgs, - SwapStartArgs, VersionInfo, + NodeHeightResult, OutputCommitMapping, OwnershipProof, OwnershipProofValidation, PaymentProof, + PubKeySignature, ReplayMitigationConfig, RetrieveTxQueryArgs, RetrieveTxQuerySortField, + RetrieveTxQuerySortOrder, SendTXArgs, SwapStartArgs, VersionInfo, }; pub use internal::scan::{scan, set_replay_config}; pub use proof::tx_proof::TxProof; diff --git a/libwallet/src/proof/crypto.rs b/libwallet/src/proof/crypto.rs index e12e35c5..35d7bccb 100644 --- a/libwallet/src/proof/crypto.rs +++ b/libwallet/src/proof/crypto.rs @@ -12,6 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +use ed25519_dalek::PublicKey as DalekPublicKey; +use ed25519_dalek::Signature as DalekSignature; use grin_wallet_util::grin_util::secp::key::{PublicKey, SecretKey}; use grin_wallet_util::grin_util::secp::pedersen::Commitment; use grin_wallet_util::grin_util::secp::{ContextFlag, Message, Secp256k1, Signature}; @@ -115,6 +117,38 @@ impl Hex for Signature { } } +impl Hex for DalekPublicKey { + fn from_hex(str: &str) -> Result { + let hex = util::from_hex(str).map_err(|e| { + Error::HexError(format!("Unable convert Public Key HEX {}, {}", str, e)) + })?; + DalekPublicKey::from_bytes(&hex).map_err(|e| { + Error::HexError(format!( + "Unable to build public key from HEX {}, {}", + str, e + )) + }) + } + + fn to_hex(&self) -> String { + util::to_hex(self.as_bytes()) + } +} + +impl Hex for DalekSignature { + fn from_hex(str: &str) -> Result { + let hex = util::from_hex(str) + .map_err(|e| Error::HexError(format!("Unable convert Signature HEX {}, {}", str, e)))?; + DalekSignature::from_bytes(&hex).map_err(|e| { + Error::HexError(format!("Unable to build Signature from HEX {}, {}", str, e)) + }) + } + + fn to_hex(&self) -> String { + util::to_hex(&self.clone().to_bytes()) + } +} + impl Hex for SecretKey { fn from_hex(str: &str) -> Result { let data = util::from_hex(str) diff --git a/libwallet/src/slate.rs b/libwallet/src/slate.rs index 4f003ce2..0b64de4f 100644 --- a/libwallet/src/slate.rs +++ b/libwallet/src/slate.rs @@ -33,7 +33,6 @@ use crate::grin_util::secp::pedersen::Commitment; use crate::grin_util::secp::Signature; use crate::grin_util::ToHex; use crate::Context; -use bitcoin_lib::secp256k1::ContextFlag; use serde::ser::{Serialize, Serializer}; use serde_json; use std::convert::{TryFrom, TryInto}; @@ -57,6 +56,7 @@ use crate::types::CbData; use crate::{SlateVersion, Slatepacker, CURRENT_SLATE_VERSION}; use ed25519_dalek::SecretKey as DalekSecretKey; use grin_wallet_util::grin_core::core::FeeFields; +use grin_wallet_util::grin_util::secp::ContextFlag; use grin_wallet_util::grin_util::secp::Secp256k1; use rand::rngs::mock::StepRng; use rand::thread_rng; diff --git a/src/bin/mwc-wallet.yml b/src/bin/mwc-wallet.yml index 231eb7f2..0f4e9695 100644 --- a/src/bin/mwc-wallet.yml +++ b/src/bin/mwc-wallet.yml @@ -1021,3 +1021,31 @@ subcommands: takes_value: true - check_tor_connection: about: check this wallet tor connection (for CLI mode) + - generate_ownership_proof: + about: Gerenerate ownershup proof for the root public key, tor address and mqs addresses. + args: + - message: + help: Message to sign + short: s + long: message + takes_value: true + - include_public_root_key: + help: Include root public key and signature. Note, root public key can be user to generate rewind_hash to view the all outputs for your wallet. + short: p + long: include_public_root_key + - include_tor_address: + help: Include tor address and singature. + short: t + long: include_tor_address + - include_mqs_address: + help: Include MWCMQS address and singature. + short: m + long: include_mqs_address + - validate_ownership_proof: + about: Validate ownership proof record + args: + - proof: + help: Proof record + short: p + long: proof + takes_value: true \ No newline at end of file diff --git a/src/cmd/wallet_args.rs b/src/cmd/wallet_args.rs index 9d7a6258..aa6ccc3d 100644 --- a/src/cmd/wallet_args.rs +++ b/src/cmd/wallet_args.rs @@ -1447,6 +1447,17 @@ pub fn parse_eth_args(args: &ArgMatches) -> Result }) } +pub fn parse_retrieve_ownership_proof( + args: &ArgMatches, +) -> Result { + Ok(command::GenerateOwnershipProofArgs { + message: parse_required(args, "message")?.to_string(), + include_public_root_key: args.is_present("include_public_root_key"), + include_tor_address: args.is_present("include_tor_address"), + include_mqs_address: args.is_present("include_mqs_address"), + }) +} + pub fn wallet_command( wallet_args: &ArgMatches, mut wallet_config: WalletConfig, @@ -1909,6 +1920,14 @@ where let a = arg_parse!(parse_eth_args(&args)); command::eth(owner_api.wallet_inst.clone(), a) } + ("generate_ownership_proof", Some(args)) => { + let a = arg_parse!(parse_retrieve_ownership_proof(&args)); + command::generate_ownership_proof(owner_api, km, a) + } + ("validate_ownership_proof", Some(args)) => { + let proof = arg_parse!(parse_required(args, "proof")); + command::validate_ownership_proof(owner_api, km, proof) + } (cmd, _) => { return Err(Error::ArgumentError(format!( "Unknown wallet command '{}', use 'mwc help wallet' for details", From 30d7a5887b3e07103d5e340560aed8e751897daa Mon Sep 17 00:00:00 2001 From: bayk Date: Mon, 30 Sep 2024 20:59:02 -0700 Subject: [PATCH 3/5] Add extra dirs to search for bridge clients --- impls/src/tor/bridge.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/impls/src/tor/bridge.rs b/impls/src/tor/bridge.rs index 834e0b9a..84f1c1b1 100644 --- a/impls/src/tor/bridge.rs +++ b/impls/src/tor/bridge.rs @@ -273,8 +273,15 @@ impl PluginClient { /// Try to find the plugin client path pub fn get_client_path(plugin: &str) -> Result { + use std::path::PathBuf; + let plugin_path = env::var_os("PATH").and_then(|path| { - env::split_paths(&path) + let mut paths: Vec = env::split_paths(&path).collect(); + paths.push(PathBuf::from("/Library/Apple/usr/bin")); + paths.push(PathBuf::from("/usr/local/bin")); + + paths + .iter() .filter_map(|dir| { let full_path = dir.join(plugin); if full_path.is_file() { From 3b1dae92ac4bd3ee5467bdc268f857b7b9a4e897 Mon Sep 17 00:00:00 2001 From: bayk Date: Tue, 1 Oct 2024 18:16:30 -0700 Subject: [PATCH 4/5] Bump version, cargo update --- Cargo.lock | 324 +++++++++++++++++++++--------------------- Cargo.toml | 14 +- api/Cargo.toml | 10 +- config/Cargo.toml | 4 +- controller/Cargo.toml | 12 +- impls/Cargo.toml | 8 +- libwallet/Cargo.toml | 6 +- util/Cargo.toml | 30 ++-- 8 files changed, 201 insertions(+), 207 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index ba49fee5..298a3250 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4,19 +4,13 @@ version = 3 [[package]] name = "addr2line" -version = "0.22.0" +version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678" +checksum = "f5fb1d8e4442bd405fdfd1dacb42792696b0cf9cb15882e5d097b742a676d375" dependencies = [ "gimli", ] -[[package]] -name = "adler" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" - [[package]] name = "adler2" version = "2.0.0" @@ -111,9 +105,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.86" +version = "1.0.89" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da" +checksum = "86fdf8605db99b54d3cd748a44c6d04df638eb5dafb219b135d0149bd0db01f6" [[package]] name = "arc-swap" @@ -123,9 +117,9 @@ checksum = "dabe5a181f83789739c194cbe5a897dde195078fac08568d09221fd6137a7ba8" [[package]] name = "arrayref" -version = "0.3.8" +version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9d151e35f61089500b617991b791fc8bfd237ae50cd5950803758a179b41e67a" +checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb" [[package]] name = "arrayvec" @@ -192,9 +186,9 @@ dependencies = [ [[package]] name = "async-executor" -version = "1.13.0" +version = "1.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d7ebdfa2ebdab6b1760375fa7d6f382b9f486eac35fc994625a00e89280bdbb7" +checksum = "30ca9a001c1e8ba5149f91a74362376cc6bc5b919d92d988668657bd570bdcec" dependencies = [ "async-task", "concurrent-queue", @@ -225,7 +219,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fc5b45d93ef0529756f812ca52e44c221b35341892d3dcc34132ac02f3dd2af" dependencies = [ "async-lock 2.8.0", - "autocfg 1.3.0", + "autocfg 1.4.0", "cfg-if 1.0.0", "concurrent-queue", "futures-lite 1.13.0", @@ -251,7 +245,7 @@ dependencies = [ "futures-lite 2.3.0", "parking", "polling 3.7.3", - "rustix 0.38.35", + "rustix 0.38.37", "slab", "tracing", "windows-sys 0.59.0", @@ -291,19 +285,19 @@ dependencies = [ [[package]] name = "async-std" -version = "1.12.0" +version = "1.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62565bb4402e926b29953c785397c6dc0391b7b446e45008b0049eb43cec6f5d" +checksum = "c634475f29802fde2b8f0b505b1bd00dfe4df7d4a000f0b36f7671197d5c3615" dependencies = [ "async-channel 1.9.0", "async-global-executor", - "async-io 1.13.0", - "async-lock 2.8.0", + "async-io 2.3.4", + "async-lock 3.4.0", "crossbeam-utils 0.8.20", "futures-channel", "futures-core", "futures-io", - "futures-lite 1.13.0", + "futures-lite 2.3.0", "gloo-timers", "kv-log-macro", "log", @@ -348,7 +342,7 @@ version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4057f2c32adbb2fc158e22fb38433c8e9bbf76b75a4732c7c0cbaf695fb65568" dependencies = [ - "bytes 1.7.1", + "bytes 1.7.2", "futures-sink", "futures-util", "memchr", @@ -384,28 +378,28 @@ version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0dde43e75fd43e8a1bf86103336bc699aa8d17ad1be60c76c0bdfd4828e19b78" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", ] [[package]] name = "autocfg" -version = "1.3.0" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0" +checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" [[package]] name = "backtrace" -version = "0.3.73" +version = "0.3.74" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a" +checksum = "8d82cb332cdfaed17ae235a638438ac4d4839913cc2af585c3c6746e8f8bee1a" dependencies = [ "addr2line", - "cc", "cfg-if 1.0.0", "libc", - "miniz_oxide 0.7.4", + "miniz_oxide", "object", "rustc-demangle", + "windows-targets 0.52.6", ] [[package]] @@ -490,7 +484,7 @@ version = "0.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "51d712318a27c7150326677b321a5fa91b55f6d9034ffd67f20319e147d40cee" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", "libm", "num-bigint 0.4.6", "num-integer", @@ -789,9 +783,9 @@ checksum = "0e4cec68f03f32e44924783795810fa50a7035d8c8ebe78580ad7e6c703fba38" [[package]] name = "bytes" -version = "1.7.1" +version = "1.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50" +checksum = "428d9aa8fbc0670b7b8d6030a7fadd0f86151cae55e4dbbece15f3780a3dfaf3" [[package]] name = "cargo-lock" @@ -816,9 +810,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.1.15" +version = "1.1.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57b6a275aa2903740dc87da01c62040406b8812552e97129a63ea8850a17c6e6" +checksum = "812acba72f0a070b003d3697490d2b55b837230ae7c6c6497f05cc2ddbb8d938" dependencies = [ "jobserver", "libc", @@ -1016,9 +1010,9 @@ checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" [[package]] name = "cpufeatures" -version = "0.2.13" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "51e852e6dc9a5bed1fae92dd2375037bf2b768725bf3be87811edee3249d09ad" +checksum = "608697df725056feaccfa42cffdaeeec3fccc4ffc38358ecd19b243e716a78e0" dependencies = [ "libc", ] @@ -1091,7 +1085,7 @@ version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", "cfg-if 0.1.10", "lazy_static", ] @@ -1275,7 +1269,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3" dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", - "syn 2.0.76", + "syn 2.0.79", ] [[package]] @@ -1294,7 +1288,7 @@ dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", "rustc_version", - "syn 2.0.76", + "syn 2.0.79", ] [[package]] @@ -1722,12 +1716,12 @@ checksum = "37ab347416e802de484e4d03c7316c48f1ecb56574dfd4a46a80f173ce1de04d" [[package]] name = "flate2" -version = "1.0.33" +version = "1.0.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "324a1be68054ef05ad64b861cc9eaf1d623d2d8cb25b4bf2cb9cdd902b4bf253" +checksum = "a1b589b4dc103969ad3cf85c950899926ec64300a1a46d76c03a6072957036f0" dependencies = [ "crc32fast", - "miniz_oxide 0.8.0", + "miniz_oxide", ] [[package]] @@ -1893,7 +1887,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", - "syn 2.0.76", + "syn 2.0.79", ] [[package]] @@ -2000,9 +1994,9 @@ dependencies = [ [[package]] name = "gimli" -version = "0.29.0" +version = "0.31.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd" +checksum = "32085ea23f3234fc7846555e85283ba4de91e21016dc0455a16286d87a292d64" [[package]] name = "git2" @@ -2019,9 +2013,9 @@ dependencies = [ [[package]] name = "gloo-timers" -version = "0.2.6" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b995a66bb87bebce9a0f4a95aed01daca4872c050bfcb21653361c03bc35e5c" +checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994" dependencies = [ "futures-channel", "futures-core", @@ -2032,7 +2026,7 @@ dependencies = [ [[package]] name = "grin_api" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2#0a96a3c69e7364246ed05d7ac89c8e51e9e2ebce" +source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" dependencies = [ "bytes 0.5.6", "chrono", @@ -2066,7 +2060,7 @@ dependencies = [ [[package]] name = "grin_chain" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2#0a96a3c69e7364246ed05d7ac89c8e51e9e2ebce" +source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" dependencies = [ "bit-vec", "bitflags 1.3.2", @@ -2089,7 +2083,7 @@ dependencies = [ [[package]] name = "grin_core" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2#0a96a3c69e7364246ed05d7ac89c8e51e9e2ebce" +source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" dependencies = [ "blake2-rfc", "byteorder", @@ -2115,7 +2109,7 @@ dependencies = [ [[package]] name = "grin_keychain" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2#0a96a3c69e7364246ed05d7ac89c8e51e9e2ebce" +source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" dependencies = [ "blake2-rfc", "byteorder", @@ -2138,7 +2132,7 @@ dependencies = [ [[package]] name = "grin_p2p" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2#0a96a3c69e7364246ed05d7ac89c8e51e9e2ebce" +source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" dependencies = [ "async-std", "bitflags 1.3.2", @@ -2172,7 +2166,7 @@ dependencies = [ [[package]] name = "grin_pool" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2#0a96a3c69e7364246ed05d7ac89c8e51e9e2ebce" +source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" dependencies = [ "blake2-rfc", "chrono", @@ -2204,7 +2198,7 @@ dependencies = [ [[package]] name = "grin_store" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2#0a96a3c69e7364246ed05d7ac89c8e51e9e2ebce" +source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" dependencies = [ "byteorder", "croaring", @@ -2223,7 +2217,7 @@ dependencies = [ [[package]] name = "grin_util" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2#0a96a3c69e7364246ed05d7ac89c8e51e9e2ebce" +source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" dependencies = [ "backtrace", "base64 0.12.3", @@ -2247,7 +2241,7 @@ dependencies = [ [[package]] name = "grin_wallet_api" -version = "5.3.2" +version = "5.3.3" dependencies = [ "base64 0.12.3", "chrono", @@ -2271,7 +2265,7 @@ dependencies = [ [[package]] name = "grin_wallet_config" -version = "5.3.2" +version = "5.3.3" dependencies = [ "dirs 2.0.2", "grin_wallet_util", @@ -2285,7 +2279,7 @@ dependencies = [ [[package]] name = "grin_wallet_controller" -version = "5.3.2" +version = "5.3.3" dependencies = [ "chrono", "colored", @@ -2320,7 +2314,7 @@ dependencies = [ [[package]] name = "grin_wallet_impls" -version = "5.3.2" +version = "5.3.3" dependencies = [ "base64 0.12.3", "blake2-rfc", @@ -2355,7 +2349,7 @@ dependencies = [ [[package]] name = "grin_wallet_libwallet" -version = "5.3.2" +version = "5.3.3" dependencies = [ "base64 0.12.3", "bch", @@ -2414,7 +2408,7 @@ dependencies = [ [[package]] name = "grin_wallet_util" -version = "5.3.2" +version = "5.3.3" dependencies = [ "data-encoding", "ed25519-dalek", @@ -2475,9 +2469,9 @@ checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" [[package]] name = "hashbrown" -version = "0.14.5" +version = "0.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1" +checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb" [[package]] name = "heck" @@ -2573,7 +2567,7 @@ version = "0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1" dependencies = [ - "bytes 1.7.1", + "bytes 1.7.2", "fnv", "itoa 1.0.11", ] @@ -2590,9 +2584,9 @@ dependencies = [ [[package]] name = "httparse" -version = "1.9.4" +version = "1.9.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fcc0b4a115bf80b728eb8ea024ad5bd707b615bfed49e0665b6e0f86fd082d9" +checksum = "7d71d3574edd2771538b901e6549113b4006ece66150fb69c0fb6d9a2adae946" [[package]] name = "httpdate" @@ -2696,9 +2690,9 @@ dependencies = [ [[package]] name = "iana-time-zone" -version = "0.1.60" +version = "0.1.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141" +checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220" dependencies = [ "android_system_properties", "core-foundation-sys 0.8.7", @@ -2806,18 +2800,18 @@ version = "1.9.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", "hashbrown 0.12.3", ] [[package]] name = "indexmap" -version = "2.4.0" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93ead53efc7ea8ed3cfb0c79fc8023fbb782a5432b52830b6518941cebe6505c" +checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da" dependencies = [ "equivalent", - "hashbrown 0.14.5", + "hashbrown 0.15.0", ] [[package]] @@ -2860,9 +2854,9 @@ dependencies = [ [[package]] name = "ipnet" -version = "2.9.0" +version = "2.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" +checksum = "187674a687eed5fe42285b40c6291f9a01517d415fad1c3cbc6a9f778af7fcd4" [[package]] name = "is-terminal" @@ -2992,9 +2986,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" [[package]] name = "libc" -version = "0.2.158" +version = "0.2.159" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439" +checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5" [[package]] name = "libgit2-sys" @@ -3030,7 +3024,7 @@ version = "0.35.1" source = "git+https://github.com/mwcproject/rust-libp2p?branch=master#c379113484a616345cff7043733c227bb71d9e74" dependencies = [ "atomic", - "bytes 1.7.1", + "bytes 1.7.2", "futures 0.3.30", "lazy_static", "libp2p-core", @@ -3103,7 +3097,7 @@ dependencies = [ "asynchronous-codec", "base64 0.13.1", "byteorder", - "bytes 1.7.1", + "bytes 1.7.2", "fnv", "futures 0.3.30", "hex_fmt", @@ -3126,7 +3120,7 @@ version = "0.27.1" source = "git+https://github.com/mwcproject/rust-libp2p?branch=master#c379113484a616345cff7043733c227bb71d9e74" dependencies = [ "asynchronous-codec", - "bytes 1.7.1", + "bytes 1.7.2", "futures 0.3.30", "libp2p-core", "log", @@ -3142,7 +3136,7 @@ name = "libp2p-noise" version = "0.29.0" source = "git+https://github.com/mwcproject/rust-libp2p?branch=master#c379113484a616345cff7043733c227bb71d9e74" dependencies = [ - "bytes 1.7.1", + "bytes 1.7.2", "curve25519-dalek 3.2.0", "futures 0.3.30", "lazy_static", @@ -3211,7 +3205,7 @@ dependencies = [ "libp2p-core", "log", "socket2 0.3.19", - "tokio 1.39.3", + "tokio 1.40.0", ] [[package]] @@ -3337,7 +3331,7 @@ version = "0.4.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "07af8b9cdd281b7915f413fa73f29ebd5d55d0d3f0155584dade1ff18cea1b17" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", "scopeguard", ] @@ -3435,15 +3429,6 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" -[[package]] -name = "miniz_oxide" -version = "0.7.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8a240ddb74feaf34a79a7add65a741f3167852fba007066dcac1ca548d89c08" -dependencies = [ - "adler", -] - [[package]] name = "miniz_oxide" version = "0.8.0" @@ -3582,7 +3567,7 @@ name = "multistream-select" version = "0.10.1" source = "git+https://github.com/mwcproject/rust-libp2p?branch=master#c379113484a616345cff7043733c227bb71d9e74" dependencies = [ - "bytes 1.7.1", + "bytes 1.7.2", "futures 0.3.30", "log", "pin-project 1.1.5", @@ -3601,7 +3586,7 @@ dependencies = [ [[package]] name = "mwc_wallet" -version = "5.3.2" +version = "5.3.3" dependencies = [ "built", "clap", @@ -3654,7 +3639,7 @@ dependencies = [ "openssl-sys", "schannel", "security-framework 2.11.1", - "security-framework-sys 2.11.1", + "security-framework-sys 2.12.0", "tempfile", ] @@ -3757,7 +3742,7 @@ version = "0.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "090c7f9998ee0ff65aa5b723e4009f7b217707f1fb5ea551329cc4d6231fb304" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", "num-integer", "num-traits 0.2.19", ] @@ -3778,7 +3763,7 @@ version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6b19411a9719e753aff12e5187b74d60d3dc449ec3f4dc21e3989c3f554bc95" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", "num-traits 0.2.19", ] @@ -3806,7 +3791,7 @@ version = "0.1.45" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", "num-integer", "num-traits 0.2.19", ] @@ -3817,7 +3802,7 @@ version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5c000134b5dbf44adc5cb772486d335293351644b801551abe8f75c84cfa4aef" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", "num-bigint 0.2.6", "num-integer", "num-traits 0.2.19", @@ -3849,7 +3834,7 @@ version = "0.2.19" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", ] [[package]] @@ -3873,9 +3858,12 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.19.0" +version = "1.20.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" +checksum = "82881c4be219ab5faaf2ad5e5e5ecdff8c66bd7402ca3160975c93b24961afd1" +dependencies = [ + "portable-atomic", +] [[package]] name = "opaque-debug" @@ -3912,7 +3900,7 @@ checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", - "syn 2.0.76", + "syn 2.0.79", ] [[package]] @@ -3992,9 +3980,9 @@ dependencies = [ [[package]] name = "parking" -version = "2.2.0" +version = "2.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb813b8af86854136c6922af0598d719255ecb2179515e6e7730d468f05c9cae" +checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba" [[package]] name = "parking_lot" @@ -4171,7 +4159,7 @@ checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965" dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", - "syn 2.0.76", + "syn 2.0.79", ] [[package]] @@ -4205,9 +4193,9 @@ dependencies = [ [[package]] name = "pkg-config" -version = "0.3.30" +version = "0.3.31" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec" +checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2" [[package]] name = "polling" @@ -4215,7 +4203,7 @@ version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4b2d323e8ca7996b3e23126511a523f7e62924d93ecd5ae73b333815b0eb3dce" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", "bitflags 1.3.2", "cfg-if 1.0.0", "concurrent-queue", @@ -4235,7 +4223,7 @@ dependencies = [ "concurrent-queue", "hermit-abi 0.4.0", "pin-project-lite 0.2.14", - "rustix 0.38.35", + "rustix 0.38.37", "tracing", "windows-sys 0.59.0", ] @@ -4273,6 +4261,12 @@ dependencies = [ "universal-hash 0.5.1", ] +[[package]] +name = "portable-atomic" +version = "1.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2" + [[package]] name = "ppv-lite86" version = "0.2.20" @@ -4390,7 +4384,7 @@ version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9e6984d2f1a23009bd270b8bb56d0926810a3d483f59c987d77969e9d8e840b2" dependencies = [ - "bytes 1.7.1", + "bytes 1.7.2", "prost-derive", ] @@ -4400,7 +4394,7 @@ version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32d3ebd75ac2679c2af3a92246639f9fcc8a442ee420719cc4fe195b98dd5fa3" dependencies = [ - "bytes 1.7.1", + "bytes 1.7.2", "heck", "itertools", "log", @@ -4431,7 +4425,7 @@ version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b518d7cdd93dab1d1122cf07fa9a60771836c668dde9d9e2a139f957f0d9f1bb" dependencies = [ - "bytes 1.7.1", + "bytes 1.7.2", "prost", ] @@ -4761,9 +4755,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.10.6" +version = "1.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619" +checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8" dependencies = [ "aho-corasick", "memchr", @@ -4773,9 +4767,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.7" +version = "0.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df" +checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3" dependencies = [ "aho-corasick", "memchr", @@ -4784,9 +4778,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.4" +version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b" +checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" [[package]] name = "remove_dir_all" @@ -4919,7 +4913,7 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bb919243f34364b6bd2fc10ef797edbfa75f33c252e7998527479c6d6b47e1ec" dependencies = [ - "bytes 1.7.1", + "bytes 1.7.2", "rustc-hex", ] @@ -5010,9 +5004,9 @@ dependencies = [ [[package]] name = "rustix" -version = "0.38.35" +version = "0.38.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a85d50532239da68e9addb745ba38ff4612a242c1c7ceea689c4bc7c2f43c36f" +checksum = "8acb788b847c24f28525660c4d7758620a7210875711f79e7f663cc152726811" dependencies = [ "bitflags 2.6.0", "errno", @@ -5122,11 +5116,11 @@ dependencies = [ [[package]] name = "schannel" -version = "0.1.23" +version = "0.1.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534" +checksum = "e9aaafd5a2b6e3d657ff009d82fbd630b6bd54dd4eb06f21693925cdf80f9b8b" dependencies = [ - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -5205,7 +5199,7 @@ dependencies = [ "core-foundation 0.9.4", "core-foundation-sys 0.8.7", "libc", - "security-framework-sys 2.11.1", + "security-framework-sys 2.12.0", ] [[package]] @@ -5220,9 +5214,9 @@ dependencies = [ [[package]] name = "security-framework-sys" -version = "2.11.1" +version = "2.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75da29fe9b9b08fe9d6b22b5b4bcbc75d8db3aa31e639aa56bb62e9d46bfceaf" +checksum = "ea4a292869320c0272d7bc55a5a6aafaff59b4f63404a003887b679a2e05b4b6" dependencies = [ "core-foundation-sys 0.8.7", "libc", @@ -5261,9 +5255,9 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" [[package]] name = "serde" -version = "1.0.209" +version = "1.0.210" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09" +checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a" dependencies = [ "serde_derive", ] @@ -5280,20 +5274,20 @@ dependencies = [ [[package]] name = "serde_derive" -version = "1.0.209" +version = "1.0.210" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170" +checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f" dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", - "syn 2.0.76", + "syn 2.0.79", ] [[package]] name = "serde_json" -version = "1.0.127" +version = "1.0.128" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad" +checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8" dependencies = [ "itoa 1.0.11", "memchr", @@ -5454,7 +5448,7 @@ version = "0.4.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" dependencies = [ - "autocfg 1.3.0", + "autocfg 1.4.0", ] [[package]] @@ -5645,9 +5639,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.76" +version = "2.0.79" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525" +checksum = "89132cd0bf050864e1d38dc3bbc07a0eb8e7530af26344d3d2bbbef83499f590" dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", @@ -5663,7 +5657,7 @@ dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", "syn 1.0.109", - "unicode-xid 0.2.5", + "unicode-xid 0.2.6", ] [[package]] @@ -5683,14 +5677,14 @@ dependencies = [ [[package]] name = "tempfile" -version = "3.12.0" +version = "3.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64" +checksum = "f0f2c9fc62d0beef6951ccffd757e241266a2c833136efbe35af6cd2567dca5b" dependencies = [ "cfg-if 1.0.0", "fastrand 2.1.1", "once_cell", - "rustix 0.38.35", + "rustix 0.38.37", "windows-sys 0.59.0", ] @@ -5739,22 +5733,22 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.63" +version = "1.0.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724" +checksum = "d50af8abc119fb8bb6dbabcfa89656f46f84aa0ac7688088608076ad2b459a84" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.63" +version = "1.0.64" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261" +checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3" dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", - "syn 2.0.76", + "syn 2.0.79", ] [[package]] @@ -5847,9 +5841,9 @@ dependencies = [ [[package]] name = "tokio" -version = "1.39.3" +version = "1.40.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9babc99b9923bfa4804bd74722ff02c0381021eafa4db9949217e3be8e84fff5" +checksum = "e2b070231665d27ad9ec9b8df639893f46727666c6767db40317fbe920a5d998" dependencies = [ "backtrace", "libc", @@ -5975,7 +5969,7 @@ version = "0.19.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421" dependencies = [ - "indexmap 2.4.0", + "indexmap 2.6.0", "toml_datetime", "winnow", ] @@ -6094,30 +6088,30 @@ checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" [[package]] name = "unicode-ident" -version = "1.0.12" +version = "1.0.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" +checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe" [[package]] name = "unicode-normalization" -version = "0.1.23" +version = "0.1.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5" +checksum = "5033c97c4262335cded6d6fc3e5c18ab755e1a3dc96376350f3d8e9f009ad956" dependencies = [ "tinyvec", ] [[package]] name = "unicode-segmentation" -version = "1.11.0" +version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202" +checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493" [[package]] name = "unicode-width" -version = "0.1.13" +version = "0.1.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d" +checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af" [[package]] name = "unicode-xid" @@ -6127,9 +6121,9 @@ checksum = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc" [[package]] name = "unicode-xid" -version = "0.2.5" +version = "0.2.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "229730647fbc343e3a80e463c1db7f78f3855d3f3739bee0dda773c9a037c90a" +checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" [[package]] name = "universal-hash" @@ -6173,7 +6167,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6889a77d49f1f013504cec6bf97a2c730394adedaeb1deb5ea08949a50541105" dependencies = [ "asynchronous-codec", - "bytes 1.7.1", + "bytes 1.7.2", ] [[package]] @@ -6359,7 +6353,7 @@ dependencies = [ "once_cell", "proc-macro2 1.0.86", "quote 1.0.37", - "syn 2.0.76", + "syn 2.0.79", "wasm-bindgen-shared", ] @@ -6393,7 +6387,7 @@ checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836" dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", - "syn 2.0.76", + "syn 2.0.79", "wasm-bindgen-backend", "wasm-bindgen-shared", ] @@ -6484,7 +6478,7 @@ dependencies = [ "either", "home", "once_cell", - "rustix 0.38.35", + "rustix 0.38.37", ] [[package]] @@ -6832,7 +6826,7 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e" dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", - "syn 2.0.76", + "syn 2.0.79", ] [[package]] @@ -6852,7 +6846,7 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ "proc-macro2 1.0.86", "quote 1.0.37", - "syn 2.0.76", + "syn 2.0.79", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 51071e18..a993578b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "mwc_wallet" -version = "5.3.2" +version = "5.3.3" authors = ["Grin Developers "] description = "Simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." license = "Apache-2.0" @@ -36,12 +36,12 @@ funty = "=1.1.0" uuid = { version = "0.8", features = ["serde", "v4"] } shlex = "1.3.0" -grin_wallet_api = { path = "./api", version = "5.3.2" } -grin_wallet_impls = { path = "./impls", version = "5.3.2" } -grin_wallet_libwallet = { path = "./libwallet", version = "5.3.2" } -grin_wallet_controller = { path = "./controller", version = "5.3.2" } -grin_wallet_config = { path = "./config", version = "5.3.2" } -grin_wallet_util = { path = "./util", version = "5.3.2" } +grin_wallet_api = { path = "./api", version = "5.3.3" } +grin_wallet_impls = { path = "./impls", version = "5.3.3" } +grin_wallet_libwallet = { path = "./libwallet", version = "5.3.3" } +grin_wallet_controller = { path = "./controller", version = "5.3.3" } +grin_wallet_config = { path = "./config", version = "5.3.3" } +grin_wallet_util = { path = "./util", version = "5.3.3" } [build-dependencies] built = { version = "0.4", features = ["git2"]} diff --git a/api/Cargo.toml b/api/Cargo.toml index 7647562a..2f8355ae 100644 --- a/api/Cargo.toml +++ b/api/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "grin_wallet_api" -version = "5.3.2" +version = "5.3.3" authors = ["Grin Developers "] description = "Grin Wallet API" license = "Apache-2.0" @@ -24,10 +24,10 @@ ed25519-dalek = "1.0.0-pre.4" colored = "1.6" x25519-dalek = "0.6" -grin_wallet_libwallet = { path = "../libwallet", version = "5.3.2" } -grin_wallet_config = { path = "../config", version = "5.3.2" } -grin_wallet_impls = { path = "../impls", version = "5.3.2" } -grin_wallet_util = { path = "../util", version = "5.3.2" } +grin_wallet_libwallet = { path = "../libwallet", version = "5.3.3" } +grin_wallet_config = { path = "../config", version = "5.3.3" } +grin_wallet_impls = { path = "../impls", version = "5.3.3" } +grin_wallet_util = { path = "../util", version = "5.3.3" } [dev-dependencies] serde_json = "1" diff --git a/config/Cargo.toml b/config/Cargo.toml index 826a8d1e..3c5ac46c 100644 --- a/config/Cargo.toml +++ b/config/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "grin_wallet_config" -version = "5.3.2" +version = "5.3.3" authors = ["Grin Developers "] description = "Configuration for grin wallet , a simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." license = "Apache-2.0" @@ -17,7 +17,7 @@ toml = "0.5" serde_derive = "1" thiserror = "1" -grin_wallet_util = { path = "../util", version = "5.3.2" } +grin_wallet_util = { path = "../util", version = "5.3.3" } [dev-dependencies] pretty_assertions = "0.6" diff --git a/controller/Cargo.toml b/controller/Cargo.toml index 5d0a17ed..6c86e2d4 100644 --- a/controller/Cargo.toml +++ b/controller/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "grin_wallet_controller" -version = "5.3.2" +version = "5.3.3" authors = ["Grin Developers "] description = "Controllers for grin wallet instantiation" license = "Apache-2.0" @@ -36,11 +36,11 @@ wagyu-ethereum = { git = "https://github.com/mwcproject/wagyu-ethereum", branch libp2p = { git = "https://github.com/mwcproject/rust-libp2p", branch = "master", default-features = false, features = [ "noise", "yamux", "mplex", "dns", "tcp-tokio", "ping", "gossipsub"] } #libp2p = { path = "../../rust-libp2p", default-features = false, features = [ "noise", "yamux", "mplex", "dns", "tcp-tokio", "ping", "gossipsub"] } -grin_wallet_util = { path = "../util", version = "5.3.2" } -grin_wallet_api = { path = "../api", version = "5.3.2" } -grin_wallet_impls = { path = "../impls", version = "5.3.2" } -grin_wallet_libwallet = { path = "../libwallet", version = "5.3.2" } -grin_wallet_config = { path = "../config", version = "5.3.2" } +grin_wallet_util = { path = "../util", version = "5.3.3" } +grin_wallet_api = { path = "../api", version = "5.3.3" } +grin_wallet_impls = { path = "../impls", version = "5.3.3" } +grin_wallet_libwallet = { path = "../libwallet", version = "5.3.3" } +grin_wallet_config = { path = "../config", version = "5.3.3" } [dev-dependencies] remove_dir_all = "0.7" diff --git a/impls/Cargo.toml b/impls/Cargo.toml index 1fbf7984..035dd0c3 100644 --- a/impls/Cargo.toml +++ b/impls/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "grin_wallet_impls" -version = "5.3.2" +version = "5.3.3" authors = ["Grin Developers "] description = "Concrete types derived from libwallet traits" license = "Apache-2.0" @@ -41,9 +41,9 @@ url = "2.1" libp2p = { git = "https://github.com/mwcproject/rust-libp2p", branch = "master", default-features = false, features = [ "noise", "yamux", "mplex", "dns", "tcp-tokio", "ping", "gossipsub"] } #libp2p = { path = "../../rust-libp2p", default-features = false, features = [ "noise", "yamux", "mplex", "dns", "tcp-tokio", "ping", "gossipsub"] } -grin_wallet_util = { path = "../util", version = "5.3.2" } -grin_wallet_config = { path = "../config", version = "5.3.2" } -grin_wallet_libwallet = { path = "../libwallet", version = "5.3.2" } +grin_wallet_util = { path = "../util", version = "5.3.3" } +grin_wallet_config = { path = "../config", version = "5.3.3" } +grin_wallet_libwallet = { path = "../libwallet", version = "5.3.3" } [dev-dependencies] "remove_dir_all" = "0.7" diff --git a/libwallet/Cargo.toml b/libwallet/Cargo.toml index 7cd9a0c0..101a342e 100644 --- a/libwallet/Cargo.toml +++ b/libwallet/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "grin_wallet_libwallet" -version = "5.3.2" +version = "5.3.3" authors = ["Grin Developers "] description = "Simple, private and scalable cryptocurrency implementation based on the MimbleWimble chain format." license = "Apache-2.0" @@ -70,8 +70,8 @@ zcash_primitives = { version = "0.4.0", git = "https://github.com/mwcproject/lib #zcash_primitives = { path = "../../librustzcash/zcash_primitives", features = ["transparent-inputs"] } -grin_wallet_util = { path = "../util", version = "5.3.2" } -grin_wallet_config = { path = "../config", version = "5.3.2" } +grin_wallet_util = { path = "../util", version = "5.3.3" } +grin_wallet_config = { path = "../config", version = "5.3.3" } [target.'cfg(any(target_os = "android", target_os = "linux"))'.dependencies] libc = { version = "0.2.69", default-features = false } diff --git a/util/Cargo.toml b/util/Cargo.toml index c2fa4ece..4bb36287 100644 --- a/util/Cargo.toml +++ b/util/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "grin_wallet_util" -version = "5.3.2" +version = "5.3.3" authors = ["Grin Developers "] description = "Util, for generic utilities and to re-export grin crates" license = "Apache-2.0" @@ -21,22 +21,22 @@ tokio = { version = "0.2", features = ["full"] } thiserror = "1" # For Release -grin_core = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -grin_keychain = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -grin_chain = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -grin_util = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -grin_api = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -grin_store = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -grin_p2p = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } +#grin_core = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } +#grin_keychain = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } +#grin_chain = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } +#grin_util = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } +#grin_api = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } +#grin_store = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } +#grin_p2p = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } # For bleeding edge -#grin_core = { git = "https://github.com/mwcproject/mwc-node", branch = "master" } -#grin_keychain = { git = "https://github.com/mwcproject/mwc-node", branch = "master" } -#grin_chain = { git = "https://github.com/mwcproject/mwc-node", branch = "master" } -#grin_util = { git = "https://github.com/mwcproject/mwc-node", branch = "master" } -#grin_api = { git = "https://github.com/mwcproject/mwc-node", branch = "master" } -#grin_store = { git = "https://github.com/mwcproject/mwc-node", branch = "master" } -#grin_p2p = { git = "https://github.com/mwcproject/mwc-node", branch = "master" } +grin_core = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +grin_keychain = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +grin_chain = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +grin_util = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +grin_api = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +grin_store = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +grin_p2p = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } # For local testing #grin_core = { path = "../../mwc-node/core"} From 96952b3f58e483717982d66c1ddb52928a17abbb Mon Sep 17 00:00:00 2001 From: bayk Date: Thu, 3 Oct 2024 15:51:49 -0700 Subject: [PATCH 5/5] Switch to the new node tag, release config --- Cargo.lock | 24 ++++++++++++------------ util/Cargo.toml | 28 ++++++++++++++-------------- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 298a3250..3d0ee803 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2026,7 +2026,7 @@ dependencies = [ [[package]] name = "grin_api" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" +source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2.2#bc491d0da86a323641482c155cf01b537235ce92" dependencies = [ "bytes 0.5.6", "chrono", @@ -2060,7 +2060,7 @@ dependencies = [ [[package]] name = "grin_chain" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" +source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2.2#bc491d0da86a323641482c155cf01b537235ce92" dependencies = [ "bit-vec", "bitflags 1.3.2", @@ -2083,7 +2083,7 @@ dependencies = [ [[package]] name = "grin_core" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" +source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2.2#bc491d0da86a323641482c155cf01b537235ce92" dependencies = [ "blake2-rfc", "byteorder", @@ -2109,7 +2109,7 @@ dependencies = [ [[package]] name = "grin_keychain" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" +source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2.2#bc491d0da86a323641482c155cf01b537235ce92" dependencies = [ "blake2-rfc", "byteorder", @@ -2132,7 +2132,7 @@ dependencies = [ [[package]] name = "grin_p2p" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" +source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2.2#bc491d0da86a323641482c155cf01b537235ce92" dependencies = [ "async-std", "bitflags 1.3.2", @@ -2166,7 +2166,7 @@ dependencies = [ [[package]] name = "grin_pool" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" +source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2.2#bc491d0da86a323641482c155cf01b537235ce92" dependencies = [ "blake2-rfc", "chrono", @@ -2198,7 +2198,7 @@ dependencies = [ [[package]] name = "grin_store" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" +source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2.2#bc491d0da86a323641482c155cf01b537235ce92" dependencies = [ "byteorder", "croaring", @@ -2217,7 +2217,7 @@ dependencies = [ [[package]] name = "grin_util" version = "5.3.2" -source = "git+https://github.com/mwcproject/mwc-node?branch=5.3.100#d0626e349870237a72ddf710689c70bff3b478c9" +source = "git+https://github.com/mwcproject/mwc-node?tag=5.3.2.2#bc491d0da86a323641482c155cf01b537235ce92" dependencies = [ "backtrace", "base64 0.12.3", @@ -2854,9 +2854,9 @@ dependencies = [ [[package]] name = "ipnet" -version = "2.10.0" +version = "2.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "187674a687eed5fe42285b40c6291f9a01517d415fad1c3cbc6a9f778af7fcd4" +checksum = "ddc24109865250148c2e0f3d25d4f0f479571723792d3802153c60922a4fb708" [[package]] name = "is-terminal" @@ -6082,9 +6082,9 @@ dependencies = [ [[package]] name = "unicode-bidi" -version = "0.3.15" +version = "0.3.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75" +checksum = "5ab17db44d7388991a428b2ee655ce0c212e862eff1768a455c58f9aad6e7893" [[package]] name = "unicode-ident" diff --git a/util/Cargo.toml b/util/Cargo.toml index 4bb36287..40550fc4 100644 --- a/util/Cargo.toml +++ b/util/Cargo.toml @@ -21,22 +21,22 @@ tokio = { version = "0.2", features = ["full"] } thiserror = "1" # For Release -#grin_core = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -#grin_keychain = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -#grin_chain = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -#grin_util = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -#grin_api = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -#grin_store = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } -#grin_p2p = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2" } +grin_core = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2.2" } +grin_keychain = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2.2" } +grin_chain = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2.2" } +grin_util = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2.2" } +grin_api = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2.2" } +grin_store = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2.2" } +grin_p2p = { git = "https://github.com/mwcproject/mwc-node", tag = "5.3.2.2" } # For bleeding edge -grin_core = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } -grin_keychain = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } -grin_chain = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } -grin_util = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } -grin_api = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } -grin_store = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } -grin_p2p = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +#grin_core = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +#grin_keychain = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +#grin_chain = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +#grin_util = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +#grin_api = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +#grin_store = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } +#grin_p2p = { git = "https://github.com/mwcproject/mwc-node", branch = "5.3.100" } # For local testing #grin_core = { path = "../../mwc-node/core"}