fix(zcoin): add locked notes support for withdrawals

mm2src/coins/eth.rs

@@ -128,21 +128,22 @@ cfg_wasm32! {
 use super::{
     coin_conf, lp_coinfind_or_err, AsyncMutex, BalanceError, BalanceFut, CheckIfMyPaymentSentArgs, CoinBalance,
     CoinProtocol, CoinTransportMetrics, CoinsContext, ConfirmPaymentInput, EthValidateFeeArgs, FeeApproxStage,
-    FoundSwapTxSpend, HistorySyncState, IguanaPrivKey, MarketCoinOps, MmCoin, MmCoinEnum, MyAddressError,
-    MyWalletAddress, NegotiateSwapContractAddrErr, NumConversError, NumConversResult, PaymentInstructionArgs,
-    PaymentInstructions, PaymentInstructionsErr, PrivKeyBuildPolicy, PrivKeyPolicyNotAllowed, RawTransactionError,
-    RawTransactionFut, RawTransactionRequest, RawTransactionRes, RawTransactionResult, RefundPaymentArgs, RewardTarget,
-    RpcClientType, RpcTransportEventHandler, RpcTransportEventHandlerShared, SearchForSwapTxSpendInput,
+    FoundSwapTxSpend, GetRawTransactionRequest, HistorySyncState, IguanaPrivKey, MarketCoinOps, MmCoin, MmCoinEnum,
+    MyAddressError, MyWalletAddress, NegotiateSwapContractAddrErr, NumConversError, NumConversResult,
+    PaymentInstructionArgs, PaymentInstructions, PaymentInstructionsErr, PrivKeyBuildPolicy, PrivKeyPolicyNotAllowed,
+    RawTransactionError, RawTransactionFut, RawTransactionResult, RefundPaymentArgs, RewardTarget, RpcClientType,
+    RpcTransportEventHandler, RpcTransportEventHandlerShared, SearchForSwapTxSpendInput,
     SendMakerPaymentSpendPreimageInput, SendPaymentArgs, SignEthTransactionParams, SignRawTransactionEnum,
-    SignRawTransactionRequest, SignatureError, SignatureResult, SpendPaymentArgs, SwapGasFeePolicy, SwapOps, TradeFee,
-    TradePreimageError, TradePreimageFut, TradePreimageResult, TradePreimageValue, Transaction, TransactionDetails,
-    TransactionEnum, TransactionErr, TransactionFut, TransactionType, TxMarshalingErr, UnexpectedDerivationMethod,
-    ValidateAddressResult, ValidateFeeArgs, ValidateInstructionsErr, ValidateOtherPubKeyErr, ValidatePaymentError,
-    ValidatePaymentFut, ValidatePaymentInput, VerificationError, VerificationResult, WaitForHTLCTxSpendArgs,
-    WatcherOps, WatcherReward, WatcherRewardError, WatcherSearchForSwapTxSpendInput, WatcherValidatePaymentInput,
-    WatcherValidateTakerFeeInput, WeakSpawner, WithdrawError, WithdrawFee, WithdrawFut, WithdrawRequest,
-    WithdrawResult, EARLY_CONFIRMATION_ERR_LOG, INVALID_CONTRACT_ADDRESS_ERR_LOG, INVALID_PAYMENT_STATE_ERR_LOG,
-    INVALID_RECEIVER_ERR_LOG, INVALID_SENDER_ERR_LOG, INVALID_SWAP_ID_ERR_LOG,
+    SignRawTransactionRequest, SignRawTransactionRes, SignatureError, SignatureResult, SpendPaymentArgs,
+    SwapGasFeePolicy, SwapOps, TradeFee, TradePreimageError, TradePreimageFut, TradePreimageResult, TradePreimageValue,
+    Transaction, TransactionDetails, TransactionEnum, TransactionErr, TransactionFut, TransactionType, TxMarshalingErr,
+    UnexpectedDerivationMethod, ValidateAddressResult, ValidateFeeArgs, ValidateInstructionsErr,
+    ValidateOtherPubKeyErr, ValidatePaymentError, ValidatePaymentFut, ValidatePaymentInput, VerificationError,
+    VerificationResult, WaitForHTLCTxSpendArgs, WatcherOps, WatcherReward, WatcherRewardError,
+    WatcherSearchForSwapTxSpendInput, WatcherValidatePaymentInput, WatcherValidateTakerFeeInput, WeakSpawner,
+    WithdrawError, WithdrawFee, WithdrawFut, WithdrawRequest, WithdrawResult, EARLY_CONFIRMATION_ERR_LOG,
+    INVALID_CONTRACT_ADDRESS_ERR_LOG, INVALID_PAYMENT_STATE_ERR_LOG, INVALID_RECEIVER_ERR_LOG, INVALID_SENDER_ERR_LOG,
+    INVALID_SWAP_ID_ERR_LOG,
 };
 #[cfg(test)]
 pub(crate) use eth_utils::display_u256_with_decimal_point;
@@ -1154,7 +1155,7 @@ impl EthCoinImpl {
     }
 }
 
