faucet request with mwc-wallet

Author: bay

api/src/owner.rs

@@ -42,7 +42,9 @@ use crate::libwallet::{
 use crate::util::logger::LoggingConfig;
 use crate::util::secp::key::SecretKey;
 use crate::util::{from_hex, Mutex, ZeroingString};
-use libwallet::{wallet_lock, OwnershipProof, OwnershipProofValidation, RetrieveTxQueryArgs};
+use libwallet::{
+	wallet_lock, Context, OwnershipProof, OwnershipProofValidation, RetrieveTxQueryArgs,
+};
 use mwc_wallet_util::mwc_util::secp::key::PublicKey;
 use mwc_wallet_util::mwc_util::static_secp_instance;
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -930,6 +932,15 @@ where
 		owner::issue_invoice_tx(&mut **w, keychain_mask, args, self.doctest_mode, 1)
 	}
 
+	pub fn generate_invoice_slate(
+		&self,
+		keychain_mask: Option<&SecretKey>,
+		amount: u64,
+	) -> Result<(Slate, Context), Error> {
+		wallet_lock!(self.wallet_inst, w);
+		owner::generate_invoice_slate(&mut **w, keychain_mask, amount)
+	}
+
 	/// Processes an invoice tranaction created by another party, essentially
 	/// a `request for payment`. The incoming slate should contain a requested
 	/// amount, an output created by the invoicer convering the amount, and

controller/src/command.rs

@@ -855,6 +855,119 @@ where
 	Ok(())
 }
 
