pub fn tx_lock_outputs(
		&self,
		keychain_mask: Option<&SecretKey>,
		slate: &Slate,
		address: Option<String>,
		participant_id: usize,
	) -> Result<(), Error> {
		let mut w_lock = self.wallet_inst.lock();
		let w = w_lock.lc_provider()?.wallet_inst()?;
		owner::tx_lock_outputs(&mut **w, keychain_mask, slate, address, participant_id)
	}
/// Locks the outputs associated with the inputs to the transaction in the given
/// [`Slate`](../mimble_wallet_libwallet/slate/struct.Slate.html),
/// making them unavailable for use in further transactions. This function is called
/// by the sender, (or more generally, all parties who have put inputs into the transaction,)
/// and must be called before the corresponding call to [`finalize_tx`](struct.Owner.html#method.finalize_tx)
/// that completes the transaction.
///
/// Outputs will generally remain locked until they are removed from the chain,
/// at which point they will become `Spent`. It is commonplace for transactions not to complete
/// for various reasons over which a particular wallet has no control. For this reason,
/// [`cancel_tx`](struct.Owner.html#method.cancel_tx) can be used to manually unlock outputs
/// and return them to the `Unspent` state.
///
/// # Arguments
/// * `keychain_mask` - Wallet secret mask to XOR against the stored wallet seed before using, if
/// being used.
/// * `slate` - The transaction [`Slate`](../mimble_wallet_libwallet/slate/struct.Slate.html). All
/// * `participant_id` - The participant id, generally 0 for the party putting in funds, 1 for the
/// party receiving.
/// elements in the `input` vector of the `tx` field that are found in the wallet's currently
/// active account will be set to status `Locked`
///
/// # Returns
/// * Ok(()) if successful
/// * or [`libwallet::Error`](../mimble_wallet_libwallet/struct.Error.html) if an error is encountered.
///
/// # Example
/// Set up as in [`new`](struct.Owner.html#method.new) method above.
/// ```
/// # mimble_wallet_api::doctest_helper_setup_doc_env!(wallet, wallet_config);
///
/// let mut api_owner = Owner::new(wallet.clone(), None, None);
/// let args = InitTxArgs {
///     src_acct_name: None,
///     amount: 2_000_000_000,
///     minimum_confirmations: 10,
///     max_outputs: 500,
///     num_change_outputs: 1,
///     selection_strategy_is_use_all: false,
///     message: Some("Remember to lock this when we're happy this is sent".to_owned()),
///     ..Default::default()
/// };
/// let result = api_owner.init_send_tx(
/// 	None,
/// 	args,
/// 	None,
/// 	1,
/// );
///
/// if let Ok(slate) = result {
///		// Send slate somehow
///		// ...
///		// Lock our outputs if we're happy the slate was (or is being) sent
///		api_owner.tx_lock_outputs(None, &slate, None, 0);
/// }
/// ```
Locks the outputs associated with the inputs to the transaction in the given
[`Slate`](../mimble_wallet_libwallet/slate/struct.Slate.html),
making them unavailable for use in further transactions. This function is called
by the sender, (or more generally, all parties who have put inputs into the transaction,)
and must be called before the corresponding call to [`finalize_tx`](struct.Owner.html#method.finalize_tx)
that completes the transaction.

Outputs will generally remain locked until they are removed from the chain,
at which point they will become `Spent`. It is commonplace for transactions not to complete
for various reasons over which a particular wallet has no control. For this reason,
[`cancel_tx`](struct.Owner.html#method.cancel_tx) can be used to manually unlock outputs
and return them to the `Unspent` state.
Locks the outputs associated with the inputs to the transaction in the given [ ` Slate ` ] ( .. / mimble_wallet_libwallet / slate / struct . Slate . html ) making them unavailable for use in further transactions . This function is called by the sender ( or more generally all parties who have put inputs into the transaction ) and must be called before the corresponding call to [ ` finalize_tx ` ] ( struct . Owner . html#method . finalize_tx ) that completes the transaction . Outputs will generally remain locked until they are removed from the chain at which point they will become ` Spent ` . It is commonplace for transactions not to complete for various reasons over which a particular wallet has no control . For this reason [ ` cancel_tx ` ] ( struct . Owner . html#method . cancel_tx ) can be used to manually unlock outputs and return them to the ` Unspent ` state .
pub fn tx_lock_outputs(
		&self,
		keychain_mask: Option<&SecretKey>,
		slate: &Slate,
		address: Option<String>,
		participant_id: usize,
	) -> Result<(), Error> {
		let mut w_lock = self.wallet_inst.lock();
		let w = w_lock.lc_provider()?.wallet_inst()?;
		owner::tx_lock_outputs(&mut **w, keychain_mask, slate, address, participant_id)
	}
pub fn tx_lock_outputs ( & self , keychain_mask : Option < & SecretKey > , slate : & Slate , address : Option < String > , participant_id : usize , ) -> Result < ( ) , Error > { let mut w_lock = self . wallet_inst . lock ( ) ; let w = w_lock . lc_provider ( ) ? . wallet_inst ( ) ? ; owner :: tx_lock_outputs ( & mut * * w , keychain_mask , slate , address , participant_id ) }
Locks the outputs associated with the inputs to the transaction in the given
[`Slate`](../mimble_wallet_libwallet/slate/struct.Slate.html),
making them unavailable for use in further transactions.
Locks the outputs associated with the inputs to the transaction in the given [ ` Slate ` ] ( .. / mimble_wallet_libwallet / slate / struct . Slate . html ) making them unavailable for use in further transactions .
&self
keychain_mask
Option<&SecretKey>
slate
&Slate
address
Option<String>
participant_id
usize
Ok(()) if successful
or [`libwallet::Error`](../mimble_wallet_libwallet/struct.Error.html) if an error is encountered.
Ok (( )) if successful or [ ` libwallet :: Error ` ] ( .. / mimble_wallet_libwallet / struct . Error . html ) if an error is encountered .
&self
keychain_mask
Option<&SecretKey>
slate
&Slate
address
Option<String>
participant_id
usize
example
Set up as in [`new`](struct.Owner.html#method.new) method above.
Set up as in [ ` new ` ] ( struct . Owner . html#method . new ) method above .
mimble_wallet_api::doctest_helper_setup_doc_env!(wallet, wallet_config);
let mut api_owner = Owner::new(wallet.clone(), None, None);
let args = InitTxArgs {
src_acct_name: None,
amount: 2_000_000_000,
minimum_confirmations: 10,
max_outputs: 500,
num_change_outputs: 1,
selection_strategy_is_use_all: false,
message: Some("Remember to lock this when we're happy this is sent".to_owned()),
Default::default()
};
let result = api_owner.init_send_tx(
None,
args,
None,
1,
).

if let Ok(slate) = result {
Send slate somehow

Lock our outputs if we're happy the slate was (or is being) sent
api_owner.tx_lock_outputs(None, &slate, None, 0);
}
```
let mut api_owner = Owner :: new ( wallet . clone () None None ) ; let args = InitTxArgs { src_acct_name : None amount : 2_000_000_000 minimum_confirmations : 10 max_outputs : 500 num_change_outputs : 1 selection_strategy_is_use_all : false message : Some ( " Remember to lock this when we ' re happy this is sent " . to_owned () ) Default :: default () } ; let result = api_owner . init_send_tx ( None args None 1 ) . if let Ok ( slate ) = result { Send slate somehow Lock our outputs if we ' re happy the slate was ( or is being ) sent api_owner . tx_lock_outputs ( None &slate None 0 ) ; } ` ` `