-async fn get_raw_transaction_impl(coin: EthCoin, req: RawTransactionRequest) -> RawTransactionResult {
+async fn get_raw_transaction_impl(coin: EthCoin, req: GetRawTransactionRequest) -> RawTransactionResult {
     let tx = match req.tx_hash.strip_prefix("0x") {
         Some(tx) => tx,
         None => &req.tx_hash,
@@ -1169,7 +1170,7 @@ async fn get_tx_hex_by_hash_impl(coin: EthCoin, tx_hash: H256) -> RawTransaction
         .await?
         .or_mm_err(|| RawTransactionError::HashNotExist(tx_hash.to_string()))?;
     let raw = signed_tx_from_web3_tx(web3_tx).map_to_mm(RawTransactionError::InternalError)?;
-    Ok(RawTransactionRes {
+    Ok(SignRawTransactionRes {
         tx_hex: BytesJson(rlp::encode(&raw).to_vec()),
     })
 }
@@ -2993,7 +2994,7 @@ async fn sign_raw_eth_tx(coin: &EthCoin, args: &SignEthTransactionParams) -> Raw
                 my_address,
             )
             .await
-            .map(|(signed_tx, _)| RawTransactionRes {
+            .map(|(signed_tx, _)| SignRawTransactionRes {
                 tx_hex: signed_tx.tx_hex().into(),
             })
             .map_to_mm(|err| RawTransactionError::TransactionError(err.get_plain_text_format()))
@@ -3049,7 +3050,7 @@ async fn sign_raw_eth_tx(coin: &EthCoin, args: &SignEthTransactionParams) -> Raw
                 .await
                 .mm_err(|err| RawTransactionError::TransactionError(err.to_string()))?;
 
-            Ok(RawTransactionRes {
+            Ok(SignRawTransactionRes {
                 tx_hex: signed_tx.tx_hex().into(),
             })
         },
@@ -3539,6 +3540,7 @@ impl EthCoin {
                     kmd_rewards: None,
                     transaction_type: Default::default(),
                     memo: None,
+                    rseeds: None,
                 };
 
                 existing_history.push(details);
@@ -3912,6 +3914,7 @@ impl EthCoin {
                     kmd_rewards: None,
                     transaction_type: Default::default(),
                     memo: None,
+                    rseeds: None,
                 };
 
                 existing_history.push(details);
@@ -5963,7 +5966,7 @@ impl MmCoin for EthCoin {
         self.abortable_system.weak_spawner()
     }
 
-    fn get_raw_transaction(&self, req: RawTransactionRequest) -> RawTransactionFut<'_> {
+    fn get_raw_transaction(&self, req: GetRawTransactionRequest) -> RawTransactionFut<'_> {
         Box::new(get_raw_transaction_impl(self.clone(), req).boxed().compat())
     }
 

mm2src/coins/eth/eth_withdraw.rs

@@ -406,6 +406,7 @@ where
             kmd_rewards: None,
             transaction_type: Default::default(),
             memo: None,
+            rseeds: None,
         })
     }
 }

mm2src/coins/lightning.rs

@@ -18,9 +18,9 @@ use crate::utxo::utxo_common::{big_decimal_from_sat, big_decimal_from_sat_unsign
 use crate::utxo::{sat_from_big_decimal, utxo_common, BlockchainNetwork};
 use crate::{
     BalanceFut, CheckIfMyPaymentSentArgs, CoinBalance, ConfirmPaymentInput, DexFee, FeeApproxStage, FoundSwapTxSpend,
-    HistorySyncState, MarketCoinOps, MmCoin, NegotiateSwapContractAddrErr, PaymentInstructionArgs, PaymentInstructions,
-    PaymentInstructionsErr, RawTransactionError, RawTransactionFut, RawTransactionRequest, RawTransactionResult,
-    RefundError, RefundPaymentArgs, RefundResult, SearchForSwapTxSpendInput, SendPaymentArgs,
+    GetRawTransactionRequest, HistorySyncState, MarketCoinOps, MmCoin, NegotiateSwapContractAddrErr,
+    PaymentInstructionArgs, PaymentInstructions, PaymentInstructionsErr, RawTransactionError, RawTransactionFut,
+    RawTransactionResult, RefundError, RefundPaymentArgs, RefundResult, SearchForSwapTxSpendInput, SendPaymentArgs,
     SignRawTransactionRequest, SignatureError, SignatureResult, SpendPaymentArgs, SwapOps, TradeFee, TradePreimageFut,
     TradePreimageResult, TradePreimageValue, Transaction, TransactionEnum, TransactionErr, TransactionResult,
     TxMarshalingErr, UnexpectedDerivationMethod, UtxoStandardCoin, ValidateAddressResult, ValidateFeeArgs,
@@ -1235,7 +1235,7 @@ impl MmCoin for LightningCoin {
         self.platform.abortable_system.weak_spawner()
     }
 
-    fn get_raw_transaction(&self, _req: RawTransactionRequest) -> RawTransactionFut<'_> {
+    fn get_raw_transaction(&self, _req: GetRawTransactionRequest) -> RawTransactionFut<'_> {
         let fut = async move {
             MmError::err(RawTransactionError::InternalError(
                 "get_raw_transaction method is not supported for lightning, please use get_payment_details method instead.".into(),

mm2src/coins/lp_coins.rs

@@ -320,9 +320,9 @@ pub type TradePreimageFut<T> = Box<dyn Future<Item = T, Error = MmError<TradePre
 pub type CoinFindResult<T> = Result<T, MmError<CoinFindError>>;
 pub type TxHistoryFut<T> = Box<dyn Future<Item = T, Error = MmError<TxHistoryError>> + Send>;
 pub type TxHistoryResult<T> = Result<T, MmError<TxHistoryError>>;
-pub type RawTransactionResult = Result<RawTransactionRes, MmError<RawTransactionError>>;
+pub type RawTransactionResult = Result<SignRawTransactionRes, MmError<RawTransactionError>>;
 pub type RawTransactionFut<'a> =
-    Box<dyn Future<Item = RawTransactionRes, Error = MmError<RawTransactionError>> + Send + 'a>;
+    Box<dyn Future<Item = SignRawTransactionRes, Error = MmError<RawTransactionError>> + Send + 'a>;
 pub type RefundResult<T> = Result<T, MmError<RefundError>>;
 /// Helper type used for swap transactions' spend preimage generation result
 pub type GenPreimageResult<Coin> = MmResult<TxPreimageWithSig<Coin>, TxGenError>;
@@ -438,13 +438,13 @@ impl HttpStatusCode for GetMyAddressError {
 }
 
 #[derive(Deserialize)]
-pub struct RawTransactionRequest {
+pub struct GetRawTransactionRequest {
     pub coin: String,
     pub tx_hash: String,
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-pub struct RawTransactionRes {
+pub struct SignRawTransactionRes {
     /// Raw bytes of signed transaction in hexadecimal string, this should be return hexadecimal encoded signed transaction for get_raw_transaction
     pub tx_hex: BytesJson,
 }
@@ -2501,6 +2501,18 @@ impl KmdRewardsDetails {
     }
 }
 
+/// Request to send zcoin raw transaction with extra parameters
+#[derive(Clone, Debug, Deserialize)]
+pub struct ZcoinSendRawTransactionRequest {
+    coin: String,
+    /// List of rseeds used to create transaction notes, needed to lock sent notes properly
+    pub rseeds: Vec<String>,
+    /// Change amount
+    pub received_by_me: BigDecimal,
+    /// Serialized zcoin transaction
+    pub tx_hex: String,
+}
+
 #[derive(Default, Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub enum TransactionType {
     StakingDelegation,
@@ -2534,7 +2546,7 @@ pub struct TransactionDetails {
     /// The amount spent from "my" address
     spent_by_me: BigDecimal,
     /// The amount received by "my" address
-    received_by_me: BigDecimal,
+    pub received_by_me: BigDecimal,
     /// Resulting "my" balance change
     my_balance_change: BigDecimal,
     /// Block height
@@ -2556,6 +2568,8 @@ pub struct TransactionDetails {
     #[serde(default)]
     transaction_type: TransactionType,
     memo: Option<String>,
+    /// List of rseeds, for Zcoin
+    pub rseeds: Option<Vec<String>>,
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
@@ -3602,7 +3616,7 @@ pub trait MmCoin: SwapOps + WatcherOps + MarketCoinOps + Send + Sync + 'static {
 
     fn withdraw(&self, req: WithdrawRequest) -> WithdrawFut;
 
-    fn get_raw_transaction(&self, req: RawTransactionRequest) -> RawTransactionFut<'_>;
+    fn get_raw_transaction(&self, req: GetRawTransactionRequest) -> RawTransactionFut<'_>;
 
     fn get_tx_hex_by_hash(&self, tx_hash: Vec<u8>) -> RawTransactionFut<'_>;
 
@@ -5435,7 +5449,7 @@ pub async fn withdraw(ctx: MmArc, req: WithdrawRequest) -> WithdrawResult {
     coin.withdraw(req).compat().await
 }
 
-pub async fn get_raw_transaction(ctx: MmArc, req: RawTransactionRequest) -> RawTransactionResult {
+pub async fn get_raw_transaction(ctx: MmArc, req: GetRawTransactionRequest) -> RawTransactionResult {
     let coin = lp_coinfind_or_err(&ctx, &req.coin).await.map_mm_err()?;
     coin.get_raw_transaction(req).compat().await
 }
@@ -5472,6 +5486,17 @@ pub async fn sign_raw_transaction(ctx: MmArc, req: SignRawTransactionRequest) ->
     coin.sign_raw_tx(&req).await
 }
 
+pub async fn z_send_raw_transaction(
+    ctx: MmArc,
+    req: ZcoinSendRawTransactionRequest,
+) -> MmResult<String, RawTransactionError> {
+    let coin = lp_coinfind_or_err(&ctx, &req.coin).await.map_mm_err()?;
+    match coin {
+        MmCoinEnum::ZCoin(ref z_coin) => z_coin.z_send_raw_tx(req).await,
+        _ => MmError::err(RawTransactionError::NotImplemented { coin: req.coin }),
+    }
+}
+
 pub async fn remove_delegation(ctx: MmArc, req: RemoveDelegateRequest) -> DelegationResult {
     let coin = lp_coinfind_or_err(&ctx, &req.coin).await.map_mm_err()?;
 

mm2src/coins/my_tx_history_v2.rs

@@ -250,6 +250,7 @@ impl<'a, Addr: Clone + DisplayAddress + Eq + std::hash::Hash, Tx: Transaction> T
             kmd_rewards: None,
             transaction_type: self.transaction_type,
             memo: None,
+            rseeds: None,
         }
     }
 }

mm2src/coins/qrc20.rs

@@ -24,8 +24,8 @@ use crate::utxo::{
 };
 use crate::{
     BalanceError, BalanceFut, CheckIfMyPaymentSentArgs, CoinBalance, ConfirmPaymentInput, DexFee, FeeApproxStage,
-    FoundSwapTxSpend, HistorySyncState, IguanaPrivKey, MarketCoinOps, MmCoin, NegotiateSwapContractAddrErr,
-    PrivKeyBuildPolicy, PrivKeyPolicyNotAllowed, RawTransactionFut, RawTransactionRequest, RawTransactionResult,
+    FoundSwapTxSpend, GetRawTransactionRequest, HistorySyncState, IguanaPrivKey, MarketCoinOps, MmCoin,
+    NegotiateSwapContractAddrErr, PrivKeyBuildPolicy, PrivKeyPolicyNotAllowed, RawTransactionFut, RawTransactionResult,
     RefundPaymentArgs, SearchForSwapTxSpendInput, SendPaymentArgs, SignRawTransactionRequest, SignatureResult,
     SpendPaymentArgs, SwapOps, TradeFee, TradePreimageError, TradePreimageFut, TradePreimageResult, TradePreimageValue,
     TransactionData, TransactionDetails, TransactionEnum, TransactionErr, TransactionResult, TransactionType,
@@ -1247,7 +1247,7 @@ impl MmCoin for Qrc20Coin {
         Box::new(qrc20_withdraw(self.clone(), req).boxed().compat())
     }
 
-    fn get_raw_transaction(&self, req: RawTransactionRequest) -> RawTransactionFut<'_> {
+    fn get_raw_transaction(&self, req: GetRawTransactionRequest) -> RawTransactionFut<'_> {
         Box::new(utxo_common::get_raw_transaction(&self.utxo, req).boxed().compat())
     }
 
@@ -1571,6 +1571,7 @@ async fn qrc20_withdraw(coin: Qrc20Coin, req: WithdrawRequest) -> WithdrawResult
         kmd_rewards: None,
         transaction_type: TransactionType::StandardTransfer,
         memo: None,
+        rseeds: None,
     })
 }
 

mm2src/coins/qrc20/qrc20_tests.rs

@@ -606,6 +606,7 @@ fn test_transfer_details_by_hash() {
         kmd_rewards: None,
         transaction_type: Default::default(),
         memo: None,
+        rseeds: None,
     };
     assert_eq!(actual, expected);
 
@@ -630,6 +631,7 @@ fn test_transfer_details_by_hash() {
         kmd_rewards: None,
         transaction_type: Default::default(),
         memo: None,
+        rseeds: None,
     };
     assert_eq!(actual, expected);
 
@@ -654,6 +656,7 @@ fn test_transfer_details_by_hash() {
         kmd_rewards: None,
         transaction_type: Default::default(),
         memo: None,
+        rseeds: None,
     };
     assert_eq!(actual, expected);
 
@@ -678,6 +681,7 @@ fn test_transfer_details_by_hash() {
         kmd_rewards: None,
         transaction_type: Default::default(),
         memo: None,
+        rseeds: None,
     };
     assert_eq!(actual, expected);
 
@@ -702,6 +706,7 @@ fn test_transfer_details_by_hash() {
         kmd_rewards: None,
         transaction_type: Default::default(),
         memo: None,
+        rseeds: None,
     };
     assert_eq!(actual, expected);
     assert!(it.next().is_none());

mm2src/coins/rpc_command/consolidate_utxos.rs

@@ -139,6 +139,7 @@ pub async fn consolidate_utxos_rpc(
                 kmd_rewards: None,
                 transaction_type: Default::default(),
                 memo: None,
+                rseeds: None,
             };
 
             if tx.should_update_kmd_rewards() {

mm2src/coins/siacoin.rs

@@ -1,16 +1,17 @@
 use super::{
-    BalanceError, CoinBalance, HistorySyncState, MarketCoinOps, MmCoin, RawTransactionFut, RawTransactionRequest,
-    SwapOps, TradeFee, TransactionEnum,
+    BalanceError, CoinBalance, HistorySyncState, MarketCoinOps, MmCoin, RawTransactionFut, SwapOps, TradeFee,
+    TransactionEnum,
 };
 use crate::hd_wallet::HDAddressSelector;
 use crate::{
     coin_errors::MyAddressError, AddressFromPubkeyError, BalanceFut, CanRefundHtlc, CheckIfMyPaymentSentArgs,
-    ConfirmPaymentInput, DexFee, FeeApproxStage, FoundSwapTxSpend, NegotiateSwapContractAddrErr, PrivKeyBuildPolicy,
-    PrivKeyPolicy, RawTransactionResult, RefundPaymentArgs, SearchForSwapTxSpendInput, SendPaymentArgs,
-    SignRawTransactionRequest, SignatureResult, SpendPaymentArgs, TradePreimageFut, TradePreimageResult,
-    TradePreimageValue, TransactionResult, TxMarshalingErr, UnexpectedDerivationMethod, ValidateAddressResult,
-    ValidateFeeArgs, ValidateOtherPubKeyErr, ValidatePaymentInput, ValidatePaymentResult, VerificationResult,
-    WaitForHTLCTxSpendArgs, WatcherOps, WeakSpawner, WithdrawFut, WithdrawRequest,
+    ConfirmPaymentInput, DexFee, FeeApproxStage, FoundSwapTxSpend, GetRawTransactionRequest,
+    NegotiateSwapContractAddrErr, PrivKeyBuildPolicy, PrivKeyPolicy, RawTransactionResult, RefundPaymentArgs,
+    SearchForSwapTxSpendInput, SendPaymentArgs, SignRawTransactionRequest, SignatureResult, SpendPaymentArgs,
+    TradePreimageFut, TradePreimageResult, TradePreimageValue, TransactionResult, TxMarshalingErr,
+    UnexpectedDerivationMethod, ValidateAddressResult, ValidateFeeArgs, ValidateOtherPubKeyErr, ValidatePaymentInput,
+    ValidatePaymentResult, VerificationResult, WaitForHTLCTxSpendArgs, WatcherOps, WeakSpawner, WithdrawFut,
+    WithdrawRequest,
 };
 use crate::{SignatureError, VerificationError};
 use async_trait::async_trait;
@@ -243,7 +244,7 @@ impl MmCoin for SiaCoin {
         unimplemented!()
     }
 
-    fn get_raw_transaction(&self, _req: RawTransactionRequest) -> RawTransactionFut<'_> {
+    fn get_raw_transaction(&self, _req: GetRawTransactionRequest) -> RawTransactionFut<'_> {
         unimplemented!()
     }
 

mm2src/coins/solana/solana_coin.rs

@@ -32,8 +32,8 @@ use crate::{
     coin_errors::{AddressFromPubkeyError, MyAddressError, ValidatePaymentResult},
     hd_wallet::HDAddressSelector,
     BalanceError, BalanceFut, CheckIfMyPaymentSentArgs, CoinBalance, ConfirmPaymentInput, DexFee, FeeApproxStage,
-    FoundSwapTxSpend, HistorySyncState, MarketCoinOps, MmCoin, NegotiateSwapContractAddrErr, PrivKeyBuildPolicy,
-    RawTransactionFut, RawTransactionRequest, RawTransactionResult, RefundPaymentArgs, SearchForSwapTxSpendInput,
+    FoundSwapTxSpend, GetRawTransactionRequest, HistorySyncState, MarketCoinOps, MmCoin, NegotiateSwapContractAddrErr,
+    PrivKeyBuildPolicy, RawTransactionFut, RawTransactionResult, RefundPaymentArgs, SearchForSwapTxSpendInput,
     SendPaymentArgs, SignRawTransactionRequest, SignatureResult, SpendPaymentArgs, SwapOps, TradeFee, TradePreimageFut,
     TradePreimageResult, TradePreimageValue, TransactionEnum, TransactionResult, TxMarshalingErr,
     UnexpectedDerivationMethod, ValidateAddressResult, ValidateFeeArgs, ValidateOtherPubKeyErr, ValidatePaymentInput,
@@ -235,7 +235,7 @@ impl MmCoin for SolanaCoin {
         todo!()
     }
 
-    fn get_raw_transaction(&self, req: RawTransactionRequest) -> RawTransactionFut<'_> {
+    fn get_raw_transaction(&self, req: GetRawTransactionRequest) -> RawTransactionFut<'_> {
         todo!()
     }