+pub fn fauset_request<L, C, K>(
+	owner_api: &mut Owner<L, C, K>,
+	keychain_mask: Option<&SecretKey>,
+	amount: u64,
+	mqs_config: Option<MQSConfig>,
+) -> Result<(), Error>
+where
+	L: WalletLCProvider<'static, C, K> + 'static,
+	C: NodeClient + 'static,
+	K: keychain::Keychain + 'static,
+{
+	let wallet_inst = owner_api.wallet_inst.clone();
+	let mut res_slate = Slate::blank(2, false);
+	controller::owner_single_use(None, keychain_mask, Some(owner_api), |api, m| {
+		let (slate, context) = api.generate_invoice_slate(m, amount)?;
+
+		if mwc_wallet_impls::adapters::get_mwcmqs_brocker().is_none() {
+			//check to see if mqs_config is there, if not, return error
+			let mqs_config_unwrapped;
+			match mqs_config {
+				Some(s) => {
+					mqs_config_unwrapped = s;
+				}
+				None => {
+					return Err(Error::MQSConfig(format!("NO MQS config!")));
+				}
+			}
+
+			let km = keychain_mask.map(|k| k.clone());
+
+			//start the listener finalize tx
+			let _ = controller::init_start_mwcmqs_listener(
+				wallet_inst.clone(),
+				mqs_config_unwrapped,
+				Arc::new(Mutex::new(km)),
+				false,
+				//None,
+			)?;
+			thread::sleep(Duration::from_millis(2000));
+		}
+
+		let sender = create_sender(
+			"mwcmqs",
+			"xmgEvZ4MCCGMJnRnNXKHBbHmSGWQchNr9uZpY5J1XXnsCFS45fsU",
+			&None,
+			None,
+		)?;
+
+		let (slatepack_secret, secp) = {
+			wallet_lock!(api.wallet_inst, w);
+			let keychain = w.keychain(keychain_mask)?;
+			let slatepack_secret =
+				proofaddress::payment_proof_address_dalek_secret(&keychain, None)?;
+			(slatepack_secret, keychain.secp().clone())
+		};
+
+		res_slate = sender.send_tx(
+			false,
+			&slate,
+			SlatePurpose::InvoiceInitial,
+			&slatepack_secret,
+			None,
+			None,
+			slate.height,
+			&secp,
+		)?;
+
+		{
+			wallet_lock!(api.wallet_inst, w);
+			let mut batch = w.batch(keychain_mask)?;
+			// Participant id is 0 for mwc713 compatibility
+			batch.save_private_context(slate.id.as_bytes(), 0, &context)?;
+			batch.commit()?;
+		}
+
+		Ok(())
+	})?;
+
+	let km = match keychain_mask.as_ref() {
+		None => None,
+		Some(&m) => Some(m.to_owned()),
+	};
+
+	controller::foreign_single_use(owner_api.wallet_inst.clone(), km, |api| {
+		if let Err(e) = api.verify_slate_messages(&res_slate) {
+			error!("Error validating participant messages: {}", e);
+			return Err(Error::LibWallet(format!(
+				"Unable to validate slate messages, {}",
+				e
+			)));
+		}
+		res_slate = api.finalize_invoice_tx(&res_slate)?;
+		Ok(())
+	})?;
+
+	// Posting
+	controller::owner_single_use(None, keychain_mask, Some(owner_api), |api, m| {
+		let result = api.post_tx(m, res_slate.tx_or_err()?, true);
+		match result {
+			Ok(_) => {
+				info!("Transaction finished successfully.");
+				Ok(())
+			}
+			Err(e) => {
+				error!("Tx post error: {}", e);
+				return Err(Error::LibWallet(format!("Unable to post slate, {}", e)));
+			}
+		}
+	})?;
+
+	Ok(())
+}
+
 /// Show slate pack and save it into the backup for historical purpose
 pub fn show_slatepack<L, C, K>(
 	api: &mut Owner<L, C, K>,

doc/floonet_faucet.md

@@ -1,45 +1,72 @@
+
 # MWC Floonet Faucet / MWC Testnet Faucet
 
-If you neeed some coins to test with MWC floonet, please be free to use the faucet that listen on MWC MQS address `xmgEvZ4MCCGMJnRnNXKHBbHmSGWQchNr9uZpY5J1XXnsCFS45fsU`.
+If you need some coins to test with the MWC Floonet network, feel free to use the faucet. It can send up to **5 MWC** per request on the Floonet testnet.
+
+Testnet coins can be requested using `mwc-wallet` with the command:
 
-Faucet is running is mwc713 wallet, so we recommend to use mwc713 wallet to request the coins. Then you can transafer them to your QT wallet or mwc-wallet. 
+```shell
+> mwc-wallet faucet_request --amount <amount>
+```
 
-You can download mwc713 from here: https://github.com/mwcproject/mwc713/releases 
+You can download the `mwc-wallet` from the official releases page:  
+👉 https://github.com/mwcproject/mwc-wallet/releases
 
-We are assuming that you already download, installed and provision your mwc713 wallet. Here are how you can request the coins. Please note, you can request maximun 5 MWC at a time.
+We assume you have already downloaded, installed, and initialized your `mwc-wallet`. Here’s how to request test coins.  
+🔹 **Note:** The maximum amount you can request at once is **5 MWC**.
 
-### How to request the coins
+---
 
+### 💸 How to Request Coins
+
+```shell
+> mwc-wallet --floonet faucet_request -a 1.2
+Password:
+20250705 19:02:06.812 WARN mwc_wallet_controller::controller - Starting MWCMQS Listener
+20250705 19:02:08.474 WARN mwc_wallet_impls::adapters::mwcmq -
+mwcmqs listener started for [xmh3yzhnBj4pxyo2N1upV6FYmqo5QpzM8YHv8HRMghTwm8ht5JR2] tid=[Mg1RKMoenGTULgK_XjBFC]
+slate [c0d202d4-0989-4a3b-a684-97514f84f25e] for [1.200000000] MWCs sent to [mwcmqs://xmgEvZ4MCCGMJnRnNXKHBbHmSGWQchNr9uZpY5J1XXnsCFS45fsU]
+Get invoice finalize slate [c0d202d4-0989-4a3b-a684-97514f84f25e] for [1.200000000] MWCs, processing...
+Invoice slate [c0d202d4-0989-4a3b-a684-97514f84f25e] for [1.200000000] MWCs was processed and sent back for posting.
+Command 'faucet_request' completed successfully
+
+> mwc-wallet --floonet info
+Password:
+updater: the current_height is 1489662
+
+____ Wallet Summary Info - Account 'default' as of height 1489662 ____
+
+ Confirmed Total                  | 4.200000000
+ Awaiting Confirmation (< 10)     | 3.000000000
+ Awaiting Finalization            | 11.200000000
+ Locked by previous transaction   | 0.000000000
+ -------------------------------- | -------------
+ Currently Spendable              | 1.200000000
+
+Command 'info' completed successfully 
 ```
-> mwc713 --floonet
-Using wallet configuration file at ......
-
-Welcome to wallet713 for MWC v4.1.0
-
-Unlock your existing wallet or type 'init' to initiate a new one
-Use 'help' to see available commands
-
-ERROR: The wallet is locked. Please use 'unlock' first.
-wallet713>
-wallet713> unlock -p XXXXXXXXXX
-Your mwcmqs address: xmj6hXXXXXXXXXXXXX
-wallet713>
-wallet713> listen -s
-Starting mwcmqs listener...
-wallet713>
-mwcmqs listener started for [xmj6hTX7UKAXXXXXXXXXXXXXX] tid=[kbxsjQ2TAo0jjLsl8Ib_L]
-
-wallet713> invoice 1.5 --to xmgEvZ4MCCGMJnRnNXKHBbHmSGWQchNr9uZpY5J1XXnsCFS45fsU
-slate [c7831053-80fb-4956-8abd-f2b270afc5ff] for [1.500000000] MWCs sent to [mwcmqs://xmgEvZ4MCCGMJnRnNXKHBbHmSGWQchNr9uZpY5J1XXnsCFS45fsU]
-slate [c7831053-80fb-4956-8abd-f2b270afc5ff] received back from [xmgEvZ4MCCGMJnRnNXKHBbHmSGWQchNr9uZpY5J1XXnsCFS45fsU] for [1.500000000] MWCs
-```
 
-Please note, if faucet not used for a long time, it might take few minutes to wakeup and resync with a blockchain. If you invoice failed,
-please wait for 10 minutes and try again. If it is still offline, please ping any moderator at Discord( https://discord.gg/n5dZaty ) 'developers' channel.  
+🕒 **Note:** If the faucet hasn't been used for a while, it may take a few minutes to wake up and resynchronize with the blockchain.  
+If your invoice fails, please wait a couple of minutes and try again.
+
+📣 If the faucet appears to be offline for an extended time, feel free to ping a moderator in the `#developers` channel on [Discord](https://discord.gg/n5dZaty).
 
-### How to return the coin 
+---
 
-When you finish with your tests, please send the coins back to faucet. 
+### 🔁 How to Return Coins
+
+Once you’re done testing, please return the test coins to the faucet:
+
+```shell
+> mwc-wallet --floonet send -m mwcmqs -d xmgEvZ4MCCGMJnRnNXKHBbHmSGWQchNr9uZpY5J1XXnsCFS45fsU <amount_to_send_back>
+Password:
+20250705 19:06:49.864 WARN mwc_wallet_controller::controller - Starting MWCMQS Listener
+20250705 19:06:52.488 WARN mwc_wallet_impls::adapters::mwcmq -
+mwcmqs listener started for [xmh3yzhnBj4pxyo2N1upV6FYmqo5QpzM8YHv8HRMghTwm8ht5JR2] tid=[RWSevePqTdwCumGfY99it]
+20250705 19:06:52.501 WARN mwc_wallet_controller::controller - Get back slate c0d202d4-0989-4a3b-a684-97514f84f25e. Because slate arrive too late, wallet not processing it
+slate [131a2cc5-cefa-4381-bdc5-e7e4b9abf788] for [1.100000000] MWCs sent to [mwcmqs://xmgEvZ4MCCGMJnRnNXKHBbHmSGWQchNr9uZpY5J1XXnsCFS45fsU]
+slate [131a2cc5-cefa-4381-bdc5-e7e4b9abf788] finalized successfully
+Command 'send' completed successfully
 ```
-send 3.123 --to xmgEvZ4MCCGMJnRnNXKHBbHmSGWQchNr9uZpY5J1XXnsCFS45fsU -c 1
-```
+
+Thank you for testing with MWC Floonet!

impls/src/adapters/mwcmq.rs

@@ -31,6 +31,7 @@ use mwc_wallet_libwallet::slatepack::SlatePurpose;
 use mwc_wallet_libwallet::swap::message::Message;
 use mwc_wallet_libwallet::swap::message::SwapMessage;
 use mwc_wallet_libwallet::{Slate, SlateVersion, VersionedSlate};
+use mwc_wallet_util::mwc_core::global;
 use mwc_wallet_util::mwc_util::secp::key::SecretKey;
 use mwc_wallet_util::mwc_util::secp::Secp256k1;
 use regex::Regex;
@@ -157,9 +158,11 @@ impl SlateSender for MwcMqsChannel {
 		secp: &Secp256k1,
 	) -> Result<Slate, Error> {
 		if !send_tx {
-			return Err(Error::MqsGenericError(
-				"MWCMQS doesn't support invoice transactions".into(),
-			));
+			if global::is_mainnet() {
+				return Err(Error::MqsGenericError(
+					"MWCMQS doesn't support invoice transactions".into(),
+				));
+			}
 		}
 
 		if let Some((mwcmqs_publisher, mwcmqs_subscriber)) = get_mwcmqs_brocker() {

libwallet/src/api_impl/owner.rs

@@ -691,6 +691,44 @@ where
 	Ok(slate)
 }
 
+/// Generate Floonet fouset Invoce slate
+pub fn generate_invoice_slate<'a, T: ?Sized, C, K>(
+	w: &mut T,
+	keychain_mask: Option<&SecretKey>,
+	amount: u64,
+) -> Result<(Slate, Context), Error>
+where
+	T: WalletBackend<'a, C, K>,
+	C: NodeClient + 'a,
+	K: Keychain + 'a,
+{
+	if global::is_mainnet() {
+		return Err(Error::FaucetRequestInvalidNetwork);
+	}
+
+	let parent_key_id = w.parent_key_id();
+
+	let mut slate = tx::new_tx_slate(&mut *w, amount, 2, false, None, false)?;
+	let chain_tip = slate.height; // it is fresh slate, height is a tip
+	let context = tx::add_output_to_slate(
+		&mut *w,
+		keychain_mask,
+		&mut slate,
+		chain_tip,
+		None,
+		None,
+		None,
+		&parent_key_id,
+		0,
+		None,
+		true,
+		false,
+		1,
+	)?;
+
+	Ok((slate, context))
+}
+
 /// Receive an invoice tx, essentially adding inputs to whatever
 /// output was specified
 /// Caller is responsible for wallet refresh

libwallet/src/error.rs

@@ -366,6 +366,10 @@ pub enum Error {
 	/// Invalid ownership proof
 	#[error("Invalid ownership proof: {0}")]
 	InvalidOwnershipProof(String),
+
+	/// Invalid network
+	#[error("command 'faucet_request' works only with a floonet. Please restart your wallet with --floonet parameter.")]
+	FaucetRequestInvalidNetwork,
 }
 
 impl From<io::Error> for Error {

src/bin/mwc-wallet.yml

@@ -1053,4 +1053,12 @@ subcommands:
             help: Proof record
             short: p
             long: proof
-            takes_value: true
+            takes_value: true
+  - faucet_request:
+     about: Request some coins from Floonet fauset
+     args:
+       - amount:
+           help: "Number of Floonet MWC coins to request. Maximum allowed number is 5 MWC, default: 3"
+           short: a
+           long: amount
+           takes_value: true

src/cmd/wallet_args.rs

@@ -687,6 +687,30 @@ pub fn parse_send_args(args: &ArgMatches) -> Result<command::SendArgs, ParseErro
 	}
 }
 
+pub fn parse_faucet_request_args(args: &ArgMatches) -> Result<u64, ParseError> {
+	let amount = parse_optional(args, "amount")?.unwrap_or("3.0".into());
+	let amount = core::core::amount_from_hr_string(&amount);
+	let amount = match amount {
+		Ok(a) => {
+			if a > 5000000000 {
+				return Err(ParseError::ArgumentError(
+					"Faucet single request amount is limited by 5 MWC".into(),
+				));
+			}
+			a
+		}
+		Err(e) => {
+			let msg = format!(
+				"Could not parse amount as a number with optional decimal point. e={}",
+				e
+			);
+			return Err(ParseError::ArgumentError(msg));
+		}
+	};
+
+	Ok(amount)
+}
+
 pub fn parse_receive_unpack_args(args: &ArgMatches) -> Result<command::ReceiveArgs, ParseError> {
 	// input file
 	let input_file = match args.is_present("file") {
@@ -1939,6 +1963,10 @@ where
 			let proof = arg_parse!(parse_required(args, "proof"));
 			command::validate_ownership_proof(owner_api, km, proof)
 		}
+		("faucet_request", Some(args)) => {
+			let amount = arg_parse!(parse_faucet_request_args(&args));
+			command::fauset_request(owner_api, km, amount, Some(mqs_config.clone()))
+		}
 		(cmd, _) => {
 			return Err(Error::ArgumentError(format!(
 				"Unknown wallet command '{}', use 'mwc help wallet' for details",