diff --git a/.github/actions/deps-install/action.yml b/.github/actions/deps-install/action.yml
index 25ed15bf50..02b0ffbec4 100644
--- a/.github/actions/deps-install/action.yml
+++ b/.github/actions/deps-install/action.yml
@@ -12,33 +12,54 @@ inputs:
runs:
using: 'composite'
steps:
+ - name: Download protoc (Linux)
+ if: runner.os == 'Linux' && contains(inputs.deps, 'protoc')
+ uses: ./.github/actions/download-and-verify
+ with:
+ url: "https://github.com/protocolbuffers/protobuf/releases/download/v25.3/protoc-25.3-linux-x86_64.zip"
+ output_file: "protoc-25.3-linux-x86_64.zip"
+ checksum: "f853e691868d0557425ea290bf7ba6384eef2fa9b04c323afab49a770ba9da80"
+
- name: Install protoc (Linux)
env:
TMP: ${{ inputs.temp || runner.temp }}
if: runner.os == 'Linux' && contains(inputs.deps, 'protoc')
shell: bash
run: |
- wget https://github.com/protocolbuffers/protobuf/releases/download/v25.3/protoc-25.3-linux-x86_64.zip
- unzip protoc-25.3-linux-x86_64 -d "$TMP/protobuf"
+ unzip protoc-25.3-linux-x86_64.zip -d "$TMP/protobuf"
echo "$TMP/protobuf/bin" >> $GITHUB_PATH
+ - name: Download protoc (MacOS)
+ if: runner.os == 'macOS' && contains(inputs.deps, 'protoc')
+ uses: ./.github/actions/download-and-verify
+ with:
+ url: "https://github.com/protocolbuffers/protobuf/releases/download/v25.3/protoc-25.3-osx-x86_64.zip"
+ output_file: "protoc-25.3-osx-x86_64.zip"
+ checksum: "247e003b8e115405172eacc50bd19825209d85940728e766f0848eee7c80e2a1"
+
- name: Install protoc (MacOS)
env:
TMP: ${{ inputs.temp || runner.temp }}
if: runner.os == 'macOS' && contains(inputs.deps, 'protoc')
shell: bash
run: |
- wget https://github.com/protocolbuffers/protobuf/releases/download/v25.3/protoc-25.3-osx-x86_64.zip
unzip protoc-25.3-osx-x86_64.zip -d "$TMP/protobuf"
echo "$TMP/protobuf/bin" >> $GITHUB_PATH
+
+ - name: Download protoc (Windows)
+ uses: ./.github/actions/download-and-verify
+ with:
+ url: "https://github.com/protocolbuffers/protobuf/releases/download/v25.3/protoc-25.3-win64.zip"
+ output_file: "protoc-25.3-win64.zip"
+ checksum: "d6b336b852726364313330631656b7f395dde5b1141b169f5c4b8d43cdf01482"
+
- name: Install protoc (Windows)
env:
TMP: ${{ inputs.temp || runner.temp }}
if: runner.os == 'Windows' && contains(inputs.deps, 'protoc')
shell: powershell
run: |
- Invoke-WebRequest -Uri https://github.com/protocolbuffers/protobuf/releases/download/v25.3/protoc-25.3-win64.zip -OutFile protoc-25.3-win64.zip
7z x protoc-25.3-win64.zip -o"$TMP\protobuf"
echo "$TMP\protobuf\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
diff --git a/.github/actions/download-and-verify/action.yml b/.github/actions/download-and-verify/action.yml
new file mode 100644
index 0000000000..198601f486
--- /dev/null
+++ b/.github/actions/download-and-verify/action.yml
@@ -0,0 +1,46 @@
+name: "Download and verify remote files"
+
+runs:
+ using: "composite"
+ steps:
+ - name: Download (Unix)
+ if: runner.os != 'Windows'
+ shell: bash
+ run: curl -L -o ${{ inputs.output_file }} ${{ inputs.url }}
+
+ - name: Download (Windows)
+ if: runner.os == 'Windows'
+ shell: powershell
+ run: Invoke-WebRequest -Uri ${{ inputs.url }} -OutFile ${{ inputs.output_file }}
+
+ - name: Verify (Unix)
+ if: runner.os != 'Windows'
+ shell: bash
+ run: |
+ if [[ "$RUNNER_OS" == "macOS" ]]; then
+ echo "${{ inputs.checksum }} *${{ inputs.output_file }}" | shasum -a 256 -c
+ else
+ echo "${{ inputs.checksum }} ${{ inputs.output_file }}" | sha256sum -c
+ fi
+
+ - name: Verify (Windows)
+ if: runner.os == 'Windows'
+ shell: powershell
+ run: |
+ $expectedChecksum = "${{ inputs.checksum }}"
+ $actualChecksum = (Get-FileHash -Path "${{ inputs.output_file }}" -Algorithm SHA256).Hash
+ if ($expectedChecksum -ne $actualChecksum) {
+ Write-Output "Checksum did not match! Expected: $expectedChecksum, Found: $actualChecksum"
+ exit 1
+ }
+
+inputs:
+ url:
+ description: "URL of the remote file."
+ required: true
+ output_file:
+ description: "Output path."
+ required: true
+ checksum:
+ description: "Expected checksum of the downloaded file."
+ required: true
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index a9790f9b13..12a60bbc3c 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -122,7 +122,7 @@ jobs:
- name: Test
run: |
- wget -O - https://raw.githubusercontent.com/KomodoPlatform/komodo/master/zcutil/fetch-params-alt.sh | bash
+ wget -O - https://raw.githubusercontent.com/KomodoPlatform/komodo/0adeeabdd484ef40539d1275c6a765f5c530ea79/zcutil/fetch-params-alt.sh | bash
cargo test --test 'mm2_tests_main' --no-fail-fast
mac-x86-64-kdf-integration:
@@ -154,7 +154,7 @@ jobs:
- name: Test
run: |
- wget -O - https://raw.githubusercontent.com/KomodoPlatform/komodo/master/zcutil/fetch-params-alt.sh | bash
+ wget -O - https://raw.githubusercontent.com/KomodoPlatform/komodo/0adeeabdd484ef40539d1275c6a765f5c530ea79/zcutil/fetch-params-alt.sh | bash
cargo test --test 'mm2_tests_main' --no-fail-fast
win-x86-64-kdf-integration:
@@ -181,10 +181,16 @@ jobs:
- name: Cargo cache
uses: ./.github/actions/cargo-cache
+ - name: Download wget64
+ uses: ./.github/actions/download-and-verify
+ with:
+ url: "https://github.com/KomodoPlatform/komodo/raw/d456be35acd1f8584e1e4f971aea27bd0644d5c5/zcutil/wget64.exe"
+ output_file: "/wget64.exe"
+ checksum: "d80719431dc22b0e4a070f61fab982b113a4ed9a6d4cf25e64b5be390dcadb94"
+
- name: Test
run: |
- Invoke-WebRequest -Uri https://github.com/KomodoPlatform/komodo/raw/d456be35acd1f8584e1e4f971aea27bd0644d5c5/zcutil/wget64.exe -OutFile \wget64.exe
- Invoke-WebRequest -Uri https://raw.githubusercontent.com/KomodoPlatform/komodo/master/zcutil/fetch-params-alt.bat -OutFile \cmd.bat && \cmd.bat
+ Invoke-WebRequest -Uri https://raw.githubusercontent.com/KomodoPlatform/komodo/0adeeabdd484ef40539d1275c6a765f5c530ea79/zcutil/fetch-params-alt.bat -OutFile \cmd.bat && \cmd.bat
cargo test --test 'mm2_tests_main' --no-fail-fast
docker-tests:
@@ -213,7 +219,7 @@ jobs:
- name: Test
run: |
- wget -O - https://raw.githubusercontent.com/KomodoPlatform/komodo/v0.8.1/zcutil/fetch-params-alt.sh | bash
+ wget -O - https://raw.githubusercontent.com/KomodoPlatform/komodo/v0.8.1//zcutil/fetch-params-alt.sh | bash
cargo test --test 'docker_tests_main' --features run-docker-tests --no-fail-fast
wasm:
@@ -241,11 +247,17 @@ jobs:
- name: Install wasm-pack
run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+ - name: Download geckodriver
+ uses: ./.github/actions/download-and-verify
+ with:
+ url: "https://github.com/mozilla/geckodriver/releases/download/v0.32.2/geckodriver-v0.32.2-linux64.tar.gz"
+ output_file: "geckodriver-v0.32.2-linux64.tar.gz"
+ checksum: "1eab226bf009599f5aa1d77d9ed4c374e10a03fd848b500be1b32cefd2cbec64"
+
- name: Install firefox and geckodriver
run: |
sudo apt-get update -y
sudo apt-get install -y firefox
- wget https://github.com/mozilla/geckodriver/releases/download/v0.32.2/geckodriver-v0.32.2-linux64.tar.gz
sudo tar -xzvf geckodriver-v0.32.2-linux64.tar.gz -C /bin
sudo chmod +x /bin/geckodriver
diff --git a/Cargo.toml b/Cargo.toml
index deec6b843f..f6f7f67e61 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -59,7 +59,7 @@ opt-level = 3
strip = true
codegen-units = 1
# lto = true
-panic = "abort"
+panic = 'unwind'
[profile.dev]
opt-level = 0
diff --git a/README.md b/README.md
index 0d91d3cded..441c23ba8c 100755
--- a/README.md
+++ b/README.md
@@ -48,7 +48,7 @@
## What is the Komodo DeFi Framework?
-The Komodo DeFi Framework is open-source [atomic-swap](https://komodoplatform.com/en/academy/atomic-swaps/) software for seamless, decentralised, peer to peer trading between almost every blockchain asset in existence. This software works with propagation of orderbooks and swap states through the [libp2p](https://libp2p.io/) protocol and uses [Hash Time Lock Contracts (HTLCs)](https://en.bitcoinwiki.org/wiki/Hashed_Timelock_Contracts) for ensuring that the two parties in a swap either mutually complete a trade, or funds return to thier original owner.
+The Komodo DeFi Framework is open-source [atomic-swap](https://komodoplatform.com/en/academy/atomic-swaps/) software for seamless, decentralized, peer to peer trading between almost every blockchain asset in existence. This software works with propagation of orderbooks and swap states through the [libp2p](https://libp2p.io/) protocol and uses [Hash Time Lock Contracts (HTLCs)](https://en.bitcoinwiki.org/wiki/Hashed_Timelock_Contracts) for ensuring that the two parties in a swap either mutually complete a trade, or funds return to thier original owner.
There is no 3rd party intermediary, no proxy tokens, and at all times users remain in sole possession of their private keys.
@@ -172,7 +172,7 @@ Refer to the [Komodo Developer Docs](https://developers.komodoplatform.com/basic
## Project structure
-[mm2src](mm2src) - Rust code, contains some parts ported from C `as is` (e.g. `lp_ordermatch`) to reach the most essential/error prone code. Some other modules/crates are reimplemented from scratch.
+[mm2src](mm2src) - Rust code, contains some parts ported from C `as is` (e.g. `lp_ordermatch`) to reach the most essential/error-prone code. Some other modules/crates are reimplemented from scratch.
## Additional docs for developers
@@ -185,12 +185,13 @@ Refer to the [Komodo Developer Docs](https://developers.komodoplatform.com/basic
## Disclaimer
-This repository contains the `work in progress` code of the brand new Komodo DeFi Framework (kdf) built mainly on Rust.
-The current state can be considered as a alpha version.
+This repository contains the `work in progress` code of the brand-new Komodo DeFi Framework (kdf) built mainly on Rust.
+The current state can be considered as an alpha version.
**WARNING: Use with test coins only or with assets which value does not exceed an amount you are willing to lose. This is alpha stage software! **
## Help and troubleshooting
-If you have any question/want to report a bug/suggest an improvement feel free to [open an issue](https://github.com/artemii235/SuperNET/issues/new) or join the [Komodo Platform Discord](https://discord.gg/PGxVm2y) `dev-marketmaker` channel.
+If you have any question/want to report a bug/suggest an improvement feel free to [open an issue](https://github.com/KomodoPlatform/komodo-defi-framework/issues/new/choose) or join the [Komodo Platform Discord](https://discord.gg/PGxVm2y) `dev-marketmaker` channel.
+
diff --git a/clippy.toml b/clippy.toml
new file mode 100644
index 0000000000..068d7e886b
--- /dev/null
+++ b/clippy.toml
@@ -0,0 +1,4 @@
+[[disallowed-methods]]
+path = "futures::future::Future::wait"
+replacement = "common::block_on_f01"
+reason = "Use the default KDF async executor."
\ No newline at end of file
diff --git a/mm2src/coins/eth/eth_tests.rs b/mm2src/coins/eth/eth_tests.rs
index 9332594931..03705ff4ca 100644
--- a/mm2src/coins/eth/eth_tests.rs
+++ b/mm2src/coins/eth/eth_tests.rs
@@ -1,27 +1,31 @@
use super::*;
-use crate::eth::for_tests::{eth_coin_for_test, eth_coin_from_keypair};
-use crate::{DexFee, IguanaPrivKey};
-use common::{block_on, now_sec};
-#[cfg(not(target_arch = "wasm32"))]
-use ethkey::{Generator, Random};
+use crate::IguanaPrivKey;
+use common::{block_on, block_on_f01};
use mm2_core::mm_ctx::MmCtxBuilder;
-use mm2_test_helpers::for_tests::{ETH_MAINNET_CHAIN_ID, ETH_MAINNET_NODE, ETH_SEPOLIA_CHAIN_ID, ETH_SEPOLIA_NODES,
+
+cfg_native!(
+ use crate::eth::for_tests::{eth_coin_for_test, eth_coin_from_keypair};
+ use crate::DexFee;
+
+ use common::now_sec;
+ use ethkey::{Generator, Random};
+ use mm2_test_helpers::for_tests::{ETH_MAINNET_CHAIN_ID, ETH_MAINNET_NODE, ETH_SEPOLIA_CHAIN_ID, ETH_SEPOLIA_NODES,
ETH_SEPOLIA_TOKEN_CONTRACT};
-use mocktopus::mocking::*;
-
-/// The gas price for the tests
-const GAS_PRICE: u64 = 50_000_000_000;
-// `GAS_PRICE` increased by 3%
-const GAS_PRICE_APPROXIMATION_ON_START_SWAP: u64 = 51_500_000_000;
-// `GAS_PRICE` increased by 5%
-const GAS_PRICE_APPROXIMATION_ON_ORDER_ISSUE: u64 = 52_500_000_000;
-// `GAS_PRICE` increased by 7%
-const GAS_PRICE_APPROXIMATION_ON_TRADE_PREIMAGE: u64 = 53_500_000_000;
+ use mocktopus::mocking::*;
+
+ /// The gas price for the tests
+ const GAS_PRICE: u64 = 50_000_000_000;
+ /// `GAS_PRICE` increased by 3%
+ const GAS_PRICE_APPROXIMATION_ON_START_SWAP: u64 = 51_500_000_000;
+ /// `GAS_PRICE` increased by 5%
+ const GAS_PRICE_APPROXIMATION_ON_ORDER_ISSUE: u64 = 52_500_000_000;
+ /// `GAS_PRICE` increased by 7%
+ const GAS_PRICE_APPROXIMATION_ON_TRADE_PREIMAGE: u64 = 53_500_000_000;
+);
+
// old way to add some extra gas to the returned value from gas station (non-existent now), still used in tests
const GAS_PRICE_PERCENT: u64 = 10;
-const TAKER_PAYMENT_SPEND_SEARCH_INTERVAL: f64 = 1.;
-
fn check_sum(addr: &str, expected: &str) {
let actual = checksum_address(addr);
assert_eq!(expected, actual);
@@ -154,8 +158,11 @@ fn test_wei_from_big_decimal() {
assert_eq!(expected_wei, wei);
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn test_wait_for_payment_spend_timeout() {
+ const TAKER_PAYMENT_SPEND_SEARCH_INTERVAL: f64 = 1.;
+
EthCoin::spend_events.mock_safe(|_, _, _, _| MockResult::Return(Box::new(futures01::future::ok(vec![]))));
EthCoin::current_block.mock_safe(|_| MockResult::Return(Box::new(futures01::future::ok(900))));
@@ -184,18 +191,16 @@ fn test_wait_for_payment_spend_timeout() {
184, 42, 106,
];
- assert!(coin
- .wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
- tx_bytes: &tx_bytes,
- secret_hash: &[],
- wait_until,
- from_block,
- swap_contract_address: &coin.swap_contract_address(),
- check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
- watcher_reward: false
- })
- .wait()
- .is_err());
+ assert!(block_on_f01(coin.wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
+ tx_bytes: &tx_bytes,
+ secret_hash: &[],
+ wait_until,
+ from_block,
+ swap_contract_address: &coin.swap_contract_address(),
+ check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
+ watcher_reward: false
+ }))
+ .is_err());
}
#[cfg(not(target_arch = "wasm32"))]
@@ -222,7 +227,7 @@ fn test_withdraw_impl_manual_fee() {
memo: None,
ibc_source_channel: None,
};
- coin.get_balance().wait().unwrap();
+ block_on_f01(coin.get_balance()).unwrap();
let tx_details = block_on(withdraw_impl(coin, withdraw_req)).unwrap();
let expected = Some(
@@ -271,7 +276,7 @@ fn test_withdraw_impl_fee_details() {
memo: None,
ibc_source_channel: None,
};
- coin.get_balance().wait().unwrap();
+ block_on_f01(coin.get_balance()).unwrap();
let tx_details = block_on(withdraw_impl(coin, withdraw_req)).unwrap();
let expected = Some(
@@ -306,6 +311,7 @@ fn test_add_ten_pct_one_gwei() {
assert_eq!(expected, actual);
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn get_sender_trade_preimage() {
/// Trade fee for the ETH coin is `2 * 150_000 * gas_price` always.
@@ -361,6 +367,7 @@ fn get_sender_trade_preimage() {
assert_eq!(actual, expected);
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn get_erc20_sender_trade_preimage() {
const APPROVE_GAS_LIMIT: u64 = 60_000;
@@ -463,6 +470,7 @@ fn get_erc20_sender_trade_preimage() {
);
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn get_receiver_trade_preimage() {
EthCoin::get_gas_price.mock_safe(|_| MockResult::Return(Box::pin(futures::future::ok(GAS_PRICE.into()))));
@@ -476,13 +484,12 @@ fn get_receiver_trade_preimage() {
paid_from_trading_vol: false,
};
- let actual = coin
- .get_receiver_trade_fee(FeeApproxStage::WithoutApprox)
- .wait()
- .expect("!get_sender_trade_fee");
+ let actual =
+ block_on_f01(coin.get_receiver_trade_fee(FeeApproxStage::WithoutApprox)).expect("!get_sender_trade_fee");
assert_eq!(actual, expected_fee);
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn test_get_fee_to_send_taker_fee() {
const DEX_FEE_AMOUNT: u64 = 100_000;
@@ -533,6 +540,7 @@ fn test_get_fee_to_send_taker_fee() {
///
/// Please note this test doesn't work correctly now,
/// because as of now [`EthCoin::get_fee_to_send_taker_fee`] doesn't process the `Exception` web3 error correctly.
+#[cfg(not(target_arch = "wasm32"))]
#[test]
#[ignore]
fn test_get_fee_to_send_taker_fee_insufficient_balance() {
@@ -562,6 +570,7 @@ fn test_get_fee_to_send_taker_fee_insufficient_balance() {
);
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn validate_dex_fee_invalid_sender_eth() {
let (_ctx, coin) = eth_coin_for_test(EthCoinType::Eth, &[ETH_MAINNET_NODE], None, ETH_MAINNET_CHAIN_ID);
@@ -582,13 +591,16 @@ fn validate_dex_fee_invalid_sender_eth() {
min_block_number: 0,
uuid: &[],
};
- let error = coin.validate_fee(validate_fee_args).wait().unwrap_err().into_inner();
+ let error = block_on_f01(coin.validate_fee(validate_fee_args))
+ .unwrap_err()
+ .into_inner();
match error {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("was sent from wrong address")),
_ => panic!("Expected `WrongPaymentTx` wrong sender address, found {:?}", error),
}
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn validate_dex_fee_invalid_sender_erc() {
let (_ctx, coin) = eth_coin_for_test(
@@ -617,13 +629,16 @@ fn validate_dex_fee_invalid_sender_erc() {
min_block_number: 0,
uuid: &[],
};
- let error = coin.validate_fee(validate_fee_args).wait().unwrap_err().into_inner();
+ let error = block_on_f01(coin.validate_fee(validate_fee_args))
+ .unwrap_err()
+ .into_inner();
match error {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("was sent from wrong address")),
_ => panic!("Expected `WrongPaymentTx` wrong sender address, found {:?}", error),
}
}
+#[cfg(not(target_arch = "wasm32"))]
fn sender_compressed_pub(tx: &SignedEthTx) -> [u8; 33] {
let tx_pubkey = tx.public.unwrap();
let mut raw_pubkey = [0; 65];
@@ -633,6 +648,7 @@ fn sender_compressed_pub(tx: &SignedEthTx) -> [u8; 33] {
secp_public.serialize()
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn validate_dex_fee_eth_confirmed_before_min_block() {
let (_ctx, coin) = eth_coin_for_test(EthCoinType::Eth, &[ETH_MAINNET_NODE], None, ETH_MAINNET_CHAIN_ID);
@@ -655,13 +671,16 @@ fn validate_dex_fee_eth_confirmed_before_min_block() {
min_block_number: 11784793,
uuid: &[],
};
- let error = coin.validate_fee(validate_fee_args).wait().unwrap_err().into_inner();
+ let error = block_on_f01(coin.validate_fee(validate_fee_args))
+ .unwrap_err()
+ .into_inner();
match error {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("confirmed before min_block")),
_ => panic!("Expected `WrongPaymentTx` early confirmation, found {:?}", error),
}
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn validate_dex_fee_erc_confirmed_before_min_block() {
let (_ctx, coin) = eth_coin_for_test(
@@ -693,13 +712,16 @@ fn validate_dex_fee_erc_confirmed_before_min_block() {
min_block_number: 11823975,
uuid: &[],
};
- let error = coin.validate_fee(validate_fee_args).wait().unwrap_err().into_inner();
+ let error = block_on_f01(coin.validate_fee(validate_fee_args))
+ .unwrap_err()
+ .into_inner();
match error {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("confirmed before min_block")),
_ => panic!("Expected `WrongPaymentTx` early confirmation, found {:?}", error),
}
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn test_negotiate_swap_contract_addr_no_fallback() {
let (_, coin) = eth_coin_for_test(EthCoinType::Eth, &[ETH_MAINNET_NODE], None, ETH_MAINNET_CHAIN_ID);
@@ -727,6 +749,7 @@ fn test_negotiate_swap_contract_addr_no_fallback() {
assert_eq!(Some(slice.to_vec().into()), result);
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn test_negotiate_swap_contract_addr_has_fallback() {
let fallback = Address::from_str("0x8500AFc0bc5214728082163326C2FF0C73f4a871").unwrap();
@@ -815,15 +838,14 @@ fn polygon_check_if_my_payment_sent() {
amount: &BigDecimal::default(),
payment_instructions: &None,
};
- let my_payment = coin
- .check_if_my_payment_sent(if_my_payment_sent_args)
- .wait()
+ let my_payment = block_on_f01(coin.check_if_my_payment_sent(if_my_payment_sent_args))
.unwrap()
.unwrap();
let expected_hash = BytesJson::from("69a20008cea0c15ee483b5bbdff942752634aa072dfd2ff715fe87eec302de11");
assert_eq!(expected_hash, my_payment.tx_hash_as_bytes());
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn test_message_hash() {
let key_pair = Random.generate().unwrap();
@@ -842,6 +864,7 @@ fn test_message_hash() {
);
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn test_sign_verify_message() {
let key_pair = KeyPair::from_secret_slice(
@@ -866,6 +889,7 @@ fn test_sign_verify_message() {
assert!(is_valid);
}
+#[cfg(not(target_arch = "wasm32"))]
#[test]
fn test_eth_extract_secret() {
let key_pair = Random.generate().unwrap();
diff --git a/mm2src/coins/lightning/ln_platform.rs b/mm2src/coins/lightning/ln_platform.rs
index 4d0573af95..0a5fae0a4f 100644
--- a/mm2src/coins/lightning/ln_platform.rs
+++ b/mm2src/coins/lightning/ln_platform.rs
@@ -15,7 +15,7 @@ use bitcoin::hash_types::{BlockHash, TxMerkleNode, Txid};
use bitcoin_hashes::{sha256d, Hash};
use common::executor::{abortable_queue::AbortableQueue, AbortableSystem, SpawnFuture, Timer};
use common::log::{debug, error, info};
-use common::wait_until_sec;
+use common::{block_on_f01, wait_until_sec};
use futures::compat::Future01CompatExt;
use futures::future::join_all;
use keys::hash::H256;
@@ -570,17 +570,15 @@ impl FeeEstimator for Platform {
ConfirmationTarget::HighPriority => self.confirmations_targets.high_priority,
};
let fee_per_kb = tokio::task::block_in_place(move || {
- self.rpc_client()
- .estimate_fee_sat(
- platform_coin.decimals(),
- // Todo: when implementing Native client detect_fee_method should be used for Native and
- // EstimateFeeMethod::Standard for Electrum
- &EstimateFeeMethod::Standard,
- &conf.estimate_fee_mode,
- n_blocks,
- )
- .wait()
- .unwrap_or(latest_fees)
+ block_on_f01(self.rpc_client().estimate_fee_sat(
+ platform_coin.decimals(),
+ // Todo: when implementing Native client detect_fee_method should be used for Native and
+ // EstimateFeeMethod::Standard for Electrum
+ &EstimateFeeMethod::Standard,
+ &conf.estimate_fee_mode,
+ n_blocks,
+ ))
+ .unwrap_or(latest_fees)
});
// Set default fee to last known fee for the corresponding confirmation target
diff --git a/mm2src/coins/lp_coins.rs b/mm2src/coins/lp_coins.rs
index 59febe5a4c..1d9c11e3b9 100644
--- a/mm2src/coins/lp_coins.rs
+++ b/mm2src/coins/lp_coins.rs
@@ -124,7 +124,7 @@ macro_rules! try_f {
};
}
-#[cfg(feature = "enable-solana")]
+#[cfg(all(feature = "enable-solana", not(target_arch = "wasm32")))]
macro_rules! try_tx_fus_err {
($err: expr) => {
return Box::new(futures01::future::err(crate::TransactionErr::Plain(ERRL!(
@@ -133,7 +133,7 @@ macro_rules! try_tx_fus_err {
};
}
-#[cfg(feature = "enable-solana")]
+#[cfg(all(feature = "enable-solana", not(target_arch = "wasm32")))]
macro_rules! try_tx_fus_opt {
($e: expr, $err: expr) => {
match $e {
diff --git a/mm2src/coins/qrc20/qrc20_tests.rs b/mm2src/coins/qrc20/qrc20_tests.rs
index 2caf87c3bf..d77afa2f9b 100644
--- a/mm2src/coins/qrc20/qrc20_tests.rs
+++ b/mm2src/coins/qrc20/qrc20_tests.rs
@@ -1,6 +1,6 @@
use super::*;
use crate::{DexFee, TxFeeDetails, WaitForHTLCTxSpendArgs};
-use common::{block_on, wait_until_sec, DEX_FEE_ADDR_RAW_PUBKEY};
+use common::{block_on, block_on_f01, wait_until_sec, DEX_FEE_ADDR_RAW_PUBKEY};
use crypto::Secp256k1Secret;
use itertools::Itertools;
use keys::Address;
@@ -96,7 +96,7 @@ fn test_withdraw_to_p2sh_address_should_fail() {
memo: None,
ibc_source_channel: None,
};
- let err = coin.withdraw(req).wait().unwrap_err().into_inner();
+ let err = block_on_f01(coin.withdraw(req)).unwrap_err().into_inner();
let expect = WithdrawError::InvalidAddress("QRC20 can be sent to P2PKH addresses only".to_owned());
assert_eq!(err, expect);
}
@@ -112,19 +112,22 @@ fn test_withdraw_impl_fee_details() {
let (_ctx, coin) = qrc20_coin_for_test(priv_key, None);
Qrc20Coin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
let withdraw_req = WithdrawRequest {
@@ -140,7 +143,7 @@ fn test_withdraw_impl_fee_details() {
memo: None,
ibc_source_channel: None,
};
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
let expected: Qrc20FeeDetails = json::from_value(json!({
"coin": "QTUM",
@@ -287,7 +290,7 @@ fn test_wait_for_confirmations_excepted() {
wait_until,
check_every,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
// tx_hash: ed53b97deb2ad76974c972cb084f6ba63bd9f16c91c4a39106a20c6d14599b2a
// `erc20Payment` contract call excepted
@@ -299,7 +302,7 @@ fn test_wait_for_confirmations_excepted() {
wait_until,
check_every,
};
- let error = coin.wait_for_confirmations(confirm_payment_input).wait().unwrap_err();
+ let error = block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap_err();
log!("error: {:?}", error);
assert!(error.contains("Contract call failed with an error: Revert"));
@@ -313,7 +316,7 @@ fn test_wait_for_confirmations_excepted() {
wait_until,
check_every,
};
- let error = coin.wait_for_confirmations(confirm_payment_input).wait().unwrap_err();
+ let error = block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap_err();
log!("error: {:?}", error);
assert!(error.contains("Contract call failed with an error: Revert"));
}
@@ -333,67 +336,59 @@ fn test_validate_fee() {
let amount = BigDecimal::from_str("0.01").unwrap();
- let result = coin
- .validate_fee(ValidateFeeArgs {
- fee_tx: &tx,
- expected_sender: &sender_pub,
- fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
- dex_fee: &DexFee::Standard(amount.clone().into()),
- min_block_number: 0,
- uuid: &[],
- })
- .wait();
+ let result = block_on_f01(coin.validate_fee(ValidateFeeArgs {
+ fee_tx: &tx,
+ expected_sender: &sender_pub,
+ fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
+ dex_fee: &DexFee::Standard(amount.clone().into()),
+ min_block_number: 0,
+ uuid: &[],
+ }));
assert!(result.is_ok());
let fee_addr_dif = hex::decode("03bc2c7ba671bae4a6fc835244c9762b41647b9827d4780a89a949b984a8ddcc05").unwrap();
- let err = coin
- .validate_fee(ValidateFeeArgs {
- fee_tx: &tx,
- expected_sender: &sender_pub,
- fee_addr: &fee_addr_dif,
- dex_fee: &DexFee::Standard(amount.clone().into()),
- min_block_number: 0,
- uuid: &[],
- })
- .wait()
- .expect_err("Expected an error")
- .into_inner();
+ let err = block_on_f01(coin.validate_fee(ValidateFeeArgs {
+ fee_tx: &tx,
+ expected_sender: &sender_pub,
+ fee_addr: &fee_addr_dif,
+ dex_fee: &DexFee::Standard(amount.clone().into()),
+ min_block_number: 0,
+ uuid: &[],
+ }))
+ .expect_err("Expected an error")
+ .into_inner();
log!("error: {:?}", err);
match err {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("QRC20 Fee tx was sent to wrong address")),
_ => panic!("Expected `WrongPaymentTx` wrong receiver address, found {:?}", err),
}
- let err = coin
- .validate_fee(ValidateFeeArgs {
- fee_tx: &tx,
- expected_sender: &DEX_FEE_ADDR_RAW_PUBKEY,
- fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
- dex_fee: &DexFee::Standard(amount.clone().into()),
- min_block_number: 0,
- uuid: &[],
- })
- .wait()
- .expect_err("Expected an error")
- .into_inner();
+ let err = block_on_f01(coin.validate_fee(ValidateFeeArgs {
+ fee_tx: &tx,
+ expected_sender: &DEX_FEE_ADDR_RAW_PUBKEY,
+ fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
+ dex_fee: &DexFee::Standard(amount.clone().into()),
+ min_block_number: 0,
+ uuid: &[],
+ }))
+ .expect_err("Expected an error")
+ .into_inner();
log!("error: {:?}", err);
match err {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("was sent from wrong address")),
_ => panic!("Expected `WrongPaymentTx` wrong sender address, found {:?}", err),
}
- let err = coin
- .validate_fee(ValidateFeeArgs {
- fee_tx: &tx,
- expected_sender: &sender_pub,
- fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
- dex_fee: &DexFee::Standard(amount.clone().into()),
- min_block_number: 2000000,
- uuid: &[],
- })
- .wait()
- .expect_err("Expected an error")
- .into_inner();
+ let err = block_on_f01(coin.validate_fee(ValidateFeeArgs {
+ fee_tx: &tx,
+ expected_sender: &sender_pub,
+ fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
+ dex_fee: &DexFee::Standard(amount.clone().into()),
+ min_block_number: 2000000,
+ uuid: &[],
+ }))
+ .expect_err("Expected an error")
+ .into_inner();
log!("error: {:?}", err);
match err {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("confirmed before min_block")),
@@ -401,18 +396,16 @@ fn test_validate_fee() {
}
let amount_dif = BigDecimal::from_str("0.02").unwrap();
- let err = coin
- .validate_fee(ValidateFeeArgs {
- fee_tx: &tx,
- expected_sender: &sender_pub,
- fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
- dex_fee: &DexFee::Standard(amount_dif.into()),
- min_block_number: 0,
- uuid: &[],
- })
- .wait()
- .expect_err("Expected an error")
- .into_inner();
+ let err = block_on_f01(coin.validate_fee(ValidateFeeArgs {
+ fee_tx: &tx,
+ expected_sender: &sender_pub,
+ fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
+ dex_fee: &DexFee::Standard(amount_dif.into()),
+ min_block_number: 0,
+ uuid: &[],
+ }))
+ .expect_err("Expected an error")
+ .into_inner();
log!("error: {:?}", err);
match err {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -424,18 +417,16 @@ fn test_validate_fee() {
// QTUM tx "8a51f0ffd45f34974de50f07c5bf2f0949da4e88433f8f75191953a442cf9310"
let tx = TransactionEnum::UtxoTx("020000000113640281c9332caeddd02a8dd0d784809e1ad87bda3c972d89d5ae41f5494b85010000006a47304402207c5c904a93310b8672f4ecdbab356b65dd869a426e92f1064a567be7ccfc61ff02203e4173b9467127f7de4682513a21efb5980e66dbed4da91dff46534b8e77c7ef012102baefe72b3591de2070c0da3853226b00f082d72daa417688b61cb18c1d543d1afeffffff020001b2c4000000001976a9149e032d4b0090a11dc40fe6c47601499a35d55fbb88acbc4dd20c2f0000001976a9144208fa7be80dcf972f767194ad365950495064a488ac76e70800".into());
let sender_pub = hex::decode("02baefe72b3591de2070c0da3853226b00f082d72daa417688b61cb18c1d543d1a").unwrap();
- let err = coin
- .validate_fee(ValidateFeeArgs {
- fee_tx: &tx,
- expected_sender: &sender_pub,
- fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
- dex_fee: &DexFee::Standard(amount.into()),
- min_block_number: 0,
- uuid: &[],
- })
- .wait()
- .expect_err("Expected an error")
- .into_inner();
+ let err = block_on_f01(coin.validate_fee(ValidateFeeArgs {
+ fee_tx: &tx,
+ expected_sender: &sender_pub,
+ fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
+ dex_fee: &DexFee::Standard(amount.into()),
+ min_block_number: 0,
+ uuid: &[],
+ }))
+ .expect_err("Expected an error")
+ .into_inner();
log!("error: {:?}", err);
match err {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("Expected 'transfer' contract call")),
@@ -462,18 +453,16 @@ fn test_wait_for_tx_spend_malicious() {
let payment_tx = hex::decode("01000000016601daa208531d20532c460d0c86b74a275f4a126bbffcf4eafdf33835af2859010000006a47304402205825657548bc1b5acf3f4bb2f89635a02b04f3228cd08126e63c5834888e7ac402207ca05fa0a629a31908a97a508e15076e925f8e621b155312b7526a6666b06a76012103693bff1b39e8b5a306810023c29b95397eb395530b106b1820ea235fd81d9ce9ffffffff020000000000000000e35403a0860101284cc49b415b2a8620ad3b72361a5aeba5dffd333fb64750089d935a1ec974d6a91ef4f24ff6ba0000000000000000000000000000000000000000000000000000000001312d00000000000000000000000000d362e096e873eb7907e205fadc6175c6fec7bc44000000000000000000000000783cf0be521101942da509846ea476e683aad8324b6b2e5444c2639cc0fb7bcea5afba3f3cdce239000000000000000000000000000000000000000000000000000000000000000000000000000000005f855c7614ba8b71f3544b93e2f681f996da519a98ace0107ac2203de400000000001976a9149e032d4b0090a11dc40fe6c47601499a35d55fbb88ac415d855f").unwrap();
let wait_until = now_sec() + 1;
let from_block = 696245;
- let found = coin
- .wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
- tx_bytes: &payment_tx,
- secret_hash: &[],
- wait_until,
- from_block,
- swap_contract_address: &coin.swap_contract_address(),
- check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
- watcher_reward: false,
- })
- .wait()
- .unwrap();
+ let found = block_on_f01(coin.wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
+ tx_bytes: &payment_tx,
+ secret_hash: &[],
+ wait_until,
+ from_block,
+ swap_contract_address: &coin.swap_contract_address(),
+ check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
+ watcher_reward: false,
+ }))
+ .unwrap();
let spend_tx = match found {
TransactionEnum::UtxoTx(tx) => tx,
@@ -731,7 +720,7 @@ fn test_get_trade_fee() {
// check if the coin's tx fee is expected
check_tx_fee(&coin, ActualTxFee::FixedPerKb(EXPECTED_TX_FEE as u64));
- let actual_trade_fee = coin.get_trade_fee().wait().unwrap();
+ let actual_trade_fee = block_on_f01(coin.get_trade_fee()).unwrap();
let expected_trade_fee_amount = big_decimal_from_sat(
2 * CONTRACT_CALL_GAS_FEE + SWAP_PAYMENT_GAS_FEE + EXPECTED_TX_FEE,
coin.utxo.decimals,
@@ -905,10 +894,8 @@ fn test_receiver_trade_preimage() {
// check if the coin's tx fee is expected
check_tx_fee(&coin, ActualTxFee::FixedPerKb(EXPECTED_TX_FEE as u64));
- let actual = coin
- .get_receiver_trade_fee(FeeApproxStage::WithoutApprox)
- .wait()
- .expect("!get_receiver_trade_fee");
+ let actual =
+ block_on_f01(coin.get_receiver_trade_fee(FeeApproxStage::WithoutApprox)).expect("!get_receiver_trade_fee");
// only one contract call should be included into the expected trade fee
let expected_receiver_fee = big_decimal_from_sat(CONTRACT_CALL_GAS_FEE + EXPECTED_TX_FEE, coin.utxo.decimals);
let expected = TradeFee {
@@ -935,7 +922,7 @@ fn test_taker_fee_tx_fee() {
spendable: BigDecimal::from(5u32),
unspendable: BigDecimal::from(0u32),
};
- assert_eq!(coin.my_balance().wait().expect("!my_balance"), expected_balance);
+ assert_eq!(block_on_f01(coin.my_balance()).expect("!my_balance"), expected_balance);
let dex_fee_amount = BigDecimal::from(5u32);
let actual = block_on(coin.get_fee_to_send_taker_fee(
diff --git a/mm2src/coins/solana/solana_tests.rs b/mm2src/coins/solana/solana_tests.rs
index fe2b104293..d4126f35c0 100644
--- a/mm2src/coins/solana/solana_tests.rs
+++ b/mm2src/coins/solana/solana_tests.rs
@@ -1,5 +1,5 @@
use base58::ToBase58;
-use common::{block_on, Future01CompatExt};
+use common::{block_on, block_on_f01, Future01CompatExt};
use rpc::v1::types::Bytes;
use solana_client::rpc_request::TokenAccountsFilter;
use solana_sdk::{bs58,
@@ -367,7 +367,7 @@ fn solana_coin_send_and_refund_maker_payment() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let tx = coin.send_maker_payment(args).wait().unwrap();
+ let tx = block_on_f01(coin.send_maker_payment(args)).unwrap();
log!("swap tx {:?}", tx);
let refund_args = RefundPaymentArgs {
@@ -415,7 +415,7 @@ fn solana_coin_send_and_spend_maker_payment() {
wait_for_confirmation_until: 0,
};
- let tx = coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let tx = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
log!("swap tx {:?}", tx);
let maker_pub = taker_pub;
diff --git a/mm2src/coins/tendermint/tendermint_coin.rs b/mm2src/coins/tendermint/tendermint_coin.rs
index bc5e12f6ff..9c7a1c1d96 100644
--- a/mm2src/coins/tendermint/tendermint_coin.rs
+++ b/mm2src/coins/tendermint/tendermint_coin.rs
@@ -3313,7 +3313,7 @@ fn parse_expected_sequence_number(e: &str) -> MmResult {
@@ -3725,18 +3723,16 @@ pub mod tendermint_coin_tests {
data: TxRaw::decode(random_transfer_tx_bytes.as_slice()).unwrap(),
});
- let error = coin
- .validate_fee(ValidateFeeArgs {
- fee_tx: &random_transfer_tx,
- expected_sender: &[],
- fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
- dex_fee: &DexFee::Standard(invalid_amount.clone()),
- min_block_number: 0,
- uuid: &[1; 16],
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(coin.validate_fee(ValidateFeeArgs {
+ fee_tx: &random_transfer_tx,
+ expected_sender: &[],
+ fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
+ dex_fee: &DexFee::Standard(invalid_amount.clone()),
+ min_block_number: 0,
+ uuid: &[1; 16],
+ }))
+ .unwrap_err()
+ .into_inner();
println!("{}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("sent to wrong address")),
@@ -3758,18 +3754,16 @@ pub mod tendermint_coin_tests {
data: TxRaw::decode(dex_fee_tx.encode_to_vec().as_slice()).unwrap(),
});
- let error = coin
- .validate_fee(ValidateFeeArgs {
- fee_tx: &dex_fee_tx,
- expected_sender: &[],
- fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
- dex_fee: &DexFee::Standard(invalid_amount),
- min_block_number: 0,
- uuid: &[1; 16],
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(coin.validate_fee(ValidateFeeArgs {
+ fee_tx: &dex_fee_tx,
+ expected_sender: &[],
+ fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
+ dex_fee: &DexFee::Standard(invalid_amount),
+ min_block_number: 0,
+ uuid: &[1; 16],
+ }))
+ .unwrap_err()
+ .into_inner();
println!("{}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("Invalid amount")),
@@ -3778,18 +3772,16 @@ pub mod tendermint_coin_tests {
let valid_amount: BigDecimal = "0.0001".parse().unwrap();
// valid amount but invalid sender
- let error = coin
- .validate_fee(ValidateFeeArgs {
- fee_tx: &dex_fee_tx,
- expected_sender: &DEX_FEE_ADDR_RAW_PUBKEY,
- fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
- dex_fee: &DexFee::Standard(valid_amount.clone().into()),
- min_block_number: 0,
- uuid: &[1; 16],
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(coin.validate_fee(ValidateFeeArgs {
+ fee_tx: &dex_fee_tx,
+ expected_sender: &DEX_FEE_ADDR_RAW_PUBKEY,
+ fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
+ dex_fee: &DexFee::Standard(valid_amount.clone().into()),
+ min_block_number: 0,
+ uuid: &[1; 16],
+ }))
+ .unwrap_err()
+ .into_inner();
println!("{}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("Invalid sender")),
@@ -3797,18 +3789,16 @@ pub mod tendermint_coin_tests {
}
// invalid memo
- let error = coin
- .validate_fee(ValidateFeeArgs {
- fee_tx: &dex_fee_tx,
- expected_sender: &pubkey,
- fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
- dex_fee: &DexFee::Standard(valid_amount.into()),
- min_block_number: 0,
- uuid: &[1; 16],
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(coin.validate_fee(ValidateFeeArgs {
+ fee_tx: &dex_fee_tx,
+ expected_sender: &pubkey,
+ fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
+ dex_fee: &DexFee::Standard(valid_amount.into()),
+ min_block_number: 0,
+ uuid: &[1; 16],
+ }))
+ .unwrap_err()
+ .into_inner();
println!("{}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("Invalid memo")),
diff --git a/mm2src/coins/utxo/slp.rs b/mm2src/coins/utxo/slp.rs
index c559449c22..503611445e 100644
--- a/mm2src/coins/utxo/slp.rs
+++ b/mm2src/coins/utxo/slp.rs
@@ -1945,6 +1945,7 @@ mod slp_tests {
use crate::utxo::GetUtxoListOps;
use crate::{utxo::bch::tbch_coin_for_test, TransactionErr};
use common::block_on;
+ use common::block_on_f01;
use mocktopus::mocking::{MockResult, Mockable};
use std::mem::discriminant;
@@ -2206,11 +2207,11 @@ mod slp_tests {
];
let tx_bytes_str = hex::encode(tx_bytes);
- let err = fusd.send_raw_tx(&tx_bytes_str).wait().unwrap_err();
+ let err = block_on_f01(fusd.send_raw_tx(&tx_bytes_str)).unwrap_err();
println!("{:?}", err);
assert!(err.contains("is not valid with reason outputs greater than inputs"));
- let err2 = fusd.send_raw_tx_bytes(tx_bytes).wait().unwrap_err();
+ let err2 = block_on_f01(fusd.send_raw_tx_bytes(tx_bytes)).unwrap_err();
println!("{:?}", err2);
assert!(err2.contains("is not valid with reason outputs greater than inputs"));
assert_eq!(err, err2);
diff --git a/mm2src/coins/utxo/utxo_tests.rs b/mm2src/coins/utxo/utxo_tests.rs
index 868f558f1f..9456361c64 100644
--- a/mm2src/coins/utxo/utxo_tests.rs
+++ b/mm2src/coins/utxo/utxo_tests.rs
@@ -34,13 +34,12 @@ use crate::{BlockHeightAndTime, CoinBalance, ConfirmPaymentInput, DexFee, Iguana
use crate::{WaitForHTLCTxSpendArgs, WithdrawFee};
use chain::{BlockHeader, BlockHeaderBits, OutPoint};
use common::executor::Timer;
-use common::{block_on, wait_until_sec, OrdRange, PagingOptionsEnum, DEX_FEE_ADDR_RAW_PUBKEY};
+use common::{block_on, block_on_f01, wait_until_sec, OrdRange, PagingOptionsEnum, DEX_FEE_ADDR_RAW_PUBKEY};
use crypto::{privkey::key_pair_from_seed, Bip44Chain, HDPathToAccount, RpcDerivationPath, Secp256k1Secret};
#[cfg(not(target_arch = "wasm32"))]
use db_common::sqlite::rusqlite::Connection;
use futures::channel::mpsc::channel;
-use futures::future::join_all;
-use futures::TryFutureExt;
+use futures::future::{join_all, Either, FutureExt, TryFutureExt};
use keys::prefixes::*;
use mm2_core::mm_ctx::MmCtxBuilder;
use mm2_number::bigdecimal::{BigDecimal, Signed};
@@ -438,18 +437,16 @@ fn test_wait_for_payment_spend_timeout_native() {
let wait_until = now_sec() - 1;
let from_block = 1000;
- assert!(coin
- .wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
- tx_bytes: &transaction,
- secret_hash: &[],
- wait_until,
- from_block,
- swap_contract_address: &None,
- check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
- watcher_reward: false
- })
- .wait()
- .is_err());
+ assert!(block_on_f01(coin.wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
+ tx_bytes: &transaction,
+ secret_hash: &[],
+ wait_until,
+ from_block,
+ swap_contract_address: &None,
+ check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
+ watcher_reward: false
+ }))
+ .is_err());
assert!(unsafe { OUTPUT_SPEND_CALLED });
}
@@ -486,18 +483,16 @@ fn test_wait_for_payment_spend_timeout_electrum() {
let wait_until = now_sec() - 1;
let from_block = 1000;
- assert!(coin
- .wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
- tx_bytes: &transaction,
- secret_hash: &[],
- wait_until,
- from_block,
- swap_contract_address: &None,
- check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
- watcher_reward: false
- })
- .wait()
- .is_err());
+ assert!(block_on_f01(coin.wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
+ tx_bytes: &transaction,
+ secret_hash: &[],
+ wait_until,
+ from_block,
+ swap_contract_address: &None,
+ check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
+ watcher_reward: false
+ }))
+ .is_err());
assert!(unsafe { OUTPUT_SPEND_CALLED });
}
@@ -575,19 +570,22 @@ fn test_search_for_swap_tx_spend_electrum_was_refunded() {
#[cfg(not(target_arch = "wasm32"))]
fn test_withdraw_impl_set_fixed_fee() {
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
let client = NativeClient(Arc::new(NativeClientImpl::default()));
@@ -613,7 +611,7 @@ fn test_withdraw_impl_set_fixed_fee() {
}
.into(),
);
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
assert_eq!(expected, tx_details.fee_details);
}
@@ -621,19 +619,22 @@ fn test_withdraw_impl_set_fixed_fee() {
#[cfg(not(target_arch = "wasm32"))]
fn test_withdraw_impl_sat_per_kb_fee() {
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
let client = NativeClient(Arc::new(NativeClientImpl::default()));
@@ -662,7 +663,7 @@ fn test_withdraw_impl_sat_per_kb_fee() {
}
.into(),
);
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
assert_eq!(expected, tx_details.fee_details);
}
@@ -670,19 +671,22 @@ fn test_withdraw_impl_sat_per_kb_fee() {
#[cfg(not(target_arch = "wasm32"))]
fn test_withdraw_impl_sat_per_kb_fee_amount_equal_to_max() {
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
let client = NativeClient(Arc::new(NativeClientImpl::default()));
@@ -701,7 +705,7 @@ fn test_withdraw_impl_sat_per_kb_fee_amount_equal_to_max() {
memo: None,
ibc_source_channel: None,
};
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
// The resulting transaction size might be 210 or 211 bytes depending on signature size
// MM2 always expects the worst case during fee calculation
// 0.1 * 211 / 1000 = 0.0211
@@ -721,19 +725,22 @@ fn test_withdraw_impl_sat_per_kb_fee_amount_equal_to_max() {
#[cfg(not(target_arch = "wasm32"))]
fn test_withdraw_impl_sat_per_kb_fee_amount_equal_to_max_dust_included_to_fee() {
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
let client = NativeClient(Arc::new(NativeClientImpl::default()));
@@ -752,7 +759,7 @@ fn test_withdraw_impl_sat_per_kb_fee_amount_equal_to_max_dust_included_to_fee()
memo: None,
ibc_source_channel: None,
};
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
// The resulting transaction size might be 210 or 211 bytes depending on signature size
// MM2 always expects the worst case during fee calculation
// 0.1 * 211 / 1000 = 0.0211
@@ -772,19 +779,22 @@ fn test_withdraw_impl_sat_per_kb_fee_amount_equal_to_max_dust_included_to_fee()
#[cfg(not(target_arch = "wasm32"))]
fn test_withdraw_impl_sat_per_kb_fee_amount_over_max() {
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
let client = NativeClient(Arc::new(NativeClientImpl::default()));
@@ -803,26 +813,29 @@ fn test_withdraw_impl_sat_per_kb_fee_amount_over_max() {
memo: None,
ibc_source_channel: None,
};
- coin.withdraw(withdraw_req).wait().unwrap_err();
+ block_on_f01(coin.withdraw(withdraw_req)).unwrap_err();
}
#[test]
#[cfg(not(target_arch = "wasm32"))]
fn test_withdraw_impl_sat_per_kb_fee_max() {
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
let client = NativeClient(Arc::new(NativeClientImpl::default()));
@@ -851,7 +864,7 @@ fn test_withdraw_impl_sat_per_kb_fee_max() {
}
.into(),
);
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
assert_eq!(expected, tx_details.fee_details);
}
@@ -866,20 +879,23 @@ fn test_withdraw_kmd_rewards_impl(
let verbose: RpcTransaction = json::from_str(verbose_serialized).unwrap();
let unspent_height = verbose.height;
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(move |coin: &UtxoStandardCoin, _| {
- let tx: UtxoTx = tx_hex.into();
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: tx.hash(),
- index: 0,
- },
- value: tx.outputs[0].value,
- height: unspent_height,
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let tx: UtxoTx = tx_hex.into();
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: tx.hash(),
+ index: 0,
+ },
+ value: tx.outputs[0].value,
+ height: unspent_height,
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
UtxoStandardCoin::get_current_mtp
.mock_safe(move |_fields| MockResult::Return(Box::pin(futures::future::ok(current_mtp))));
@@ -909,7 +925,7 @@ fn test_withdraw_kmd_rewards_impl(
coin: Some("KMD".into()),
amount: "0.00001".parse().unwrap(),
});
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
assert_eq!(tx_details.fee_details, Some(expected_fee));
let expected_rewards = expected_rewards.map(|amount| KmdRewardsDetails {
@@ -958,20 +974,23 @@ fn test_withdraw_rick_rewards_none() {
const TX_HEX: &str = "0400008085202f8901df8119c507aa61d32332cd246dbfeb3818a4f96e76492454c1fbba5aa097977e000000004847304402205a7e229ea6929c97fd6dde254c19e4eb890a90353249721701ae7a1c477d99c402206a8b7c5bf42b5095585731d6b4c589ce557f63c20aed69ff242eca22ecfcdc7a01feffffff02d04d1bffbc050000232102afdbba3e3c90db5f0f4064118f79cf308f926c68afd64ea7afc930975663e4c4ac402dd913000000001976a9143e17014eca06281ee600adffa34b4afb0922a22288ac2bdab86035a00e000000000000000000000000";
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(move |coin, _| {
- let tx: UtxoTx = TX_HEX.into();
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: tx.hash(),
- index: 0,
- },
- value: tx.outputs[0].value,
- height: Some(1431628),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let tx: UtxoTx = TX_HEX.into();
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: tx.hash(),
+ index: 0,
+ },
+ value: tx.outputs[0].value,
+ height: Some(1431628),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
let withdraw_req = WithdrawRequest {
@@ -988,7 +1007,7 @@ fn test_withdraw_rick_rewards_none() {
coin: Some(TEST_COIN_NAME.into()),
amount: "0.00001".parse().unwrap(),
});
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
assert_eq!(tx_details.fee_details, Some(expected_fee));
assert_eq!(tx_details.kmd_rewards, None);
}
@@ -1066,7 +1085,7 @@ fn test_electrum_rpc_client_error() {
let client = electrum_client_for_test(&["electrum1.cipig.net:10060"]);
let empty_hash = H256Json::default();
- let err = client.get_verbose_transaction(&empty_hash).wait().unwrap_err();
+ let err = block_on_f01(client.get_verbose_transaction(&empty_hash)).unwrap_err();
// use the static string instead because the actual error message cannot be obtain
// by serde_json serialization
@@ -1305,10 +1324,7 @@ fn test_get_median_time_past_from_electrum_kmd() {
"electrum3.cipig.net:10001",
]);
- let mtp = client
- .get_median_time_past(1773390, KMD_MTP_BLOCK_COUNT, CoinVariant::Standard)
- .wait()
- .unwrap();
+ let mtp = block_on_f01(client.get_median_time_past(1773390, KMD_MTP_BLOCK_COUNT, CoinVariant::Standard)).unwrap();
// the MTP is block time of 1773385 in this case
assert_eq!(1583159915, mtp);
}
@@ -1321,10 +1337,7 @@ fn test_get_median_time_past_from_electrum_btc() {
"electrum3.cipig.net:10000",
]);
- let mtp = client
- .get_median_time_past(632858, KMD_MTP_BLOCK_COUNT, CoinVariant::Standard)
- .wait()
- .unwrap();
+ let mtp = block_on_f01(client.get_median_time_past(632858, KMD_MTP_BLOCK_COUNT, CoinVariant::Standard)).unwrap();
assert_eq!(1591173041, mtp);
}
@@ -1348,10 +1361,7 @@ fn test_get_median_time_past_from_native_has_median_in_get_block() {
)
});
- let mtp = client
- .get_median_time_past(632858, KMD_MTP_BLOCK_COUNT, CoinVariant::Standard)
- .wait()
- .unwrap();
+ let mtp = block_on_f01(client.get_median_time_past(632858, KMD_MTP_BLOCK_COUNT, CoinVariant::Standard)).unwrap();
assert_eq!(1591173041, mtp);
}
@@ -1394,10 +1404,7 @@ fn test_get_median_time_past_from_native_does_not_have_median_in_get_block() {
MockResult::Return(Box::new(futures01::future::ok(block)))
});
- let mtp = client
- .get_median_time_past(632858, KMD_MTP_BLOCK_COUNT, CoinVariant::Standard)
- .wait()
- .unwrap();
+ let mtp = block_on_f01(client.get_median_time_past(632858, KMD_MTP_BLOCK_COUNT, CoinVariant::Standard)).unwrap();
assert_eq!(1591173041, mtp);
}
@@ -1597,13 +1604,11 @@ fn test_spam_rick() {
fn test_one_unavailable_electrum_proto_version() {
// check if the electrum-mona.bitbank.cc:50001 doesn't support the protocol version 1.4
let client = electrum_client_for_test(&["electrum-mona.bitbank.cc:50001"]);
- let result = client
- .server_version(
- "electrum-mona.bitbank.cc:50001",
- "AtomicDEX",
- &OrdRange::new(1.4, 1.4).unwrap(),
- )
- .wait();
+ let result = block_on_f01(client.server_version(
+ "electrum-mona.bitbank.cc:50001",
+ "AtomicDEX",
+ &OrdRange::new(1.4, 1.4).unwrap(),
+ ));
assert!(result
.err()
.unwrap()
@@ -1628,7 +1633,7 @@ fn test_one_unavailable_electrum_proto_version() {
block_on(async { Timer::sleep(0.5).await });
- assert!(coin.as_ref().rpc_client.get_block_count().wait().is_ok());
+ assert!(block_on_f01(coin.as_ref().rpc_client.get_block_count()).is_ok());
}
#[test]
@@ -1685,7 +1690,7 @@ fn test_qtum_add_delegation() {
address: address.to_string(),
fee: Some(10),
};
- let res = coin.add_delegation(request).wait().unwrap();
+ let res = block_on_f01(coin.add_delegation(request)).unwrap();
// Eligible for delegation
assert!(res.my_balance_change.is_negative());
assert_eq!(res.total_amount, res.spent_by_me);
@@ -1695,7 +1700,7 @@ fn test_qtum_add_delegation() {
address: "fake_address".to_string(),
fee: Some(10),
};
- let res = coin.add_delegation(request).wait();
+ let res = block_on_f01(coin.add_delegation(request));
// Wrong address
assert!(res.is_err());
}
@@ -1728,7 +1733,7 @@ fn test_qtum_add_delegation_on_already_delegating() {
address: address.to_string(),
fee: Some(10),
};
- let res = coin.add_delegation(request).wait();
+ let res = block_on_f01(coin.add_delegation(request));
// Already Delegating
assert!(res.is_err());
}
@@ -1754,7 +1759,7 @@ fn test_qtum_get_delegation_infos() {
keypair.private().secret,
))
.unwrap();
- let staking_infos = coin.get_delegation_infos().wait().unwrap();
+ let staking_infos = block_on_f01(coin.get_delegation_infos()).unwrap();
match staking_infos.staking_infos_details {
StakingInfosDetails::Qtum(staking_details) => {
assert!(staking_details.am_i_staking);
@@ -1784,49 +1789,49 @@ fn test_qtum_remove_delegation() {
keypair.private().secret,
))
.unwrap();
- let res = coin.remove_delegation().wait();
+ let res = block_on_f01(coin.remove_delegation());
assert!(res.is_ok());
}
#[test]
fn test_qtum_my_balance() {
QtumCoin::get_mature_unspent_ordered_list.mock_safe(move |coin, _address| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- // spendable balance (66.0)
- let mature = vec![
- UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ // spendable balance (66.0)
+ let mature = vec![
+ UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 5000000000,
+ height: Default::default(),
+ script: Vec::new().into(),
},
- value: 5000000000,
- height: Default::default(),
- script: Vec::new().into(),
- },
- UnspentInfo {
+ UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1600000000,
+ height: Default::default(),
+ script: Vec::new().into(),
+ },
+ ];
+ // unspendable (2.0)
+ let immature = vec![UnspentInfo {
outpoint: OutPoint {
hash: 1.into(),
index: 0,
},
- value: 1600000000,
+ value: 200000000,
height: Default::default(),
script: Vec::new().into(),
- },
- ];
- // unspendable (2.0)
- let immature = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 200000000,
- height: Default::default(),
- script: Vec::new().into(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((
- MatureUnspentList { mature, immature },
- cache,
- ))))
+ }];
+ Ok((MatureUnspentList { mature, immature }, cache))
+ };
+ MockResult::Return(fut.boxed())
});
let conf = json!({"coin":"tQTUM","rpcport":13889,"pubtype":120,"p2shtype":110});
@@ -1845,7 +1850,7 @@ fn test_qtum_my_balance() {
let params = UtxoActivationParams::from_legacy_req(&req).unwrap();
let coin = block_on(qtum_coin_with_priv_key(&ctx, "tQTUM", &conf, ¶ms, priv_key)).unwrap();
- let CoinBalance { spendable, unspendable } = coin.my_balance().wait().unwrap();
+ let CoinBalance { spendable, unspendable } = block_on_f01(coin.my_balance()).unwrap();
let expected_spendable = BigDecimal::from(66);
let expected_unspendable = BigDecimal::from(2);
assert_eq!(spendable, expected_spendable);
@@ -1881,7 +1886,7 @@ fn test_qtum_my_balance_with_check_utxo_maturity_false() {
let params = UtxoActivationParams::from_legacy_req(&req).unwrap();
let coin = block_on(qtum_coin_with_priv_key(&ctx, "tQTUM", &conf, ¶ms, priv_key)).unwrap();
- let CoinBalance { spendable, unspendable } = coin.my_balance().wait().unwrap();
+ let CoinBalance { spendable, unspendable } = block_on_f01(coin.my_balance()).unwrap();
let expected_spendable = BigDecimal::from(DISPLAY_BALANCE);
let expected_unspendable = BigDecimal::from(0);
assert_eq!(spendable, expected_spendable);
@@ -1899,7 +1904,7 @@ fn test_get_mature_unspent_ordered_map_from_cache_impl(
const TX_HASH: &str = "b43f9ed47f7b97d4766b6f1614136fa0c55b9a52c97342428333521fa13ad714";
let tx_hash: H256Json = hex::decode(TX_HASH).unwrap().as_slice().into();
let client = electrum_client_for_test(DOC_ELECTRUM_ADDRS);
- let mut verbose = client.get_verbose_transaction(&tx_hash).wait().unwrap();
+ let mut verbose = block_on_f01(client.get_verbose_transaction(&tx_hash)).unwrap();
verbose.confirmations = cached_confs;
verbose.height = cached_height;
@@ -2517,15 +2522,13 @@ fn test_find_output_spend_skips_conflicting_transactions() {
let tx: UtxoTx = "0400008085202f89027f57730fcbbc2c72fb18bcc3766a713044831a117bb1cade3ed88644864f7333020000006a47304402206e3737b2fcf078b61b16fa67340cc3e79c5d5e2dc9ffda09608371552a3887450220460a332aa1b8ad8f2de92d319666f70751078b221199951f80265b4f7cef8543012102d8c948c6af848c588517288168faa397d6ba3ea924596d03d1d84f224b5123c2ffffffff42b916a80430b80a77e114445b08cf120735447a524de10742fac8f6a9d4170f000000006a473044022004aa053edafb9d161ea8146e0c21ed1593aa6b9404dd44294bcdf920a1695fd902202365eac15dbcc5e9f83e2eed56a8f2f0e5aded36206f9c3fabc668fd4665fa2d012102d8c948c6af848c588517288168faa397d6ba3ea924596d03d1d84f224b5123c2ffffffff03547b16000000000017a9143e8ad0e2bf573d32cb0b3d3a304d9ebcd0c2023b870000000000000000166a144e2b3c0323ab3c2dc6f86dc5ec0729f11e42f56103970400000000001976a91450f4f098306f988d8843004689fae28c83ef16e888ac89c5925f000000000000000000000000000000".into();
let vout = 0;
let from_block = 0;
- let actual = client
- .find_output_spend(
- tx.hash(),
- &tx.outputs[vout].script_pubkey,
- vout,
- BlockHashOrHeight::Height(from_block),
- TxHashAlgo::DSHA256,
- )
- .wait();
+ let actual = block_on_f01(client.find_output_spend(
+ tx.hash(),
+ &tx.outputs[vout].script_pubkey,
+ vout,
+ BlockHashOrHeight::Height(from_block),
+ TxHashAlgo::DSHA256,
+ ));
assert_eq!(actual, Ok(None));
assert_eq!(unsafe { GET_RAW_TRANSACTION_BYTES_CALLED }, 1);
}
@@ -2609,7 +2612,7 @@ fn test_get_sender_trade_fee_dynamic_tx_fee() {
);
coin_fields.tx_fee = TxFee::Dynamic(EstimateFeeMethod::Standard);
let coin = utxo_coin_from_fields(coin_fields);
- let my_balance = coin.my_spendable_balance().wait().expect("!my_balance");
+ let my_balance = block_on_f01(coin.my_spendable_balance()).expect("!my_balance");
let expected_balance = BigDecimal::from_str("2.22222").expect("!BigDecimal::from_str");
assert_eq!(my_balance, expected_balance);
@@ -2657,7 +2660,9 @@ fn test_validate_fee_wrong_sender() {
min_block_number: 0,
uuid: &[],
};
- let error = coin.validate_fee(validate_fee_args).wait().unwrap_err().into_inner();
+ let error = block_on_f01(coin.validate_fee(validate_fee_args))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains(INVALID_SENDER_ERR_LOG)),
@@ -2682,7 +2687,9 @@ fn test_validate_fee_min_block() {
min_block_number: 278455,
uuid: &[],
};
- let error = coin.validate_fee(validate_fee_args).wait().unwrap_err().into_inner();
+ let error = block_on_f01(coin.validate_fee(validate_fee_args))
+ .unwrap_err()
+ .into_inner();
match error {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("confirmed before min_block")),
_ => panic!("Expected `WrongPaymentTx` early confirmation, found {:?}", error),
@@ -2711,7 +2718,7 @@ fn test_validate_fee_bch_70_bytes_signature() {
min_block_number: 0,
uuid: &[],
};
- coin.validate_fee(validate_fee_args).wait().unwrap();
+ block_on_f01(coin.validate_fee(validate_fee_args)).unwrap();
}
#[test]
@@ -2766,7 +2773,7 @@ fn firo_lelantus_tx() {
"electrumx02.firo.org:50001",
"electrumx03.firo.org:50001",
]);
- let _tx = electrum.get_verbose_transaction(&tx_hash).wait().unwrap();
+ let _tx = block_on_f01(electrum.get_verbose_transaction(&tx_hash)).unwrap();
}
#[test]
@@ -2903,9 +2910,7 @@ fn doge_mtp() {
"electrum2.cipig.net:10060",
"electrum3.cipig.net:10060",
]);
- let mtp = electrum
- .get_median_time_past(3631820, NonZeroU64::new(11).unwrap(), CoinVariant::Standard)
- .wait()
+ let mtp = block_on_f01(electrum.get_median_time_past(3631820, NonZeroU64::new(11).unwrap(), CoinVariant::Standard))
.unwrap();
assert_eq!(mtp, 1614849084);
}
@@ -2917,9 +2922,7 @@ fn firo_mtp() {
"electrumx02.firo.org:50001",
"electrumx03.firo.org:50001",
]);
- let mtp = electrum
- .get_median_time_past(356730, NonZeroU64::new(11).unwrap(), CoinVariant::Standard)
- .wait()
+ let mtp = block_on_f01(electrum.get_median_time_past(356730, NonZeroU64::new(11).unwrap(), CoinVariant::Standard))
.unwrap();
assert_eq!(mtp, 1616492629);
}
@@ -2927,9 +2930,7 @@ fn firo_mtp() {
#[test]
fn verus_mtp() {
let electrum = electrum_client_for_test(&["el0.verus.io:17485", "el1.verus.io:17485", "el2.verus.io:17485"]);
- let mtp = electrum
- .get_median_time_past(1480113, NonZeroU64::new(11).unwrap(), CoinVariant::Standard)
- .wait()
+ let mtp = block_on_f01(electrum.get_median_time_past(1480113, NonZeroU64::new(11).unwrap(), CoinVariant::Standard))
.unwrap();
assert_eq!(mtp, 1618579909);
}
@@ -2941,9 +2942,7 @@ fn sys_mtp() {
"electrum2.cipig.net:10064",
"electrum3.cipig.net:10064",
]);
- let mtp = electrum
- .get_median_time_past(1006678, NonZeroU64::new(11).unwrap(), CoinVariant::Standard)
- .wait()
+ let mtp = block_on_f01(electrum.get_median_time_past(1006678, NonZeroU64::new(11).unwrap(), CoinVariant::Standard))
.unwrap();
assert_eq!(mtp, 1620019628);
}
@@ -2955,9 +2954,7 @@ fn btc_mtp() {
"electrum2.cipig.net:10000",
"electrum3.cipig.net:10000",
]);
- let mtp = electrum
- .get_median_time_past(681659, NonZeroU64::new(11).unwrap(), CoinVariant::Standard)
- .wait()
+ let mtp = block_on_f01(electrum.get_median_time_past(681659, NonZeroU64::new(11).unwrap(), CoinVariant::Standard))
.unwrap();
assert_eq!(mtp, 1620019527);
}
@@ -2969,9 +2966,7 @@ fn rvn_mtp() {
"electrum2.cipig.net:10051",
"electrum3.cipig.net:10051",
]);
- let mtp = electrum
- .get_median_time_past(1968120, NonZeroU64::new(11).unwrap(), CoinVariant::Standard)
- .wait()
+ let mtp = block_on_f01(electrum.get_median_time_past(1968120, NonZeroU64::new(11).unwrap(), CoinVariant::Standard))
.unwrap();
assert_eq!(mtp, 1633946264);
}
@@ -2983,10 +2978,8 @@ fn qtum_mtp() {
"electrum2.cipig.net:10050",
"electrum3.cipig.net:10050",
]);
- let mtp = electrum
- .get_median_time_past(681659, NonZeroU64::new(11).unwrap(), CoinVariant::Qtum)
- .wait()
- .unwrap();
+ let mtp =
+ block_on_f01(electrum.get_median_time_past(681659, NonZeroU64::new(11).unwrap(), CoinVariant::Qtum)).unwrap();
assert_eq!(mtp, 1598854128);
}
@@ -2997,9 +2990,7 @@ fn zer_mtp() {
"electrum2.cipig.net:10065",
"electrum3.cipig.net:10065",
]);
- let mtp = electrum
- .get_median_time_past(1130915, NonZeroU64::new(11).unwrap(), CoinVariant::Standard)
- .wait()
+ let mtp = block_on_f01(electrum.get_median_time_past(1130915, NonZeroU64::new(11).unwrap(), CoinVariant::Standard))
.unwrap();
assert_eq!(mtp, 1623240214);
}
@@ -3196,7 +3187,7 @@ fn test_withdraw_to_p2pk_fails() {
};
assert!(matches!(
- coin.withdraw(withdraw_req).wait().unwrap_err().into_inner(),
+ block_on_f01(coin.withdraw(withdraw_req)).unwrap_err().into_inner(),
WithdrawError::InvalidAddress(..)
))
}
@@ -3209,19 +3200,22 @@ fn test_withdraw_to_p2pkh() {
let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
// Create a p2pkh address for the test coin
@@ -3249,7 +3243,7 @@ fn test_withdraw_to_p2pkh() {
memo: None,
ibc_source_channel: None,
};
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
let transaction: UtxoTx = deserialize(tx_details.tx.tx_hex().unwrap().as_slice()).unwrap();
let output_script: Script = transaction.outputs[0].script_pubkey.clone().into();
@@ -3266,19 +3260,22 @@ fn test_withdraw_to_p2sh() {
let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
// Create a p2sh address for the test coin
@@ -3306,7 +3303,7 @@ fn test_withdraw_to_p2sh() {
memo: None,
ibc_source_channel: None,
};
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
let transaction: UtxoTx = deserialize(tx_details.tx.tx_hex().unwrap().as_slice()).unwrap();
let output_script: Script = transaction.outputs[0].script_pubkey.clone().into();
@@ -3323,19 +3320,22 @@ fn test_withdraw_to_p2wpkh() {
let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, true);
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- script: coin
- .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
- .unwrap(),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ script: coin
+ .script_for_address(&coin.as_ref().derivation_method.unwrap_single_addr().await)
+ .unwrap(),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
// Create a p2wpkh address for the test coin
@@ -3363,7 +3363,7 @@ fn test_withdraw_to_p2wpkh() {
memo: None,
ibc_source_channel: None,
};
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
let transaction: UtxoTx = deserialize(tx_details.tx.tx_hex().unwrap().as_slice()).unwrap();
let output_script: Script = transaction.outputs[0].script_pubkey.clone().into();
@@ -3380,22 +3380,29 @@ fn test_withdraw_p2pk_balance() {
let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = vec![UnspentInfo {
- outpoint: OutPoint {
- hash: 1.into(),
- index: 0,
- },
- value: 1000000000,
- height: Default::default(),
- // Use a p2pk output script for this UTXO
- script: output_script_p2pk(
- &block_on(coin.as_ref().derivation_method.unwrap_single_addr())
- .pubkey()
- .unwrap(),
- ),
- }];
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = vec![UnspentInfo {
+ outpoint: OutPoint {
+ hash: 1.into(),
+ index: 0,
+ },
+ value: 1000000000,
+ height: Default::default(),
+ // Use a p2pk output script for this UTXO
+ script: output_script_p2pk(
+ &coin
+ .as_ref()
+ .derivation_method
+ .unwrap_single_addr()
+ .await
+ .pubkey()
+ .unwrap(),
+ ),
+ }];
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
// Create a dummy p2pkh address to withdraw the coins to.
@@ -3411,7 +3418,7 @@ fn test_withdraw_p2pk_balance() {
memo: None,
ibc_source_channel: None,
};
- let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+ let tx_details = block_on_f01(coin.withdraw(withdraw_req)).unwrap();
let transaction: UtxoTx = deserialize(tx_details.tx.tx_hex().unwrap().as_slice()).unwrap();
// The change should be in a p2pkh script.
@@ -3432,8 +3439,11 @@ fn test_utxo_standard_with_check_utxo_maturity_true() {
UtxoStandardCoin::get_mature_unspent_ordered_list.mock_safe(|coin, _| {
unsafe { GET_MATURE_UNSPENT_ORDERED_LIST_CALLED = true };
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- MockResult::Return(Box::pin(futures::future::ok((MatureUnspentList::default(), cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ Ok((MatureUnspentList::default(), cache))
+ };
+ MockResult::Return(fut.boxed())
});
let conf = json!({"coin":"RICK","asset":"RICK","rpcport":25435,"txversion":4,"overwintered":1,"mm2":1,"protocol":{"type":"UTXO"}});
@@ -3451,7 +3461,7 @@ fn test_utxo_standard_with_check_utxo_maturity_true() {
let address = Address::from_legacyaddress("R9o9xTocqr6CeEDGDH6mEYpwLoMz6jNjMW", &KMD_PREFIXES).unwrap();
// Don't use `block_on` here because it's used within a mock of [`GetUtxoListOps::get_mature_unspent_ordered_list`].
- coin.get_unspent_ordered_list(&address).compat().wait().unwrap();
+ block_on_f01(coin.get_unspent_ordered_list(&address).compat()).unwrap();
assert!(unsafe { GET_MATURE_UNSPENT_ORDERED_LIST_CALLED });
}
@@ -3464,9 +3474,11 @@ fn test_utxo_standard_without_check_utxo_maturity() {
UtxoStandardCoin::get_all_unspent_ordered_list.mock_safe(|coin, _| {
unsafe { GET_ALL_UNSPENT_ORDERED_LIST_CALLED = true };
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = Vec::new();
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ Ok((Vec::new(), cache))
+ };
+ MockResult::Return(fut.boxed())
});
UtxoStandardCoin::get_mature_unspent_ordered_list.mock_safe(|_, _| {
@@ -3487,7 +3499,7 @@ fn test_utxo_standard_without_check_utxo_maturity() {
let address = Address::from_legacyaddress("R9o9xTocqr6CeEDGDH6mEYpwLoMz6jNjMW", &KMD_PREFIXES).unwrap();
// Don't use `block_on` here because it's used within a mock of [`UtxoStandardCoin::get_all_unspent_ordered_list`].
- coin.get_unspent_ordered_list(&address).compat().wait().unwrap();
+ block_on_f01(coin.get_unspent_ordered_list(&address).compat()).unwrap();
assert!(unsafe { GET_ALL_UNSPENT_ORDERED_LIST_CALLED });
}
@@ -3500,8 +3512,11 @@ fn test_qtum_without_check_utxo_maturity() {
QtumCoin::get_mature_unspent_ordered_list.mock_safe(|coin, _| {
unsafe { GET_MATURE_UNSPENT_ORDERED_LIST_CALLED = true };
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- MockResult::Return(Box::pin(futures::future::ok((MatureUnspentList::default(), cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ Ok((MatureUnspentList::default(), cache))
+ };
+ MockResult::Return(fut.boxed())
});
let conf = json!({"coin":"tQTUM","rpcport":13889,"pubtype":120,"p2shtype":110});
@@ -3526,7 +3541,7 @@ fn test_qtum_without_check_utxo_maturity() {
)
.unwrap();
// Don't use `block_on` here because it's used within a mock of [`QtumCoin::get_mature_unspent_ordered_list`].
- coin.get_unspent_ordered_list(&address).compat().wait().unwrap();
+ block_on_f01(coin.get_unspent_ordered_list(&address).compat()).unwrap();
assert!(unsafe { GET_MATURE_UNSPENT_ORDERED_LIST_CALLED });
}
@@ -3604,9 +3619,12 @@ fn test_qtum_with_check_utxo_maturity_false() {
QtumCoin::get_all_unspent_ordered_list.mock_safe(|coin, _address| {
unsafe { GET_ALL_UNSPENT_ORDERED_LIST_CALLED = true };
- let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
- let unspents = Vec::new();
- MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+ let fut = async move {
+ let cache = coin.as_ref().recently_spent_outpoints.lock().await;
+ let unspents = Vec::new();
+ Ok((unspents, cache))
+ };
+ MockResult::Return(fut.boxed())
});
QtumCoin::get_mature_unspent_ordered_list.mock_safe(|_, _| {
panic!(
@@ -3637,7 +3655,7 @@ fn test_qtum_with_check_utxo_maturity_false() {
)
.unwrap();
// Don't use `block_on` here because it's used within a mock of [`QtumCoin::get_all_unspent_ordered_list`].
- coin.get_unspent_ordered_list(&address).compat().wait().unwrap();
+ block_on_f01(coin.get_unspent_ordered_list(&address).compat()).unwrap();
assert!(unsafe { GET_ALL_UNSPENT_ORDERED_LIST_CALLED });
}
@@ -4365,7 +4383,9 @@ fn test_for_non_existent_tx_hex_utxo_electrum() {
wait_until: timeout,
check_every: 1,
};
- let actual = coin.wait_for_confirmations(confirm_payment_input).wait().err().unwrap();
+ let actual = block_on_f01(coin.wait_for_confirmations(confirm_payment_input))
+ .err()
+ .unwrap();
assert!(actual.contains(
"Tx d342ff9da528a2e262bddf2b6f9a27d1beb7aeb03f0fc8d9eac2987266447e44 was not found on chain after 10 tries"
));
@@ -4408,10 +4428,7 @@ fn test_native_display_balances() {
Address::from_legacyaddress("RJeDDtDRtKUoL8BCKdH7TNCHqUKr7kQRsi", &KMD_PREFIXES).unwrap(),
Address::from_legacyaddress("RQHn9VPHBqNjYwyKfJbZCiaxVrWPKGQjeF", &KMD_PREFIXES).unwrap(),
];
- let actual = rpc_client
- .display_balances(addresses, TEST_COIN_DECIMALS)
- .wait()
- .unwrap();
+ let actual = block_on_f01(rpc_client.display_balances(addresses, TEST_COIN_DECIMALS)).unwrap();
let expected: Vec<(Address, BigDecimal)> = vec![
(
@@ -4549,7 +4566,6 @@ fn test_utxo_validate_valid_and_invalid_pubkey() {
#[test]
fn test_block_header_utxo_loop() {
use crate::utxo::utxo_builder::{block_header_utxo_loop, BlockHeaderUtxoLoopExtraArgs};
- use futures::future::{Either, FutureExt};
use keys::hash::H256 as H256Json;
static mut CURRENT_BLOCK_COUNT: u64 = 13;
diff --git a/mm2src/coins/z_coin/storage/walletdb/wasm/mod.rs b/mm2src/coins/z_coin/storage/walletdb/wasm/mod.rs
index 907a007c55..4c68fec22c 100644
--- a/mm2src/coins/z_coin/storage/walletdb/wasm/mod.rs
+++ b/mm2src/coins/z_coin/storage/walletdb/wasm/mod.rs
@@ -253,7 +253,12 @@ mod wasm_test {
// scan the cache
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None,
+ )
.await
.unwrap();
@@ -293,7 +298,12 @@ mod wasm_test {
// Scan the cache again
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None,
+ )
.await
.unwrap();
@@ -347,7 +357,12 @@ mod wasm_test {
// Scan the cache again
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None,
+ )
.await
.unwrap();
@@ -436,7 +451,12 @@ mod wasm_test {
// Scan the cache again
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None,
+ )
.await
.unwrap();
@@ -520,7 +540,12 @@ mod wasm_test {
// Scan the cache
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None,
+ )
.await
.unwrap();
@@ -545,7 +570,12 @@ mod wasm_test {
// Scan the cache again
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None,
+ )
.await
.unwrap();
@@ -579,7 +609,12 @@ mod wasm_test {
// Scan cache
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None,
+ )
.await
.unwrap();
@@ -592,7 +627,12 @@ mod wasm_test {
// Scan the cache again
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
let scan = blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None,
+ )
.await
.unwrap_err();
match scan.get_inner() {
@@ -611,7 +651,12 @@ mod wasm_test {
blockdb.insert_block(cb2.height as u32, cb2_bytes).await.unwrap();
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
assert!(blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None
+ )
.await
.is_ok());
@@ -650,7 +695,12 @@ mod wasm_test {
// Scan the cache
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
assert!(blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None
+ )
.await
.is_ok());
@@ -666,7 +716,12 @@ mod wasm_test {
// Scan the cache again
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
assert!(blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None
+ )
.await
.is_ok());
@@ -703,7 +758,12 @@ mod wasm_test {
// Scan the cache
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
assert!(blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None
+ )
.await
.is_ok());
@@ -728,7 +788,12 @@ mod wasm_test {
// Scan the cache again
let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
let scan = blockdb
- .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ .process_blocks_with_mode(
+ consensus_params.clone(),
+ BlockProcessingMode::Scan(scan, None),
+ None,
+ None,
+ )
.await;
assert!(scan.is_ok());
@@ -767,7 +832,7 @@ mod wasm_test {
// // Scan the cache
// let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
// assert!(blockdb
- // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan, None), None, None)
// .await
// .is_ok());
//
@@ -787,7 +852,7 @@ mod wasm_test {
// // Scan the cache
// let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
// assert!(blockdb
- // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan, None), None, None)
// .await
// .is_ok());
//
@@ -832,7 +897,7 @@ mod wasm_test {
// // Scan the cache
// let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
// assert!(blockdb
- // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan, None), None, None)
// .await
// .is_ok());
//
@@ -863,7 +928,7 @@ mod wasm_test {
// // Scan the cache
// let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
// assert!(blockdb
- // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan, None), None, None)
// .await
// .is_ok());
//
@@ -1033,7 +1098,7 @@ mod wasm_test {
// // Scan the cache
// let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
// blockdb
- // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan, None), None, None)
// .await
// .unwrap();
// assert_eq!(walletdb.get_balance(AccountId(0)).await.unwrap(), value);
@@ -1090,7 +1155,7 @@ mod wasm_test {
// // Scan the cache
// let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
// blockdb
- // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan, None), None, None)
// .await
// .unwrap();
//
@@ -1126,7 +1191,7 @@ mod wasm_test {
// // Scan the cache
// let scan = DataConnStmtCacheWrapper::new(DataConnStmtCacheWasm(walletdb.clone()));
// blockdb
- // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan), None, None)
+ // .process_blocks_with_mode(consensus_params.clone(), BlockProcessingMode::Scan(scan, None), None, None)
// .await
// .unwrap();
//
diff --git a/mm2src/coins/z_coin/z_coin_native_tests.rs b/mm2src/coins/z_coin/z_coin_native_tests.rs
index 9e4358727d..790f42818f 100644
--- a/mm2src/coins/z_coin/z_coin_native_tests.rs
+++ b/mm2src/coins/z_coin/z_coin_native_tests.rs
@@ -1,14 +1,13 @@
use bitcrypto::dhash160;
-use common::{block_on, now_sec};
+use common::{block_on, block_on_f01, now_sec};
use mm2_core::mm_ctx::MmCtxBuilder;
use mm2_test_helpers::for_tests::zombie_conf;
use std::path::PathBuf;
use std::time::Duration;
use zcash_client_backend::encoding::decode_extended_spending_key;
-use super::{z_coin_from_conf_and_params_with_z_key, z_mainnet_constants, Future, PrivKeyBuildPolicy,
- RefundPaymentArgs, SendPaymentArgs, SpendPaymentArgs, SwapOps, ValidateFeeArgs, ValidatePaymentError,
- ZTransaction};
+use super::{z_coin_from_conf_and_params_with_z_key, z_mainnet_constants, PrivKeyBuildPolicy, RefundPaymentArgs,
+ SendPaymentArgs, SpendPaymentArgs, SwapOps, ValidateFeeArgs, ValidatePaymentError, ZTransaction};
use crate::z_coin::{z_htlc::z_send_dex_fee, ZcoinActivationParams, ZcoinRpcMode};
use crate::DexFee;
use crate::{CoinProtocol, SwapTxTypeWithSecretHash};
@@ -55,7 +54,7 @@ fn zombie_coin_send_and_refund_maker_payment() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let tx = coin.send_maker_payment(args).wait().unwrap();
+ let tx = block_on_f01(coin.send_maker_payment(args)).unwrap();
log!("swap tx {}", hex::encode(tx.tx_hash_as_bytes().0));
let refund_args = RefundPaymentArgs {
@@ -116,7 +115,7 @@ fn zombie_coin_send_and_spend_maker_payment() {
wait_for_confirmation_until: 0,
};
- let tx = coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let tx = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
log!("swap tx {}", hex::encode(tx.tx_hash_as_bytes().0));
let maker_pub = taker_pub;
@@ -234,7 +233,9 @@ fn zombie_coin_validate_dex_fee() {
uuid: &[1; 16],
};
// Invalid amount should return an error
- let err = coin.validate_fee(validate_fee_args).wait().unwrap_err().into_inner();
+ let err = block_on_f01(coin.validate_fee(validate_fee_args))
+ .unwrap_err()
+ .into_inner();
match err {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("Dex fee has invalid amount")),
_ => panic!("Expected `WrongPaymentTx`: {:?}", err),
@@ -249,7 +250,9 @@ fn zombie_coin_validate_dex_fee() {
min_block_number: 12000,
uuid: &[2; 16],
};
- let err = coin.validate_fee(validate_fee_args).wait().unwrap_err().into_inner();
+ let err = block_on_f01(coin.validate_fee(validate_fee_args))
+ .unwrap_err()
+ .into_inner();
match err {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("Dex fee has invalid memo")),
_ => panic!("Expected `WrongPaymentTx`: {:?}", err),
@@ -264,7 +267,9 @@ fn zombie_coin_validate_dex_fee() {
min_block_number: 14000,
uuid: &[1; 16],
};
- let err = coin.validate_fee(validate_fee_args).wait().unwrap_err().into_inner();
+ let err = block_on_f01(coin.validate_fee(validate_fee_args))
+ .unwrap_err()
+ .into_inner();
match err {
ValidatePaymentError::WrongPaymentTx(err) => assert!(err.contains("confirmed before min block")),
_ => panic!("Expected `WrongPaymentTx`: {:?}", err),
@@ -279,7 +284,7 @@ fn zombie_coin_validate_dex_fee() {
min_block_number: 12000,
uuid: &[1; 16],
};
- coin.validate_fee(validate_fee_args).wait().unwrap();
+ block_on_f01(coin.validate_fee(validate_fee_args)).unwrap();
}
fn default_zcoin_activation_params() -> ZcoinActivationParams {
diff --git a/mm2src/common/common.rs b/mm2src/common/common.rs
index 13ec32bcb9..8eac389e58 100644
--- a/mm2src/common/common.rs
+++ b/mm2src/common/common.rs
@@ -518,19 +518,6 @@ pub fn set_panic_hook() {
}))
}
-/// Simulates the panic-in-panic crash.
-pub fn double_panic_crash() {
- struct Panicker;
- impl Drop for Panicker {
- fn drop(&mut self) { panic!("panic in drop") }
- }
- let panicker = Panicker;
- if 1 < 2 {
- panic!("first panic")
- }
- drop(panicker) // Delays the drop.
-}
-
/// RPC response, returned by the RPC handlers.
/// NB: By default the future is executed on the shared asynchronous reactor (`CORE`),
/// the handler is responsible for spawning the future on another reactor if it doesn't fit the `CORE` well.
@@ -634,7 +621,20 @@ pub fn var(name: &str) -> Result {
#[cfg(target_arch = "wasm32")]
pub fn var(_name: &str) -> Result { ERR!("Environment variable not supported in WASM") }
+/// Runs the given future on MM2's executor and waits for the result.
+///
+/// This is compatible with futures 0.1.
+pub fn block_on_f01(f: F) -> Result
+where
+ F: Future,
+{
+ block_on(f.compat())
+}
+
#[cfg(not(target_arch = "wasm32"))]
+/// Runs the given future on MM2's executor and waits for the result.
+///
+/// This is compatible with futures 0.3.
pub fn block_on(f: F) -> F::Output
where
F: Future03,
diff --git a/mm2src/mm2_bin_lib/src/lib.rs b/mm2src/mm2_bin_lib/src/lib.rs
index 81c532419f..c78233e64a 100644
--- a/mm2src/mm2_bin_lib/src/lib.rs
+++ b/mm2src/mm2_bin_lib/src/lib.rs
@@ -99,5 +99,5 @@ fn prepare_for_mm2_stop() -> PrepareForStopResult {
async fn finalize_mm2_stop(ctx: MmArc) {
dispatch_lp_event(ctx.clone(), StopCtxEvent.into()).await;
- let _ = ctx.stop();
+ let _ = ctx.stop().await;
}
diff --git a/mm2src/mm2_core/src/lib.rs b/mm2src/mm2_core/src/lib.rs
index 62e4bef09c..88b0fd5c81 100644
--- a/mm2src/mm2_core/src/lib.rs
+++ b/mm2src/mm2_core/src/lib.rs
@@ -1,10 +1,11 @@
-use derive_more::Display;
-use rand::{thread_rng, Rng};
+#[cfg(target_arch = "wasm32")] use derive_more::Display;
+#[cfg(target_arch = "wasm32")] use rand::{thread_rng, Rng};
pub mod data_asker;
pub mod event_dispatcher;
pub mod mm_ctx;
+#[cfg(target_arch = "wasm32")]
#[derive(Clone, Copy, Display, PartialEq, Default)]
pub enum DbNamespaceId {
#[display(fmt = "MAIN")]
@@ -14,9 +15,13 @@ pub enum DbNamespaceId {
Test(u64),
}
+#[cfg(target_arch = "wasm32")]
impl DbNamespaceId {
pub fn for_test() -> DbNamespaceId {
let mut rng = thread_rng();
DbNamespaceId::Test(rng.gen())
}
+
+ #[inline(always)]
+ pub fn for_test_with_id(id: u64) -> DbNamespaceId { DbNamespaceId::Test(id) }
}
diff --git a/mm2src/mm2_core/src/mm_ctx.rs b/mm2src/mm2_core/src/mm_ctx.rs
index ec7ceb036a..c61b4e1aba 100644
--- a/mm2src/mm2_core/src/mm_ctx.rs
+++ b/mm2src/mm2_core/src/mm_ctx.rs
@@ -290,7 +290,6 @@ impl MmCtx {
/// Returns the path to the MM databases root.
#[cfg(not(target_arch = "wasm32"))]
pub fn db_root(&self) -> PathBuf { path_to_db_root(self.conf["dbdir"].as_str()) }
-
#[cfg(not(target_arch = "wasm32"))]
pub fn wallet_file_path(&self, wallet_name: &str) -> PathBuf {
self.db_root().join(wallet_name.to_string() + ".dat")
@@ -503,7 +502,10 @@ lazy_static! {
impl MmArc {
pub fn new(ctx: MmCtx) -> MmArc { MmArc(SharedRc::new(ctx)) }
- pub fn stop(&self) -> Result<(), String> {
+ pub async fn stop(&self) -> Result<(), String> {
+ #[cfg(not(target_arch = "wasm32"))]
+ try_s!(self.close_async_connection().await);
+
try_s!(self.stop.pin(true));
// Notify shutdown listeners.
@@ -517,6 +519,16 @@ impl MmArc {
Ok(())
}
+ #[cfg(not(target_arch = "wasm32"))]
+ async fn close_async_connection(&self) -> Result<(), db_common::async_sql_conn::AsyncConnError> {
+ if let Some(async_conn) = self.async_sqlite_connection.as_option() {
+ let mut conn = async_conn.lock().await;
+ conn.close().await?;
+ }
+
+ Ok(())
+ }
+
#[cfg(feature = "track-ctx-pointer")]
fn track_ctx_pointer(&self) {
let ctx_weak = self.weak();
@@ -740,6 +752,12 @@ impl MmCtxBuilder {
self
}
+ #[cfg(target_arch = "wasm32")]
+ pub fn with_test_db_namespace_with_id(mut self, id: u64) -> Self {
+ self.db_namespace = DbNamespaceId::for_test_with_id(id);
+ self
+ }
+
pub fn into_mm_arc(self) -> MmArc {
// NB: We avoid recreating LogState
// in order not to interfere with the integration tests checking LogState drop on shutdown.
diff --git a/mm2src/mm2_err_handle/src/map_to_mm_fut.rs b/mm2src/mm2_err_handle/src/map_to_mm_fut.rs
index 01de1b7d7e..0cfeb9cf13 100644
--- a/mm2src/mm2_err_handle/src/map_to_mm_fut.rs
+++ b/mm2src/mm2_err_handle/src/map_to_mm_fut.rs
@@ -21,7 +21,7 @@ where
///
/// ```rust
/// let fut = futures01::future::err("An error".to_owned());
- /// let mapped_res: Result<(), MmError> = fut.map_to_mm_fut(|e| e.len()).wait();
+ /// let mapped_res: Result<(), MmError> = block_on_f01(fut.map_to_mm_fut(|e| e.len()));
/// ```
#[track_caller]
fn map_to_mm_fut(self, f: F) -> MapToMmFuture<'a, T, E1, E2>
diff --git a/mm2src/mm2_err_handle/src/mm_error.rs b/mm2src/mm2_err_handle/src/mm_error.rs
index 56e7f29f50..1ea7bf1555 100644
--- a/mm2src/mm2_err_handle/src/mm_error.rs
+++ b/mm2src/mm2_err_handle/src/mm_error.rs
@@ -332,6 +332,7 @@ impl FormattedTrace for Vec {
mod tests {
use super::*;
use crate::prelude::*;
+ use common::block_on_f01;
use futures01::Future;
use ser_error_derive::SerializeErrorType;
use serde_json::{self as json, json};
@@ -425,10 +426,8 @@ mod tests {
}
let into_mm_line = line!() + 2;
- let mm_err = generate_error("An error")
- .map_to_mm_fut(|error| error.len())
- .wait()
- .expect_err("Expected an error");
+ let mm_err =
+ block_on_f01(generate_error("An error").map_to_mm_fut(|error| error.len())).expect_err("Expected an error");
assert_eq!(mm_err.etype, 8);
assert_eq!(mm_err.trace, vec![TraceLocation::new("mm_error", into_mm_line)]);
}
diff --git a/mm2src/mm2_io/src/fs.rs b/mm2src/mm2_io/src/fs.rs
index 94a323c0b8..489b3bad8b 100644
--- a/mm2src/mm2_io/src/fs.rs
+++ b/mm2src/mm2_io/src/fs.rs
@@ -192,19 +192,52 @@ where
json::from_slice(&content).map_to_mm(FsJsonError::Deserializing)
}
-/// Read the `dir_path` entries trying to deserialize each as the `T` type.
+async fn filter_files_by_extension(dir_path: &Path, extension: &str) -> IoResult> {
+ let ext = Some(OsStr::new(extension).to_ascii_lowercase());
+ let entries = read_dir_async(dir_path)
+ .await?
+ .into_iter()
+ .filter(|path| path.extension().map(|ext| ext.to_ascii_lowercase()) == ext)
+ .collect();
+ Ok(entries)
+}
+
+/// Helper function to extract file names or stems based on the provided extraction function.
+fn extract_file_identifiers<'a, F>(entries: Vec, extractor: F) -> impl Iterator- + 'a
+where
+ F: Fn(&Path) -> Option<&OsStr> + 'a,
+{
+ entries
+ .into_iter()
+ .filter_map(move |path| extractor(&path).and_then(OsStr::to_str).map(ToOwned::to_owned))
+}
+
+/// Lists files by the specified extension from the given directory path.
+/// If include_extension is true, returns full file names; otherwise, returns file stems.
+pub async fn list_files_by_extension(
+ dir_path: &Path,
+ extension: &str,
+ include_extension: bool,
+) -> IoResult> {
+ let entries = filter_files_by_extension(dir_path, extension).await?;
+ let extractor = if include_extension {
+ Path::file_name
+ } else {
+ Path::file_stem
+ };
+ Ok(extract_file_identifiers(entries, extractor))
+}
+
+/// Read the `dir_path` entries trying to deserialize each as the `T` type,
+/// filtering by the specified extension.
/// Please note that files that couldn't be deserialized are skipped.
-pub async fn read_dir_json(dir_path: &Path) -> FsJsonResult>
+pub async fn read_files_with_extension(dir_path: &Path, extension: &str) -> FsJsonResult>
where
T: DeserializeOwned,
{
- let json_ext = Some(OsStr::new("json"));
- let entries: Vec<_> = read_dir_async(dir_path)
+ let entries = filter_files_by_extension(dir_path, extension)
.await
- .mm_err(FsJsonError::IoReading)?
- .into_iter()
- .filter(|path| path.extension() == json_ext)
- .collect();
+ .mm_err(FsJsonError::IoReading)?;
let type_name = std::any::type_name::();
let mut result = Vec::new();
@@ -233,6 +266,16 @@ where
Ok(result)
}
+/// Read the `dir_path` entries trying to deserialize each as the `T` type from JSON files.
+/// Please note that files that couldn't be deserialized are skipped.
+#[inline(always)]
+pub async fn read_dir_json(dir_path: &Path) -> FsJsonResult>
+where
+ T: DeserializeOwned,
+{
+ read_files_with_extension(dir_path, "json").await
+}
+
pub async fn write_json(t: &T, path: &Path, use_tmp_file: bool) -> FsJsonResult<()>
where
T: Serialize,
diff --git a/mm2src/mm2_main/Cargo.toml b/mm2src/mm2_main/Cargo.toml
index 60c3e9aa62..8f84ebb90a 100644
--- a/mm2src/mm2_main/Cargo.toml
+++ b/mm2src/mm2_main/Cargo.toml
@@ -77,9 +77,6 @@ primitives = { path = "../mm2_bitcoin/primitives" }
prost = "0.11"
rand = { version = "0.7", features = ["std", "small_rng"] }
rand6 = { version = "0.6", package = "rand" }
-# TODO: Reduce the size of regex by disabling the features we don't use.
-# cf. https://github.com/rust-lang/regex/issues/583
-regex = "1"
rmp-serde = "0.14.3"
rpc = { path = "../mm2_bitcoin/rpc" }
rpc_task = { path = "../rpc_task" }
@@ -116,7 +113,7 @@ hyper = { version = "0.14.26", features = ["client", "http2", "server", "tcp"] }
rcgen = "0.10"
rustls = { version = "0.21", default-features = false }
rustls-pemfile = "1.0.2"
-tokio = { version = "1.20", features = ["io-util", "rt-multi-thread", "net"] }
+tokio = { version = "1.20", features = ["io-util", "rt-multi-thread", "net", "signal"] }
[target.'cfg(windows)'.dependencies]
winapi = "0.3"
diff --git a/mm2src/mm2_main/src/lp_wallet.rs b/mm2src/mm2_main/src/lp_wallet.rs
index 19ac357cab..559821a26a 100644
--- a/mm2src/mm2_main/src/lp_wallet.rs
+++ b/mm2src/mm2_main/src/lp_wallet.rs
@@ -2,23 +2,24 @@ use common::HttpStatusCode;
use crypto::{decrypt_mnemonic, encrypt_mnemonic, generate_mnemonic, CryptoCtx, CryptoInitError, EncryptedData,
MnemonicError};
use http::StatusCode;
+use itertools::Itertools;
use mm2_core::mm_ctx::MmArc;
use mm2_err_handle::prelude::*;
use serde::de::DeserializeOwned;
-use serde_json::{self as json};
+use serde_json::{self as json, Value as Json};
cfg_wasm32! {
use crate::lp_wallet::mnemonics_wasm_db::{WalletsDb, WalletsDBError};
use mm2_core::mm_ctx::from_ctx;
use mm2_db::indexed_db::{ConstructibleDb, DbLocked, InitDbResult};
- use mnemonics_wasm_db::{read_encrypted_passphrase_if_available, save_encrypted_passphrase};
+ use mnemonics_wasm_db::{read_all_wallet_names, read_encrypted_passphrase_if_available, save_encrypted_passphrase};
use std::sync::Arc;
type WalletsDbLocked<'a> = DbLocked<'a, WalletsDb>;
}
cfg_native! {
- use mnemonics_storage::{read_encrypted_passphrase_if_available, save_encrypted_passphrase, WalletsStorageError};
+ use mnemonics_storage::{read_all_wallet_names, read_encrypted_passphrase_if_available, save_encrypted_passphrase, WalletsStorageError};
}
#[cfg(not(target_arch = "wasm32"))] mod mnemonics_storage;
@@ -499,3 +500,53 @@ pub async fn get_mnemonic_rpc(ctx: MmArc, req: GetMnemonicRequest) -> MmResult,
+ activated_wallet: Option,
+}
+
+#[derive(Debug, Display, Serialize, SerializeErrorType)]
+#[serde(tag = "error_type", content = "error_data")]
+pub enum GetWalletsError {
+ #[display(fmt = "Wallets storage error: {}", _0)]
+ WalletsStorageError(String),
+ #[display(fmt = "Internal error: {}", _0)]
+ Internal(String),
+}
+
+impl HttpStatusCode for GetWalletsError {
+ fn status_code(&self) -> StatusCode {
+ match self {
+ GetWalletsError::WalletsStorageError(_) | GetWalletsError::Internal(_) => StatusCode::INTERNAL_SERVER_ERROR,
+ }
+ }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl From for GetWalletsError {
+ fn from(e: WalletsStorageError) -> Self { GetWalletsError::WalletsStorageError(e.to_string()) }
+}
+
+#[cfg(target_arch = "wasm32")]
+impl From for GetWalletsError {
+ fn from(e: WalletsDBError) -> Self { GetWalletsError::WalletsStorageError(e.to_string()) }
+}
+
+/// Retrieves all created wallets and the currently activated wallet.
+pub async fn get_wallet_names_rpc(ctx: MmArc, _req: Json) -> MmResult {
+ // We want to return wallet names in the same order for both native and wasm32 targets.
+ let wallets = read_all_wallet_names(&ctx).await?.sorted().collect();
+ // Note: `ok_or` is used here on `Constructible>` to handle the case where the wallet name is not set.
+ // `wallet_name` can be `None` in the case of no-login mode.
+ let activated_wallet = ctx.wallet_name.ok_or(GetWalletsError::Internal(
+ "`wallet_name` not initialized yet!".to_string(),
+ ))?;
+
+ Ok(GetWalletNamesResponse {
+ wallet_names: wallets,
+ activated_wallet: activated_wallet.clone(),
+ })
+}
diff --git a/mm2src/mm2_main/src/lp_wallet/mnemonics_storage.rs b/mm2src/mm2_main/src/lp_wallet/mnemonics_storage.rs
index 3cf40e61fb..c873b2d5ff 100644
--- a/mm2src/mm2_main/src/lp_wallet/mnemonics_storage.rs
+++ b/mm2src/mm2_main/src/lp_wallet/mnemonics_storage.rs
@@ -1,7 +1,7 @@
use crypto::EncryptedData;
use mm2_core::mm_ctx::MmArc;
use mm2_err_handle::prelude::*;
-use mm2_io::fs::ensure_file_is_writable;
+use mm2_io::fs::{ensure_file_is_writable, list_files_by_extension};
type WalletsStorageResult = Result>;
@@ -61,3 +61,10 @@ pub(super) async fn read_encrypted_passphrase_if_available(ctx: &MmArc) -> Walle
))
})
}
+
+pub(super) async fn read_all_wallet_names(ctx: &MmArc) -> WalletsStorageResult> {
+ let wallet_names = list_files_by_extension(&ctx.db_root(), "dat", false)
+ .await
+ .mm_err(|e| WalletsStorageError::FsReadError(format!("Error reading wallets directory: {}", e)))?;
+ Ok(wallet_names)
+}
diff --git a/mm2src/mm2_main/src/lp_wallet/mnemonics_wasm_db.rs b/mm2src/mm2_main/src/lp_wallet/mnemonics_wasm_db.rs
index 40daa62029..a815bfcca1 100644
--- a/mm2src/mm2_main/src/lp_wallet/mnemonics_wasm_db.rs
+++ b/mm2src/mm2_main/src/lp_wallet/mnemonics_wasm_db.rs
@@ -144,3 +144,16 @@ pub(super) async fn read_encrypted_passphrase_if_available(ctx: &MmArc) -> Walle
})
.transpose()
}
+
+pub(super) async fn read_all_wallet_names(ctx: &MmArc) -> WalletsDBResult> {
+ let wallets_ctx = WalletsContext::from_ctx(ctx).map_to_mm(WalletsDBError::Internal)?;
+
+ let db = wallets_ctx.wallets_db().await?;
+ let transaction = db.transaction().await?;
+ let table = transaction.table::().await?;
+
+ let all_items = table.get_all_items().await?;
+ let wallet_names = all_items.into_iter().map(|(_, item)| item.wallet_name);
+
+ Ok(wallet_names)
+}
diff --git a/mm2src/mm2_main/src/mm2.rs b/mm2src/mm2_main/src/mm2.rs
index 7dcc5572cb..734e71becf 100644
--- a/mm2src/mm2_main/src/mm2.rs
+++ b/mm2src/mm2_main/src/mm2.rs
@@ -42,7 +42,7 @@
#[cfg(not(target_arch = "wasm32"))] use common::block_on;
use common::crash_reports::init_crash_reports;
-use common::double_panic_crash;
+use common::log;
use common::log::LogLevel;
use common::password_policy::password_policy;
use mm2_core::mm_ctx::MmCtxBuilder;
@@ -54,7 +54,6 @@ use lp_swap::PAYMENT_LOCKTIME;
use std::sync::atomic::Ordering;
use gstuff::slurp;
-
use serde::ser::Serialize;
use serde_json::{self as json, Value as Json};
@@ -64,7 +63,6 @@ use std::process::exit;
use std::ptr::null;
use std::str;
-mod lp_native_dex;
pub use self::lp_native_dex::init_hw;
pub use self::lp_native_dex::lp_init;
use coins::update_coins_config;
@@ -75,6 +73,7 @@ use mm2_err_handle::prelude::*;
pub mod heartbeat_event;
pub mod lp_dispatcher;
pub mod lp_message_service;
+mod lp_native_dex;
pub mod lp_network;
pub mod lp_ordermatch;
pub mod lp_stats;
@@ -160,10 +159,33 @@ pub async fn lp_main(
.with_datetime(datetime.clone())
.into_mm_arc();
ctx_cb(try_s!(ctx.ffi_handle()));
+
+ #[cfg(not(target_arch = "wasm32"))]
+ spawn_ctrl_c_handler(ctx.clone());
+
try_s!(lp_init(ctx, version, datetime).await);
Ok(())
}
+/// Handles CTRL-C signals and shutdowns the KDF runtime gracefully.
+///
+/// It's important to spawn this task as soon as `Ctx` is in the correct state.
+#[cfg(not(target_arch = "wasm32"))]
+fn spawn_ctrl_c_handler(ctx: mm2_core::mm_ctx::MmArc) {
+ use crate::lp_dispatcher::{dispatch_lp_event, StopCtxEvent};
+
+ common::executor::spawn(async move {
+ tokio::signal::ctrl_c()
+ .await
+ .expect("Couldn't listen for the CTRL-C signal.");
+
+ log::info!("Wrapping things up and shutting down...");
+
+ dispatch_lp_event(ctx.clone(), StopCtxEvent.into()).await;
+ ctx.stop().await.expect("Couldn't stop the KDF runtime.");
+ });
+}
+
fn help() {
const HELP_MSG: &str = r#"Command-line options.
The first command-line argument is special and designates the mode.
@@ -248,16 +270,6 @@ pub fn mm2_main(version: String, datetime: String) {
// we're not checking them for the mode switches in order not to risk [untrusted] data being mistaken for a mode switch.
let first_arg = args_os.get(1).and_then(|arg| arg.to_str());
- if first_arg == Some("panic") {
- panic!("panic message")
- }
- if first_arg == Some("crash") {
- double_panic_crash()
- }
- if first_arg == Some("stderr") {
- eprintln!("This goes to stderr");
- return;
- }
if first_arg == Some("update_config") {
match on_update_config(&args_os) {
Ok(_) => println!("Success"),
diff --git a/mm2src/mm2_main/src/rpc.rs b/mm2src/mm2_main/src/rpc.rs
index 2709d76f32..1bef856e15 100644
--- a/mm2src/mm2_main/src/rpc.rs
+++ b/mm2src/mm2_main/src/rpc.rs
@@ -28,14 +28,11 @@ use futures::future::{join_all, FutureExt};
use http::header::{HeaderValue, ACCESS_CONTROL_ALLOW_ORIGIN, CONTENT_TYPE};
use http::request::Parts;
use http::{Method, Request, Response, StatusCode};
-use lazy_static::lazy_static;
use mm2_core::mm_ctx::MmArc;
use mm2_err_handle::prelude::*;
use mm2_rpc::mm_protocol::{MmRpcBuilder, MmRpcResponse, MmRpcVersion};
-use regex::Regex;
use serde::Serialize;
use serde_json::{self as json, Value as Json};
-use std::borrow::Cow;
use std::net::SocketAddr;
cfg_native! {
@@ -178,35 +175,6 @@ fn response_from_dispatcher_error(
response.serialize_http_response()
}
-pub fn escape_answer<'a, S: Into>>(input: S) -> Cow<'a, str> {
- lazy_static! {
- static ref REGEX: Regex = Regex::new("[<>&]").unwrap();
- }
-
- let input = input.into();
- let mut last_match = 0;
-
- if REGEX.is_match(&input) {
- let matches = REGEX.find_iter(&input);
- let mut output = String::with_capacity(input.len());
- for mat in matches {
- let (begin, end) = (mat.start(), mat.end());
- output.push_str(&input[last_match..begin]);
- match &input[begin..end] {
- "<" => output.push_str("<"),
- ">" => output.push_str(">"),
- "&" => output.push_str("&"),
- _ => unreachable!(),
- }
- last_match = end;
- }
- output.push_str(&input[last_match..]);
- Cow::Owned(output)
- } else {
- input
- }
-}
-
async fn process_single_request(ctx: MmArc, req: Json, client: SocketAddr) -> Result>, String> {
let local_only = ctx.conf["rpc_local_only"].as_bool().unwrap_or(true);
if req["mmrpc"].is_null() {
@@ -314,23 +282,9 @@ async fn rpc_service(req: Request, ctx_h: u32, client: SocketAddr) -> Resp
let res = try_sf!(process_rpc_request(ctx, req, req_json, client).await, ACCESS_CONTROL_ALLOW_ORIGIN => rpc_cors);
let (mut parts, body) = res.into_parts();
- let body_escaped = {
- let body_utf8 = match std::str::from_utf8(&body) {
- Ok(body_utf8) => body_utf8,
- Err(_) => {
- return Response::builder()
- .status(500)
- .header(ACCESS_CONTROL_ALLOW_ORIGIN, rpc_cors)
- .header(CONTENT_TYPE, APPLICATION_JSON)
- .body(Body::from(err_to_rpc_json_string("Non UTF-8 output")))
- .unwrap();
- },
- };
- let escaped = escape_answer(body_utf8);
- escaped.as_bytes().to_vec()
- };
parts.headers.insert(ACCESS_CONTROL_ALLOW_ORIGIN, rpc_cors);
- Response::from_parts(parts, Body::from(body_escaped))
+
+ Response::from_parts(parts, Body::from(body))
}
// TODO: This should exclude TCP internals, as including them results in having to
diff --git a/mm2src/mm2_main/src/rpc/dispatcher/dispatcher.rs b/mm2src/mm2_main/src/rpc/dispatcher/dispatcher.rs
index b9066bf540..fec08d106f 100644
--- a/mm2src/mm2_main/src/rpc/dispatcher/dispatcher.rs
+++ b/mm2src/mm2_main/src/rpc/dispatcher/dispatcher.rs
@@ -5,7 +5,7 @@ use crate::lp_native_dex::init_metamask::{cancel_connect_metamask, connect_metam
use crate::lp_ordermatch::{best_orders_rpc_v2, orderbook_rpc_v2, start_simple_market_maker_bot,
stop_simple_market_maker_bot};
use crate::lp_swap::swap_v2_rpcs::{active_swaps_rpc, my_recent_swaps_rpc, my_swap_status_rpc};
-use crate::lp_wallet::get_mnemonic_rpc;
+use crate::lp_wallet::{get_mnemonic_rpc, get_wallet_names_rpc};
use crate::rpc::rate_limiter::{process_rate_limit, RateLimitContext};
use crate::{lp_stats::{add_node_to_version_stat, remove_node_from_version_stat, start_version_stat_collection,
stop_version_stat_collection, update_version_stat_collection},
@@ -190,6 +190,7 @@ async fn dispatcher_v2(request: MmRpcRequest, ctx: MmArc) -> DispatcherResult handle_mmrpc(ctx, request, get_raw_transaction).await,
"get_shared_db_id" => handle_mmrpc(ctx, request, get_shared_db_id).await,
"get_staking_infos" => handle_mmrpc(ctx, request, get_staking_infos).await,
+ "get_wallet_names" => handle_mmrpc(ctx, request, get_wallet_names_rpc).await,
"max_maker_vol" => handle_mmrpc(ctx, request, max_maker_vol).await,
"my_recent_swaps" => handle_mmrpc(ctx, request, my_recent_swaps_rpc).await,
"my_swap_status" => handle_mmrpc(ctx, request, my_swap_status_rpc).await,
diff --git a/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs b/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs
index 7db7c5b02b..5ef386942c 100644
--- a/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs
+++ b/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs
@@ -21,7 +21,6 @@
use coins::{lp_coinfind, lp_coinfind_any, lp_coininit, CoinsContext, MmCoinEnum};
use common::executor::Timer;
-use common::log::error;
use common::{rpc_err_response, rpc_response, HyRes};
use futures::compat::Future01CompatExt;
use http::Response;
@@ -242,29 +241,13 @@ pub async fn my_balance(ctx: MmArc, req: Json) -> Result>, Stri
Ok(try_s!(Response::builder().body(res)))
}
-#[cfg(not(target_arch = "wasm32"))]
-async fn close_async_connection(ctx: &MmArc) {
- if let Some(async_conn) = ctx.async_sqlite_connection.as_option() {
- let mut conn = async_conn.lock().await;
- if let Err(e) = conn.close().await {
- error!("Error stopping AsyncConnection: {}", e);
- }
- }
-}
-
pub async fn stop(ctx: MmArc) -> Result>, String> {
dispatch_lp_event(ctx.clone(), StopCtxEvent.into()).await;
// Should delay the shutdown a bit in order not to trip the "stop" RPC call in unit tests.
// Stopping immediately leads to the "stop" RPC call failing with the "errno 10054" sometimes.
let fut = async move {
Timer::sleep(0.05).await;
-
- #[cfg(not(target_arch = "wasm32"))]
- close_async_connection(&ctx).await;
-
- if let Err(e) = ctx.stop() {
- error!("Error stopping MmCtx: {}", e);
- }
+ ctx.stop().await.expect("Couldn't stop the KDF runtime.");
};
// Please note we shouldn't use `MmCtx::spawner` to spawn this future,
diff --git a/mm2src/mm2_main/src/wasm_tests.rs b/mm2src/mm2_main/src/wasm_tests.rs
index fbf37ca545..bd24bf4a4c 100644
--- a/mm2src/mm2_main/src/wasm_tests.rs
+++ b/mm2src/mm2_main/src/wasm_tests.rs
@@ -1,14 +1,14 @@
use crate::lp_init;
-use common::executor::{spawn, Timer};
+use common::executor::{spawn, spawn_abortable, spawn_local_abortable, AbortOnDropHandle, Timer};
use common::log::wasm_log::register_wasm_log;
use mm2_core::mm_ctx::MmArc;
use mm2_number::BigDecimal;
use mm2_rpc::data::legacy::OrderbookResponse;
use mm2_test_helpers::electrums::{doc_electrums, marty_electrums};
use mm2_test_helpers::for_tests::{check_recent_swaps, enable_electrum_json, enable_utxo_v2_electrum,
- enable_z_coin_light, morty_conf, pirate_conf, rick_conf, start_swaps,
- test_qrc20_history_impl, wait_for_swaps_finish_and_check_status, MarketMakerIt,
- Mm2InitPrivKeyPolicy, Mm2TestConf, Mm2TestConfForSwap, ARRR, MORTY,
+ enable_z_coin_light, get_wallet_names, morty_conf, pirate_conf, rick_conf,
+ start_swaps, test_qrc20_history_impl, wait_for_swaps_finish_and_check_status,
+ MarketMakerIt, Mm2InitPrivKeyPolicy, Mm2TestConf, Mm2TestConfForSwap, ARRR, MORTY,
PIRATE_ELECTRUMS, PIRATE_LIGHTWALLETD_URLS, RICK};
use mm2_test_helpers::get_passphrase;
use mm2_test_helpers::structs::{Bip44Chain, EnableCoinBalance, HDAccountAddressId};
@@ -16,6 +16,7 @@ use serde_json::json;
use wasm_bindgen_test::wasm_bindgen_test;
const PIRATE_TEST_BALANCE_SEED: &str = "pirate test seed";
+const STOP_TIMEOUT_MS: u64 = 1000;
/// Starts the WASM version of MM.
fn wasm_start(ctx: MmArc) {
@@ -26,13 +27,7 @@ fn wasm_start(ctx: MmArc) {
/// This function runs Alice and Bob nodes, activates coins, starts swaps,
/// and then immediately stops the nodes to check if `MmArc` is dropped in a short period.
-async fn test_mm2_stops_impl(
- pairs: &[(&'static str, &'static str)],
- maker_price: f64,
- taker_price: f64,
- volume: f64,
- stop_timeout_ms: u64,
-) {
+async fn test_mm2_stops_impl(pairs: &[(&'static str, &'static str)], maker_price: f64, taker_price: f64, volume: f64) {
let coins = json!([rick_conf(), morty_conf()]);
let bob_passphrase = get_passphrase!(".env.seed", "BOB_PASSPHRASE").unwrap();
@@ -69,20 +64,18 @@ async fn test_mm2_stops_impl(
start_swaps(&mut mm_bob, &mut mm_alice, pairs, maker_price, taker_price, volume).await;
mm_alice
- .stop_and_wait_for_ctx_is_dropped(stop_timeout_ms)
+ .stop_and_wait_for_ctx_is_dropped(STOP_TIMEOUT_MS)
.await
.unwrap();
- mm_bob.stop_and_wait_for_ctx_is_dropped(stop_timeout_ms).await.unwrap();
+ mm_bob.stop_and_wait_for_ctx_is_dropped(STOP_TIMEOUT_MS).await.unwrap();
}
#[wasm_bindgen_test]
async fn test_mm2_stops_immediately() {
- const STOP_TIMEOUT_MS: u64 = 1000;
-
register_wasm_log();
let pairs: &[_] = &[("RICK", "MORTY")];
- test_mm2_stops_impl(pairs, 1., 1., 0.0001, STOP_TIMEOUT_MS).await;
+ test_mm2_stops_impl(pairs, 1., 1., 0.0001).await;
}
#[wasm_bindgen_test]
@@ -147,8 +140,6 @@ async fn trade_base_rel_electrum(
assert_eq!(0, bob_orderbook.asks.len(), "{} {} asks must be empty", base, rel);
}
- const STOP_TIMEOUT_MS: u64 = 1000;
-
mm_bob.stop_and_wait_for_ctx_is_dropped(STOP_TIMEOUT_MS).await.unwrap();
mm_alice
.stop_and_wait_for_ctx_is_dropped(STOP_TIMEOUT_MS)
@@ -266,3 +257,46 @@ async fn activate_z_coin_light() {
};
assert_eq!(balance.balance.spendable, BigDecimal::default());
}
+
+#[wasm_bindgen_test]
+async fn test_get_wallet_names() {
+ const DB_NAMESPACE_NUM: u64 = 1;
+
+ let coins = json!([]);
+
+ // Initialize the first wallet with a specific name
+ let wallet_1 = Mm2TestConf::seednode_with_wallet_name(&coins, "wallet_1", "pass");
+ let mm_wallet_1 =
+ MarketMakerIt::start_with_db(wallet_1.conf, wallet_1.rpc_password, Some(wasm_start), DB_NAMESPACE_NUM)
+ .await
+ .unwrap();
+
+ // Retrieve and verify the wallet names for the first wallet
+ let get_wallet_names_1 = get_wallet_names(&mm_wallet_1).await;
+ assert_eq!(get_wallet_names_1.wallet_names, vec!["wallet_1"]);
+ assert_eq!(get_wallet_names_1.activated_wallet.unwrap(), "wallet_1");
+
+ // Stop the first wallet before starting the second one
+ mm_wallet_1
+ .stop_and_wait_for_ctx_is_dropped(STOP_TIMEOUT_MS)
+ .await
+ .unwrap();
+
+ // Initialize the second wallet with a different name
+ let wallet_2 = Mm2TestConf::seednode_with_wallet_name(&coins, "wallet_2", "pass");
+ let mm_wallet_2 =
+ MarketMakerIt::start_with_db(wallet_2.conf, wallet_2.rpc_password, Some(wasm_start), DB_NAMESPACE_NUM)
+ .await
+ .unwrap();
+
+ // Retrieve and verify the wallet names for the second wallet
+ let get_wallet_names_2 = get_wallet_names(&mm_wallet_2).await;
+ assert_eq!(get_wallet_names_2.wallet_names, vec!["wallet_1", "wallet_2"]);
+ assert_eq!(get_wallet_names_2.activated_wallet.unwrap(), "wallet_2");
+
+ // Stop the second wallet
+ mm_wallet_2
+ .stop_and_wait_for_ctx_is_dropped(STOP_TIMEOUT_MS)
+ .await
+ .unwrap();
+}
diff --git a/mm2src/mm2_main/tests/docker_tests/docker_tests_common.rs b/mm2src/mm2_main/tests/docker_tests/docker_tests_common.rs
index fe5d7f96d4..49150fab55 100644
--- a/mm2src/mm2_main/tests/docker_tests/docker_tests_common.rs
+++ b/mm2src/mm2_main/tests/docker_tests/docker_tests_common.rs
@@ -1,4 +1,4 @@
-pub use common::{block_on, now_ms, now_sec, wait_until_ms, wait_until_sec, DEX_FEE_ADDR_RAW_PUBKEY};
+pub use common::{block_on, block_on_f01, now_ms, now_sec, wait_until_ms, wait_until_sec, DEX_FEE_ADDR_RAW_PUBKEY};
pub use mm2_number::MmNumber;
use mm2_rpc::data::legacy::BalanceResponse;
pub use mm2_test_helpers::for_tests::{check_my_swap_status, check_recent_swaps, enable_eth_coin, enable_native,
@@ -27,7 +27,6 @@ use crypto::Secp256k1Secret;
use ethabi::Token;
use ethereum_types::{H160 as H160Eth, U256};
use futures::TryFutureExt;
-use futures01::Future;
use http::StatusCode;
use keys::{Address, AddressBuilder, AddressHashEnum, AddressPrefix, KeyPair, NetworkAddressPrefixes,
NetworkPrefix as CashAddrPrefix};
@@ -155,13 +154,13 @@ pub trait CoinDockerOps {
fn wait_ready(&self, expected_tx_version: i32) {
let timeout = wait_until_ms(120000);
loop {
- match self.rpc_client().get_block_count().wait() {
+ match block_on_f01(self.rpc_client().get_block_count()) {
Ok(n) => {
if n > 1 {
if let UtxoRpcClientEnum::Native(client) = self.rpc_client() {
- let hash = client.get_block_hash(n).wait().unwrap();
- let block = client.get_block(hash).wait().unwrap();
- let coinbase = client.get_verbose_transaction(&block.tx[0]).wait().unwrap();
+ let hash = block_on_f01(client.get_block_hash(n)).unwrap();
+ let block = block_on_f01(client.get_block(hash)).unwrap();
+ let coinbase = block_on_f01(client.get_verbose_transaction(&block.tx[0])).unwrap();
log!("Coinbase tx {:?} in block {}", coinbase, n);
if coinbase.version == expected_tx_version {
break;
@@ -251,10 +250,11 @@ impl BchDockerOps {
.build()
.expect("valid address props");
- self.native_client()
- .import_address(&address.to_string(), &address.to_string(), false)
- .wait()
- .unwrap();
+ block_on_f01(
+ self.native_client()
+ .import_address(&address.to_string(), &address.to_string(), false),
+ )
+ .unwrap();
let script_pubkey = Builder::build_p2pkh(&key_pair.public().address_hash().into());
@@ -270,9 +270,7 @@ impl BchDockerOps {
slp_privkeys.push(*key_pair.private_ref());
}
- let slp_genesis_tx = send_outputs_from_my_address(self.coin.clone(), bch_outputs)
- .wait()
- .unwrap();
+ let slp_genesis_tx = block_on_f01(send_outputs_from_my_address(self.coin.clone(), bch_outputs)).unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: slp_genesis_tx.tx_hex(),
confirmations: 1,
@@ -280,7 +278,7 @@ impl BchDockerOps {
wait_until: wait_until_sec(30),
check_every: 1,
};
- self.coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(self.coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let adex_slp = SlpToken::new(
8,
@@ -299,7 +297,7 @@ impl BchDockerOps {
wait_until: wait_until_sec(30),
check_every: 1,
};
- self.coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(self.coin.wait_for_confirmations(confirm_payment_input)).unwrap();
*SLP_TOKEN_OWNERS.lock().unwrap() = slp_privkeys;
*SLP_TOKEN_ID.lock().unwrap() = slp_genesis_tx.tx_hash_as_bytes().as_slice().into();
}
@@ -466,7 +464,7 @@ where
match coin.as_ref().rpc_client {
UtxoRpcClientEnum::Native(ref native) => {
let my_address = coin.my_address().unwrap();
- native.import_address(&my_address, &my_address, false).wait().unwrap()
+ block_on_f01(native.import_address(&my_address, &my_address, false)).unwrap()
},
UtxoRpcClientEnum::Electrum(_) => panic!("Expected NativeClient"),
}
@@ -586,9 +584,7 @@ where
UtxoRpcClientEnum::Native(ref native) => native,
UtxoRpcClientEnum::Electrum(_) => panic!("NativeClient expected"),
};
- let mut addresses = native
- .get_addresses_by_label(label)
- .wait()
+ let mut addresses = block_on_f01(native.get_addresses_by_label(label))
.expect("!getaddressesbylabel")
.into_iter();
match addresses.next() {
@@ -610,22 +606,20 @@ pub fn fill_qrc20_address(coin: &Qrc20Coin, amount: BigDecimal, timeout: u64) {
};
let from_addr = get_address_by_label(coin, QTUM_ADDRESS_LABEL);
- let to_addr = coin.my_addr_as_contract_addr().compat().wait().unwrap();
+ let to_addr = block_on_f01(coin.my_addr_as_contract_addr().compat()).unwrap();
let satoshis = sat_from_big_decimal(&amount, coin.as_ref().decimals).expect("!sat_from_big_decimal");
- let hash = client
- .transfer_tokens(
- &coin.contract_address,
- &from_addr,
- to_addr,
- satoshis.into(),
- coin.as_ref().decimals,
- )
- .wait()
- .expect("!transfer_tokens")
- .txid;
+ let hash = block_on_f01(client.transfer_tokens(
+ &coin.contract_address,
+ &from_addr,
+ to_addr,
+ satoshis.into(),
+ coin.as_ref().decimals,
+ ))
+ .expect("!transfer_tokens")
+ .txid;
- let tx_bytes = client.get_transaction_bytes(&hash).wait().unwrap();
+ let tx_bytes = block_on_f01(client.get_transaction_bytes(&hash)).unwrap();
log!("{:02x}", tx_bytes);
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: tx_bytes.0,
@@ -634,7 +628,7 @@ pub fn fill_qrc20_address(coin: &Qrc20Coin, amount: BigDecimal, timeout: u64) {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
}
/// Generate random privkey, create a QRC20 coin and fill it's address with the specified balance.
@@ -742,9 +736,9 @@ where
let timeout = wait_until_sec(timeout);
if let UtxoRpcClientEnum::Native(client) = &coin.as_ref().rpc_client {
- client.import_address(address, address, false).wait().unwrap();
- let hash = client.send_to_address(address, &amount).wait().unwrap();
- let tx_bytes = client.get_transaction_bytes(&hash).wait().unwrap();
+ block_on_f01(client.import_address(address, address, false)).unwrap();
+ let hash = block_on_f01(client.send_to_address(address, &amount)).unwrap();
+ let tx_bytes = block_on_f01(client.get_transaction_bytes(&hash)).unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: tx_bytes.clone().0,
confirmations: 1,
@@ -752,13 +746,10 @@ where
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
log!("{:02x}", tx_bytes);
loop {
- let unspents = client
- .list_unspent_impl(0, std::i32::MAX, vec![address.to_string()])
- .wait()
- .unwrap();
+ let unspents = block_on_f01(client.list_unspent_impl(0, std::i32::MAX, vec![address.to_string()])).unwrap();
if !unspents.is_empty() {
break;
}
@@ -794,7 +785,7 @@ pub fn wait_for_estimate_smart_fee(timeout: u64) -> Result<(), String> {
UtxoRpcClientEnum::Electrum(_) => panic!("Expected NativeClient"),
};
while now_sec() < timeout {
- if let Ok(res) = client.estimate_smart_fee(&None, 1).wait() {
+ if let Ok(res) = block_on_f01(client.estimate_smart_fee(&None, 1)) {
if res.errors.is_empty() {
*state = EstimateSmartFeeState::Ok;
return Ok(());
diff --git a/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs b/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs
index 330dec30de..fd9e4eefb6 100644
--- a/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs
+++ b/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs
@@ -12,10 +12,9 @@ use coins::TxFeeDetails;
use coins::{ConfirmPaymentInput, FoundSwapTxSpend, MarketCoinOps, MmCoin, RefundPaymentArgs,
SearchForSwapTxSpendInput, SendPaymentArgs, SpendPaymentArgs, SwapOps, SwapTxTypeWithSecretHash,
TransactionEnum, WithdrawRequest};
-use common::{block_on, executor::Timer, get_utc_timestamp, now_sec, wait_until_sec};
+use common::{block_on, block_on_f01, executor::Timer, get_utc_timestamp, now_sec, wait_until_sec};
use crypto::privkey::key_pair_from_seed;
use crypto::{CryptoCtx, DerivationPath, KeyPairPolicy};
-use futures01::Future;
use http::StatusCode;
use mm2_number::{BigDecimal, BigRational, MmNumber};
use mm2_test_helpers::for_tests::{check_my_swap_status_amounts, disable_coin, disable_coin_err, enable_eth_coin,
@@ -51,7 +50,7 @@ fn test_search_for_swap_tx_spend_native_was_refunded_taker() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let tx = coin.send_taker_payment(taker_payment_args).wait().unwrap();
+ let tx = block_on_f01(coin.send_taker_payment(taker_payment_args)).unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: tx.tx_hex(),
@@ -60,7 +59,7 @@ fn test_search_for_swap_tx_spend_native_was_refunded_taker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let maker_refunds_payment_args = RefundPaymentArgs {
payment_tx: &tx.tx_hex(),
time_lock,
@@ -81,7 +80,7 @@ fn test_search_for_swap_tx_spend_native_was_refunded_taker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
@@ -113,7 +112,9 @@ fn test_for_non_existent_tx_hex_utxo() {
wait_until: timeout,
check_every: 1,
};
- let actual = coin.wait_for_confirmations(confirm_payment_input).wait().err().unwrap();
+ let actual = block_on_f01(coin.wait_for_confirmations(confirm_payment_input))
+ .err()
+ .unwrap();
assert!(actual.contains(
"Tx d342ff9da528a2e262bddf2b6f9a27d1beb7aeb03f0fc8d9eac2987266447e44 was not found on chain after 10 tries"
));
@@ -138,7 +139,7 @@ fn test_search_for_swap_tx_spend_native_was_refunded_maker() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let tx = coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let tx = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: tx.tx_hex(),
@@ -147,7 +148,7 @@ fn test_search_for_swap_tx_spend_native_was_refunded_maker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let maker_refunds_payment_args = RefundPaymentArgs {
payment_tx: &tx.tx_hex(),
time_lock,
@@ -168,7 +169,7 @@ fn test_search_for_swap_tx_spend_native_was_refunded_maker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
@@ -207,7 +208,7 @@ fn test_search_for_taker_swap_tx_spend_native_was_spent_by_maker() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let tx = coin.send_taker_payment(taker_payment_args).wait().unwrap();
+ let tx = block_on_f01(coin.send_taker_payment(taker_payment_args)).unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: tx.tx_hex(),
@@ -216,7 +217,7 @@ fn test_search_for_taker_swap_tx_spend_native_was_spent_by_maker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let maker_spends_payment_args = SpendPaymentArgs {
other_payment_tx: &tx.tx_hex(),
time_lock,
@@ -236,7 +237,7 @@ fn test_search_for_taker_swap_tx_spend_native_was_spent_by_maker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
@@ -275,7 +276,7 @@ fn test_search_for_maker_swap_tx_spend_native_was_spent_by_taker() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let tx = coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let tx = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: tx.tx_hex(),
@@ -284,7 +285,7 @@ fn test_search_for_maker_swap_tx_spend_native_was_spent_by_taker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let taker_spends_payment_args = SpendPaymentArgs {
other_payment_tx: &tx.tx_hex(),
time_lock,
@@ -304,7 +305,7 @@ fn test_search_for_maker_swap_tx_spend_native_was_spent_by_taker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
@@ -346,7 +347,7 @@ fn test_one_hundred_maker_payments_in_a_row_native() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let tx = coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let tx = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
if let TransactionEnum::UtxoTx(tx) = tx {
unspents.push(UnspentInfo {
outpoint: OutPoint {
@@ -2472,16 +2473,12 @@ fn test_maker_order_should_not_kick_start_and_appear_in_orderbook_if_balance_is_
bob_conf["log"] = mm_bob.folder.join("mm2_dup.log").to_str().unwrap().into();
block_on(mm_bob.stop()).unwrap();
- let withdraw = coin
- .withdraw(WithdrawRequest::new_max(
- "MYCOIN".to_string(),
- "RRYmiZSDo3UdHHqj1rLKf8cbJroyv9NxXw".to_string(),
- ))
- .wait()
- .unwrap();
- coin.send_raw_tx(&hex::encode(&withdraw.tx.tx_hex().unwrap().0))
- .wait()
- .unwrap();
+ let withdraw = block_on_f01(coin.withdraw(WithdrawRequest::new_max(
+ "MYCOIN".to_string(),
+ "RRYmiZSDo3UdHHqj1rLKf8cbJroyv9NxXw".to_string(),
+ )))
+ .unwrap();
+ block_on_f01(coin.send_raw_tx(&hex::encode(&withdraw.tx.tx_hex().unwrap().0))).unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: withdraw.tx.tx_hex().unwrap().0.to_owned(),
confirmations: 1,
@@ -2489,7 +2486,7 @@ fn test_maker_order_should_not_kick_start_and_appear_in_orderbook_if_balance_is_
wait_until: wait_until_sec(10),
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let mm_bob_dup = MarketMakerIt::start(bob_conf, "pass".to_string(), None).unwrap();
let (_bob_dup_dump_log, _bob_dup_dump_dashboard) = mm_dump(&mm_bob_dup.log_path);
diff --git a/mm2src/mm2_main/tests/docker_tests/eth_docker_tests.rs b/mm2src/mm2_main/tests/docker_tests/eth_docker_tests.rs
index 2fbb31bf71..b898e9151b 100644
--- a/mm2src/mm2_main/tests/docker_tests/eth_docker_tests.rs
+++ b/mm2src/mm2_main/tests/docker_tests/eth_docker_tests.rs
@@ -19,10 +19,9 @@ use coins::{lp_coinfind, CoinProtocol, CoinWithDerivationMethod, CoinsContext, C
SendNftMakerPaymentArgs, SendPaymentArgs, SendTakerFundingArgs, SpendNftMakerPaymentArgs,
SpendPaymentArgs, SwapOps, SwapTxFeePolicy, SwapTxTypeWithSecretHash, TakerCoinSwapOpsV2, ToBytes,
Transaction, TxPreimageWithSig, ValidateNftMakerPaymentArgs, ValidateTakerFundingArgs};
-use common::{block_on, now_sec};
+use common::{block_on, block_on_f01, now_sec};
use crypto::Secp256k1Secret;
use ethereum_types::U256;
-use futures01::Future;
use mm2_core::mm_ctx::MmArc;
use mm2_number::{BigDecimal, BigUint};
use mm2_test_helpers::for_tests::{erc20_dev_conf, eth_dev_conf, eth_sepolia_conf, nft_dev_conf, sepolia_erc20_dev_conf};
@@ -545,7 +544,7 @@ fn send_and_refund_eth_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let eth_maker_payment = eth_coin.send_maker_payment(send_payment_args).wait().unwrap();
+ let eth_maker_payment = block_on_f01(eth_coin.send_maker_payment(send_payment_args)).unwrap();
let confirm_input = ConfirmPaymentInput {
payment_tx: eth_maker_payment.tx_hex(),
@@ -554,7 +553,7 @@ fn send_and_refund_eth_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
wait_until: now_sec() + 60,
check_every: 1,
};
- eth_coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(eth_coin.wait_for_confirmations(confirm_input)).unwrap();
let refund_args = RefundPaymentArgs {
payment_tx: ð_maker_payment.tx_hex(),
@@ -577,7 +576,7 @@ fn send_and_refund_eth_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
wait_until: now_sec() + 60,
check_every: 1,
};
- eth_coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(eth_coin.wait_for_confirmations(confirm_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
@@ -631,7 +630,7 @@ fn send_and_spend_eth_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let eth_maker_payment = maker_eth_coin.send_maker_payment(send_payment_args).wait().unwrap();
+ let eth_maker_payment = block_on_f01(maker_eth_coin.send_maker_payment(send_payment_args)).unwrap();
let confirm_input = ConfirmPaymentInput {
payment_tx: eth_maker_payment.tx_hex(),
@@ -640,7 +639,7 @@ fn send_and_spend_eth_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
wait_until: now_sec() + 60,
check_every: 1,
};
- taker_eth_coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(taker_eth_coin.wait_for_confirmations(confirm_input)).unwrap();
let spend_args = SpendPaymentArgs {
other_payment_tx: ð_maker_payment.tx_hex(),
@@ -662,7 +661,7 @@ fn send_and_spend_eth_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
wait_until: now_sec() + 60,
check_every: 1,
};
- taker_eth_coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(taker_eth_coin.wait_for_confirmations(confirm_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
@@ -714,7 +713,7 @@ fn send_and_refund_erc20_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy)
watcher_reward: None,
wait_for_confirmation_until: now_sec() + 60,
};
- let eth_maker_payment = erc20_coin.send_maker_payment(send_payment_args).wait().unwrap();
+ let eth_maker_payment = block_on_f01(erc20_coin.send_maker_payment(send_payment_args)).unwrap();
let confirm_input = ConfirmPaymentInput {
payment_tx: eth_maker_payment.tx_hex(),
@@ -723,7 +722,7 @@ fn send_and_refund_erc20_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy)
wait_until: now_sec() + 60,
check_every: 1,
};
- erc20_coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(erc20_coin.wait_for_confirmations(confirm_input)).unwrap();
let refund_args = RefundPaymentArgs {
payment_tx: ð_maker_payment.tx_hex(),
@@ -746,7 +745,7 @@ fn send_and_refund_erc20_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy)
wait_until: now_sec() + 60,
check_every: 1,
};
- erc20_coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(erc20_coin.wait_for_confirmations(confirm_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
@@ -803,7 +802,7 @@ fn send_and_spend_erc20_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
watcher_reward: None,
wait_for_confirmation_until: now_sec() + 60,
};
- let eth_maker_payment = maker_erc20_coin.send_maker_payment(send_payment_args).wait().unwrap();
+ let eth_maker_payment = block_on_f01(maker_erc20_coin.send_maker_payment(send_payment_args)).unwrap();
let confirm_input = ConfirmPaymentInput {
payment_tx: eth_maker_payment.tx_hex(),
@@ -812,7 +811,7 @@ fn send_and_spend_erc20_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
wait_until: now_sec() + 60,
check_every: 1,
};
- taker_erc20_coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(taker_erc20_coin.wait_for_confirmations(confirm_input)).unwrap();
let spend_args = SpendPaymentArgs {
other_payment_tx: ð_maker_payment.tx_hex(),
@@ -834,7 +833,7 @@ fn send_and_spend_erc20_maker_payment_impl(swap_txfee_policy: SwapTxFeePolicy) {
wait_until: now_sec() + 60,
check_every: 1,
};
- taker_erc20_coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(taker_erc20_coin.wait_for_confirmations(confirm_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
@@ -976,12 +975,12 @@ fn test_nonce_several_urls() {
// Use one working and one failing URL.
let coin = eth_coin_with_random_privkey_using_urls(swap_contract(), &[GETH_RPC_URL, "http://127.0.0.1:0"]);
let my_address = block_on(coin.derivation_method().single_addr_or_err()).unwrap();
- let (old_nonce, _) = coin.clone().get_addr_nonce(my_address).wait().unwrap();
+ let (old_nonce, _) = block_on_f01(coin.clone().get_addr_nonce(my_address)).unwrap();
// Send a payment to increase the nonce.
- coin.send_to_address(my_address, 200000000.into()).wait().unwrap();
+ block_on_f01(coin.send_to_address(my_address, 200000000.into())).unwrap();
- let (new_nonce, _) = coin.get_addr_nonce(my_address).wait().unwrap();
+ let (new_nonce, _) = block_on_f01(coin.get_addr_nonce(my_address)).unwrap();
assert_eq!(old_nonce + 1, new_nonce);
}
@@ -1313,7 +1312,7 @@ fn wait_for_confirmations(coin: &EthCoin, tx: &SignedEthTx, wait_seconds: u64) {
wait_until: now_sec() + wait_seconds,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_input)).unwrap();
}
fn validate_nft_maker_payment(setup: &NftTestSetup, maker_payment: &SignedEthTx, amount: BigDecimal) {
diff --git a/mm2src/mm2_main/tests/docker_tests/qrc20_tests.rs b/mm2src/mm2_main/tests/docker_tests/qrc20_tests.rs
index e66a3a5852..6d8d03d96c 100644
--- a/mm2src/mm2_main/tests/docker_tests/qrc20_tests.rs
+++ b/mm2src/mm2_main/tests/docker_tests/qrc20_tests.rs
@@ -11,10 +11,9 @@ use coins::{CheckIfMyPaymentSentArgs, ConfirmPaymentInput, DexFee, FeeApproxStag
SwapTxTypeWithSecretHash, TradePreimageValue, TransactionEnum, ValidateFeeArgs, ValidatePaymentInput,
WaitForHTLCTxSpendArgs};
use common::log::debug;
-use common::{temp_dir, DEX_FEE_ADDR_RAW_PUBKEY};
+use common::{block_on_f01, temp_dir, DEX_FEE_ADDR_RAW_PUBKEY};
use crypto::Secp256k1Secret;
use ethereum_types::H160;
-use futures01::Future;
use http::StatusCode;
use mm2_core::mm_ctx::{MmArc, MmCtxBuilder};
use mm2_main::lp_swap::{dex_fee_amount, max_taker_vol_from_available};
@@ -78,9 +77,7 @@ impl QtumDockerOps {
match self.coin.as_ref().rpc_client {
UtxoRpcClientEnum::Native(ref native) => {
- let result = native
- .create_contract(&bytecode.into(), gas_limit, gas_price, sender)
- .wait()
+ let result = block_on_f01(native.create_contract(&bytecode.into(), gas_limit, gas_price, sender))
.expect("!createcontract");
result.address.0.into()
},
@@ -165,14 +162,8 @@ fn withdraw_and_send(mm: &MarketMakerIt, coin: &str, to: &str, amount: f64) {
fn test_taker_spends_maker_payment() {
let (_ctx, maker_coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 10.into());
let (_ctx, taker_coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 1.into());
- let maker_old_balance = maker_coin
- .my_spendable_balance()
- .wait()
- .expect("Error on get maker balance");
- let taker_old_balance = taker_coin
- .my_spendable_balance()
- .wait()
- .expect("Error on get taker balance");
+ let maker_old_balance = block_on_f01(maker_coin.my_spendable_balance()).expect("Error on get maker balance");
+ let taker_old_balance = block_on_f01(taker_coin.my_spendable_balance()).expect("Error on get taker balance");
assert_eq!(maker_old_balance, BigDecimal::from(10));
assert_eq!(taker_old_balance, BigDecimal::from(1));
@@ -194,7 +185,7 @@ fn test_taker_spends_maker_payment() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let payment = maker_coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let payment = block_on_f01(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
let payment_tx_hash = payment.tx_hash_as_bytes();
let payment_tx_hex = payment.tx_hex();
log!("Maker payment: {:?}", payment_tx_hash);
@@ -210,7 +201,7 @@ fn test_taker_spends_maker_payment() {
wait_until,
check_every,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let input = ValidatePaymentInput {
payment_tx: payment_tx_hex.clone(),
@@ -249,16 +240,10 @@ fn test_taker_spends_maker_payment() {
wait_until,
check_every,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
-
- let maker_balance = maker_coin
- .my_spendable_balance()
- .wait()
- .expect("Error on get maker balance");
- let taker_balance = taker_coin
- .my_spendable_balance()
- .wait()
- .expect("Error on get taker balance");
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
+
+ let maker_balance = block_on_f01(maker_coin.my_spendable_balance()).expect("Error on get maker balance");
+ let taker_balance = block_on_f01(taker_coin.my_spendable_balance()).expect("Error on get taker balance");
assert_eq!(maker_old_balance - amount.clone(), maker_balance);
assert_eq!(taker_old_balance + amount, taker_balance);
}
@@ -267,14 +252,8 @@ fn test_taker_spends_maker_payment() {
fn test_maker_spends_taker_payment() {
let (_ctx, maker_coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 10.into());
let (_ctx, taker_coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 10.into());
- let maker_old_balance = maker_coin
- .my_spendable_balance()
- .wait()
- .expect("Error on get maker balance");
- let taker_old_balance = taker_coin
- .my_spendable_balance()
- .wait()
- .expect("Error on get taker balance");
+ let maker_old_balance = block_on_f01(maker_coin.my_spendable_balance()).expect("Error on get maker balance");
+ let taker_old_balance = block_on_f01(taker_coin.my_spendable_balance()).expect("Error on get taker balance");
assert_eq!(maker_old_balance, BigDecimal::from(10));
assert_eq!(taker_old_balance, BigDecimal::from(10));
@@ -296,7 +275,7 @@ fn test_maker_spends_taker_payment() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let payment = taker_coin.send_taker_payment(taker_payment_args).wait().unwrap();
+ let payment = block_on_f01(taker_coin.send_taker_payment(taker_payment_args)).unwrap();
let payment_tx_hash = payment.tx_hash_as_bytes();
let payment_tx_hex = payment.tx_hex();
log!("Taker payment: {:?}", payment_tx_hash);
@@ -312,7 +291,7 @@ fn test_maker_spends_taker_payment() {
wait_until,
check_every,
};
- maker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(maker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let input = ValidatePaymentInput {
payment_tx: payment_tx_hex.clone(),
@@ -351,16 +330,10 @@ fn test_maker_spends_taker_payment() {
wait_until,
check_every,
};
- maker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
-
- let maker_balance = maker_coin
- .my_spendable_balance()
- .wait()
- .expect("Error on get maker balance");
- let taker_balance = taker_coin
- .my_spendable_balance()
- .wait()
- .expect("Error on get taker balance");
+ block_on_f01(maker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
+
+ let maker_balance = block_on_f01(maker_coin.my_spendable_balance()).expect("Error on get maker balance");
+ let taker_balance = block_on_f01(taker_coin.my_spendable_balance()).expect("Error on get taker balance");
assert_eq!(maker_old_balance + amount.clone(), maker_balance);
assert_eq!(taker_old_balance - amount, taker_balance);
}
@@ -368,7 +341,7 @@ fn test_maker_spends_taker_payment() {
#[test]
fn test_maker_refunds_payment() {
let (_ctx, coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 10.into());
- let expected_balance = coin.my_spendable_balance().wait().unwrap();
+ let expected_balance = block_on_f01(coin.my_spendable_balance()).unwrap();
assert_eq!(expected_balance, BigDecimal::from(10));
let timelock = now_sec() - 200;
@@ -387,7 +360,7 @@ fn test_maker_refunds_payment() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let payment = coin.send_maker_payment(maker_payment).wait().unwrap();
+ let payment = block_on_f01(coin.send_maker_payment(maker_payment)).unwrap();
let payment_tx_hash = payment.tx_hash_as_bytes();
let payment_tx_hex = payment.tx_hex();
log!("Maker payment: {:?}", payment_tx_hash);
@@ -403,9 +376,9 @@ fn test_maker_refunds_payment() {
wait_until,
check_every,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let balance_after_payment = coin.my_spendable_balance().wait().unwrap();
+ let balance_after_payment = block_on_f01(coin.my_spendable_balance()).unwrap();
assert_eq!(expected_balance.clone() - amount, balance_after_payment);
let maker_refunds_payment_args = RefundPaymentArgs {
payment_tx: &payment_tx_hex,
@@ -431,16 +404,16 @@ fn test_maker_refunds_payment() {
wait_until,
check_every,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let balance_after_refund = coin.my_spendable_balance().wait().unwrap();
+ let balance_after_refund = block_on_f01(coin.my_spendable_balance()).unwrap();
assert_eq!(expected_balance, balance_after_refund);
}
#[test]
fn test_taker_refunds_payment() {
let (_ctx, coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 10.into());
- let expected_balance = coin.my_spendable_balance().wait().unwrap();
+ let expected_balance = block_on_f01(coin.my_spendable_balance()).unwrap();
assert_eq!(expected_balance, BigDecimal::from(10));
let timelock = now_sec() - 200;
@@ -459,7 +432,7 @@ fn test_taker_refunds_payment() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let payment = coin.send_taker_payment(taker_payment_args).wait().unwrap();
+ let payment = block_on_f01(coin.send_taker_payment(taker_payment_args)).unwrap();
let payment_tx_hash = payment.tx_hash_as_bytes();
let payment_tx_hex = payment.tx_hex();
log!("Taker payment: {:?}", payment_tx_hash);
@@ -475,9 +448,9 @@ fn test_taker_refunds_payment() {
wait_until,
check_every,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let balance_after_payment = coin.my_spendable_balance().wait().unwrap();
+ let balance_after_payment = block_on_f01(coin.my_spendable_balance()).unwrap();
assert_eq!(expected_balance.clone() - amount, balance_after_payment);
let taker_refunds_payment_args = RefundPaymentArgs {
payment_tx: &payment_tx_hex,
@@ -503,9 +476,9 @@ fn test_taker_refunds_payment() {
wait_until,
check_every,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let balance_after_refund = coin.my_spendable_balance().wait().unwrap();
+ let balance_after_refund = block_on_f01(coin.my_spendable_balance()).unwrap();
assert_eq!(expected_balance, balance_after_refund);
}
@@ -528,7 +501,7 @@ fn test_check_if_my_payment_sent() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let payment = coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let payment = block_on_f01(coin.send_maker_payment(maker_payment_args)).unwrap();
let payment_tx_hash = payment.tx_hash_as_bytes();
let payment_tx_hex = payment.tx_hex();
log!("Maker payment: {:?}", payment_tx_hash);
@@ -544,9 +517,9 @@ fn test_check_if_my_payment_sent() {
wait_until,
check_every,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let search_from_block = coin.current_block().wait().expect("!current_block") - 10;
+ let search_from_block = block_on_f01(coin.current_block()).expect("!current_block") - 10;
let if_my_payment_sent_args = CheckIfMyPaymentSentArgs {
time_lock: timelock,
other_pub: &taker_pub,
@@ -557,7 +530,7 @@ fn test_check_if_my_payment_sent() {
amount: &amount,
payment_instructions: &None,
};
- let found = coin.check_if_my_payment_sent(if_my_payment_sent_args).wait().unwrap();
+ let found = block_on_f01(coin.check_if_my_payment_sent(if_my_payment_sent_args)).unwrap();
assert_eq!(found, Some(payment));
}
@@ -565,7 +538,7 @@ fn test_check_if_my_payment_sent() {
fn test_search_for_swap_tx_spend_taker_spent() {
let (_ctx, maker_coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 10.into());
let (_ctx, taker_coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 1.into());
- let search_from_block = maker_coin.current_block().wait().expect("!current_block");
+ let search_from_block = block_on_f01(maker_coin.current_block()).expect("!current_block");
let timelock = now_sec() - 200;
let maker_pub = maker_coin.my_public_key().unwrap();
@@ -585,7 +558,7 @@ fn test_search_for_swap_tx_spend_taker_spent() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let payment = maker_coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let payment = block_on_f01(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
let payment_tx_hash = payment.tx_hash_as_bytes();
let payment_tx_hex = payment.tx_hex();
log!("Maker payment: {:?}", payment_tx_hash);
@@ -601,7 +574,7 @@ fn test_search_for_swap_tx_spend_taker_spent() {
wait_until,
check_every,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let taker_spends_payment_args = SpendPaymentArgs {
other_payment_tx: &payment_tx_hex,
time_lock: timelock,
@@ -625,7 +598,7 @@ fn test_search_for_swap_tx_spend_taker_spent() {
wait_until,
check_every,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock: timelock,
@@ -645,7 +618,7 @@ fn test_search_for_swap_tx_spend_taker_spent() {
#[test]
fn test_search_for_swap_tx_spend_maker_refunded() {
let (_ctx, maker_coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 10.into());
- let search_from_block = maker_coin.current_block().wait().expect("!current_block");
+ let search_from_block = block_on_f01(maker_coin.current_block()).expect("!current_block");
let timelock = now_sec() - 200;
let taker_pub = hex::decode("022b00078841f37b5d30a6a1defb82b3af4d4e2d24dd4204d41f0c9ce1e875de1a").unwrap();
@@ -664,7 +637,7 @@ fn test_search_for_swap_tx_spend_maker_refunded() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let payment = maker_coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let payment = block_on_f01(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
let payment_tx_hash = payment.tx_hash_as_bytes();
let payment_tx_hex = payment.tx_hex();
log!("Maker payment: {:?}", payment_tx_hash);
@@ -680,7 +653,7 @@ fn test_search_for_swap_tx_spend_maker_refunded() {
wait_until,
check_every,
};
- maker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(maker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let maker_refunds_payment_args = RefundPaymentArgs {
payment_tx: &payment_tx_hex,
time_lock: timelock,
@@ -705,7 +678,7 @@ fn test_search_for_swap_tx_spend_maker_refunded() {
wait_until,
check_every,
};
- maker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(maker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock: timelock,
@@ -725,7 +698,7 @@ fn test_search_for_swap_tx_spend_maker_refunded() {
#[test]
fn test_search_for_swap_tx_spend_not_spent() {
let (_ctx, maker_coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 10.into());
- let search_from_block = maker_coin.current_block().wait().expect("!current_block");
+ let search_from_block = block_on_f01(maker_coin.current_block()).expect("!current_block");
let timelock = now_sec() - 200;
let taker_pub = hex::decode("022b00078841f37b5d30a6a1defb82b3af4d4e2d24dd4204d41f0c9ce1e875de1a").unwrap();
@@ -744,7 +717,7 @@ fn test_search_for_swap_tx_spend_not_spent() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let payment = maker_coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let payment = block_on_f01(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
let payment_tx_hash = payment.tx_hash_as_bytes();
let payment_tx_hex = payment.tx_hex();
log!("Maker payment: {:?}", payment_tx_hash);
@@ -760,7 +733,7 @@ fn test_search_for_swap_tx_spend_not_spent() {
wait_until,
check_every,
};
- maker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(maker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock: timelock,
@@ -781,7 +754,7 @@ fn test_search_for_swap_tx_spend_not_spent() {
fn test_wait_for_tx_spend() {
let (_ctx, maker_coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 10.into());
let (_ctx, taker_coin, _priv_key) = generate_qrc20_coin_with_random_privkey("QICK", 20.into(), 1.into());
- let from_block = maker_coin.current_block().wait().expect("!current_block");
+ let from_block = block_on_f01(maker_coin.current_block()).expect("!current_block");
let timelock = now_sec() - 200;
let maker_pub = maker_coin.my_public_key().unwrap();
@@ -801,7 +774,7 @@ fn test_wait_for_tx_spend() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let payment = maker_coin.send_maker_payment(maker_payment_args).wait().unwrap();
+ let payment = block_on_f01(maker_coin.send_maker_payment(maker_payment_args)).unwrap();
let payment_tx_hash = payment.tx_hash_as_bytes();
let payment_tx_hex = payment.tx_hex();
log!("Maker payment: {:?}", payment_tx_hash);
@@ -817,22 +790,20 @@ fn test_wait_for_tx_spend() {
wait_until,
check_every,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
// first try to check if the wait_for_htlc_tx_spend() returns an error correctly
let wait_until = wait_until_sec(5);
- let tx_err = maker_coin
- .wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
- tx_bytes: &payment_tx_hex,
- secret_hash: &[],
- wait_until,
- from_block,
- swap_contract_address: &maker_coin.swap_contract_address(),
- check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
- watcher_reward: false,
- })
- .wait()
- .expect_err("Expected 'Waited too long' error");
+ let tx_err = block_on_f01(maker_coin.wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
+ tx_bytes: &payment_tx_hex,
+ secret_hash: &[],
+ wait_until,
+ from_block,
+ swap_contract_address: &maker_coin.swap_contract_address(),
+ check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
+ watcher_reward: false,
+ }))
+ .expect_err("Expected 'Waited too long' error");
let err = tx_err.get_plain_text_format();
log!("error: {:?}", err);
@@ -860,18 +831,16 @@ fn test_wait_for_tx_spend() {
});
let wait_until = wait_until_sec(120);
- let found = maker_coin
- .wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
- tx_bytes: &payment_tx_hex,
- secret_hash: &[],
- wait_until,
- from_block,
- swap_contract_address: &maker_coin.swap_contract_address(),
- check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
- watcher_reward: false,
- })
- .wait()
- .unwrap();
+ let found = block_on_f01(maker_coin.wait_for_htlc_tx_spend(WaitForHTLCTxSpendArgs {
+ tx_bytes: &payment_tx_hex,
+ secret_hash: &[],
+ wait_until,
+ from_block,
+ swap_contract_address: &maker_coin.swap_contract_address(),
+ check_every: TAKER_PAYMENT_SPEND_SEARCH_INTERVAL,
+ watcher_reward: false,
+ }))
+ .unwrap();
unsafe { assert_eq!(Some(found), SPEND_TX) }
}
@@ -1030,7 +999,7 @@ fn test_get_max_taker_vol_and_trade_with_dynamic_trade_fee(coin: QtumCoin, priv_
log!("{:?}", block_on(enable_native(&mm, "MYCOIN", &[], None)));
log!("{:?}", block_on(enable_native(&mm, "QTUM", &[], None)));
- let qtum_balance = coin.my_spendable_balance().wait().expect("!my_balance");
+ let qtum_balance = block_on_f01(coin.my_spendable_balance()).expect("!my_balance");
let qtum_min_tx_amount = MmNumber::from("0.000728");
// - `max_possible = balance - locked_amount`, where `locked_amount = 0`
@@ -1103,10 +1072,8 @@ fn test_get_max_taker_vol_and_trade_with_dynamic_trade_fee(coin: QtumCoin, priv_
let secret_hash = &[0; 20];
let dex_fee = dex_fee_amount("QTUM", "MYCOIN", &expected_max_taker_vol, &qtum_min_tx_amount);
- let _taker_fee_tx = coin
- .send_taker_fee(&DEX_FEE_ADDR_RAW_PUBKEY, dex_fee, &[], timelock)
- .wait()
- .expect("!send_taker_fee");
+ let _taker_fee_tx =
+ block_on_f01(coin.send_taker_fee(&DEX_FEE_ADDR_RAW_PUBKEY, dex_fee, &[], timelock)).expect("!send_taker_fee");
let taker_payment_args = SendPaymentArgs {
time_lock_duration: 0,
time_lock: timelock,
@@ -1120,12 +1087,9 @@ fn test_get_max_taker_vol_and_trade_with_dynamic_trade_fee(coin: QtumCoin, priv_
wait_for_confirmation_until: 0,
};
- let _taker_payment_tx = coin
- .send_taker_payment(taker_payment_args)
- .wait()
- .expect("!send_taker_payment");
+ let _taker_payment_tx = block_on_f01(coin.send_taker_payment(taker_payment_args)).expect("!send_taker_payment");
- let my_balance = coin.my_spendable_balance().wait().expect("!my_balance");
+ let my_balance = block_on_f01(coin.my_spendable_balance()).expect("!my_balance");
assert_eq!(
my_balance,
BigDecimal::from(0u32),
@@ -1519,7 +1483,7 @@ fn test_search_for_segwit_swap_tx_spend_native_was_refunded_maker() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let tx = coin.send_maker_payment(maker_payment).wait().unwrap();
+ let tx = block_on_f01(coin.send_maker_payment(maker_payment)).unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: tx.tx_hex(),
@@ -1528,7 +1492,7 @@ fn test_search_for_segwit_swap_tx_spend_native_was_refunded_maker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let maker_refunds_payment_args = RefundPaymentArgs {
payment_tx: &tx.tx_hex(),
time_lock,
@@ -1549,7 +1513,7 @@ fn test_search_for_segwit_swap_tx_spend_native_was_refunded_maker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
@@ -1587,7 +1551,7 @@ fn test_search_for_segwit_swap_tx_spend_native_was_refunded_taker() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let tx = coin.send_taker_payment(taker_payment).wait().unwrap();
+ let tx = block_on_f01(coin.send_taker_payment(taker_payment)).unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: tx.tx_hex(),
@@ -1596,7 +1560,7 @@ fn test_search_for_segwit_swap_tx_spend_native_was_refunded_taker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let maker_refunds_payment_args = RefundPaymentArgs {
payment_tx: &tx.tx_hex(),
time_lock,
@@ -1617,7 +1581,7 @@ fn test_search_for_segwit_swap_tx_spend_native_was_refunded_taker() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
@@ -1741,26 +1705,23 @@ fn test_send_taker_fee_qtum() {
generate_segwit_qtum_coin_with_random_privkey("QTUM", BigDecimal::try_from(0.5).unwrap(), Some(0));
let amount = BigDecimal::from_str("0.01").unwrap();
- let tx = coin
- .send_taker_fee(
- &DEX_FEE_ADDR_RAW_PUBKEY,
- DexFee::Standard(amount.clone().into()),
- &[],
- 0,
- )
- .wait()
- .expect("!send_taker_fee");
+ let tx = block_on_f01(coin.send_taker_fee(
+ &DEX_FEE_ADDR_RAW_PUBKEY,
+ DexFee::Standard(amount.clone().into()),
+ &[],
+ 0,
+ ))
+ .expect("!send_taker_fee");
assert!(matches!(tx, TransactionEnum::UtxoTx(_)), "Expected UtxoTx");
- coin.validate_fee(ValidateFeeArgs {
+ block_on_f01(coin.validate_fee(ValidateFeeArgs {
fee_tx: &tx,
expected_sender: coin.my_public_key().unwrap(),
fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
dex_fee: &DexFee::Standard(amount.into()),
min_block_number: 0,
uuid: &[],
- })
- .wait()
+ }))
.expect("!validate_fee");
}
@@ -1773,25 +1734,22 @@ fn test_send_taker_fee_qrc20() {
);
let amount = BigDecimal::from_str("0.01").unwrap();
- let tx = coin
- .send_taker_fee(
- &DEX_FEE_ADDR_RAW_PUBKEY,
- DexFee::Standard(amount.clone().into()),
- &[],
- 0,
- )
- .wait()
- .expect("!send_taker_fee");
+ let tx = block_on_f01(coin.send_taker_fee(
+ &DEX_FEE_ADDR_RAW_PUBKEY,
+ DexFee::Standard(amount.clone().into()),
+ &[],
+ 0,
+ ))
+ .expect("!send_taker_fee");
assert!(matches!(tx, TransactionEnum::UtxoTx(_)), "Expected UtxoTx");
- coin.validate_fee(ValidateFeeArgs {
+ block_on_f01(coin.validate_fee(ValidateFeeArgs {
fee_tx: &tx,
expected_sender: coin.my_public_key().unwrap(),
fee_addr: &DEX_FEE_ADDR_RAW_PUBKEY,
dex_fee: &DexFee::Standard(amount.into()),
min_block_number: 0,
uuid: &[],
- })
- .wait()
+ }))
.expect("!validate_fee");
}
diff --git a/mm2src/mm2_main/tests/docker_tests/swap_proto_v2_tests.rs b/mm2src/mm2_main/tests/docker_tests/swap_proto_v2_tests.rs
index 672ef88aa5..46d950242d 100644
--- a/mm2src/mm2_main/tests/docker_tests/swap_proto_v2_tests.rs
+++ b/mm2src/mm2_main/tests/docker_tests/swap_proto_v2_tests.rs
@@ -6,8 +6,7 @@ use coins::{ConfirmPaymentInput, DexFee, FundingTxSpend, GenTakerFundingSpendArg
RefundMakerPaymentSecretArgs, RefundMakerPaymentTimelockArgs, RefundTakerPaymentArgs,
SendMakerPaymentArgs, SendTakerFundingArgs, SwapTxTypeWithSecretHash, TakerCoinSwapOpsV2, Transaction,
ValidateMakerPaymentArgs, ValidateTakerFundingArgs};
-use common::{block_on, now_sec, DEX_FEE_ADDR_RAW_PUBKEY};
-use futures01::Future;
+use common::{block_on, block_on_f01, now_sec, DEX_FEE_ADDR_RAW_PUBKEY};
use mm2_number::MmNumber;
use mm2_test_helpers::for_tests::{active_swaps, check_recent_swaps, coins_needed_for_kickstart, disable_coin,
disable_coin_err, enable_native, get_locked_amount, mm_dump, my_swap_status,
@@ -93,7 +92,7 @@ fn send_and_refund_taker_funding_timelock() {
wait_until: now_sec() + 20,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_input)).unwrap();
let found_refund_tx =
block_on(coin.search_for_taker_funding_spend(&taker_funding_utxo_tx, 1, taker_secret_hash)).unwrap();
@@ -180,7 +179,7 @@ fn send_and_refund_taker_funding_secret() {
wait_until: now_sec() + 20,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_input)).unwrap();
let found_refund_tx =
block_on(coin.search_for_taker_funding_spend(&taker_funding_utxo_tx, 1, taker_secret_hash)).unwrap();
@@ -268,7 +267,7 @@ fn send_and_spend_taker_funding() {
wait_until: now_sec() + 20,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_input)).unwrap();
let found_spend_tx =
block_on(taker_coin.search_for_taker_funding_spend(&taker_funding_utxo_tx, 1, taker_secret_hash)).unwrap();
diff --git a/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs b/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs
index 22c17c1444..aadda99709 100644
--- a/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs
+++ b/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs
@@ -13,9 +13,8 @@ use coins::{ConfirmPaymentInput, FoundSwapTxSpend, MarketCoinOps, MmCoin, MmCoin
INVALID_CONTRACT_ADDRESS_ERR_LOG, INVALID_PAYMENT_STATE_ERR_LOG, INVALID_RECEIVER_ERR_LOG,
INVALID_REFUND_TX_ERR_LOG, INVALID_SCRIPT_ERR_LOG, INVALID_SENDER_ERR_LOG, INVALID_SWAP_ID_ERR_LOG,
OLD_TRANSACTION_ERR_LOG};
-use common::{block_on, now_sec, wait_until_sec, DEX_FEE_ADDR_RAW_PUBKEY};
+use common::{block_on, block_on_f01, now_sec, wait_until_sec, DEX_FEE_ADDR_RAW_PUBKEY};
use crypto::privkey::{key_pair_from_secret, key_pair_from_seed};
-use futures01::Future;
use mm2_main::lp_swap::{dex_fee_amount, dex_fee_amount_from_taker_coin, generate_secret, get_payment_locktime,
MAKER_PAYMENT_SENT_LOG, MAKER_PAYMENT_SPEND_FOUND_LOG, MAKER_PAYMENT_SPEND_SENT_LOG,
REFUND_TEST_FAILURE_LOG, TAKER_PAYMENT_REFUND_SENT_LOG, WATCHER_MESSAGE_SENT_LOG};
@@ -1208,15 +1207,13 @@ fn test_watcher_validate_taker_fee_utxo() {
let taker_amount = MmNumber::from((10, 1));
let fee_amount = dex_fee_amount_from_taker_coin(&taker_coin, maker_coin.ticker(), &taker_amount);
- let taker_fee = taker_coin
- .send_taker_fee(
- &DEX_FEE_ADDR_RAW_PUBKEY,
- fee_amount,
- Uuid::new_v4().as_bytes(),
- lock_duration,
- )
- .wait()
- .unwrap();
+ let taker_fee = block_on_f01(taker_coin.send_taker_fee(
+ &DEX_FEE_ADDR_RAW_PUBKEY,
+ fee_amount,
+ Uuid::new_v4().as_bytes(),
+ lock_duration,
+ ))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_fee.tx_hex(),
@@ -1226,30 +1223,26 @@ fn test_watcher_validate_taker_fee_utxo() {
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let validate_taker_fee_res = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: taker_pubkey.to_vec(),
- min_block_number: 0,
- fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
- lock_duration,
- })
- .wait();
+ let validate_taker_fee_res = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: taker_pubkey.to_vec(),
+ min_block_number: 0,
+ fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
+ lock_duration,
+ }));
assert!(validate_taker_fee_res.is_ok());
- let error = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: maker_coin.my_public_key().unwrap().to_vec(),
- min_block_number: 0,
- fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
- lock_duration,
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: maker_coin.my_public_key().unwrap().to_vec(),
+ min_block_number: 0,
+ fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
+ lock_duration,
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
@@ -1259,17 +1252,15 @@ fn test_watcher_validate_taker_fee_utxo() {
_ => panic!("Expected `WrongPaymentTx` invalid public key, found {:?}", error),
}
- let error = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: taker_pubkey.to_vec(),
- min_block_number: std::u64::MAX,
- fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
- lock_duration,
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: taker_pubkey.to_vec(),
+ min_block_number: std::u64::MAX,
+ fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
+ lock_duration,
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -1281,17 +1272,15 @@ fn test_watcher_validate_taker_fee_utxo() {
),
}
- let error = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: taker_pubkey.to_vec(),
- min_block_number: 0,
- fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
- lock_duration: 0,
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: taker_pubkey.to_vec(),
+ min_block_number: 0,
+ fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
+ lock_duration: 0,
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -1300,17 +1289,15 @@ fn test_watcher_validate_taker_fee_utxo() {
_ => panic!("Expected `WrongPaymentTx` transaction too old, found {:?}", error),
}
- let error = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: taker_pubkey.to_vec(),
- min_block_number: 0,
- fee_addr: taker_pubkey.to_vec(),
- lock_duration,
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: taker_pubkey.to_vec(),
+ min_block_number: 0,
+ fee_addr: taker_pubkey.to_vec(),
+ lock_duration,
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -1334,15 +1321,13 @@ fn test_watcher_validate_taker_fee_eth() {
let taker_amount = MmNumber::from((1, 1));
let fee_amount = dex_fee_amount_from_taker_coin(&taker_coin, "ETH", &taker_amount);
- let taker_fee = taker_coin
- .send_taker_fee(
- &DEX_FEE_ADDR_RAW_PUBKEY,
- fee_amount,
- Uuid::new_v4().as_bytes(),
- lock_duration,
- )
- .wait()
- .unwrap();
+ let taker_fee = block_on_f01(taker_coin.send_taker_fee(
+ &DEX_FEE_ADDR_RAW_PUBKEY,
+ fee_amount,
+ Uuid::new_v4().as_bytes(),
+ lock_duration,
+ ))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_fee.tx_hex(),
@@ -1351,31 +1336,27 @@ fn test_watcher_validate_taker_fee_eth() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
-
- let validate_taker_fee_res = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: taker_pubkey.to_vec(),
- min_block_number: 0,
- fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
- lock_duration,
- })
- .wait();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
+
+ let validate_taker_fee_res = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: taker_pubkey.to_vec(),
+ min_block_number: 0,
+ fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
+ lock_duration,
+ }));
assert!(validate_taker_fee_res.is_ok());
let wrong_keypair = key_pair_from_secret(random_secp256k1_secret().as_slice()).unwrap();
- let error = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: wrong_keypair.public().to_vec(),
- min_block_number: 0,
- fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
- lock_duration,
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: wrong_keypair.public().to_vec(),
+ min_block_number: 0,
+ fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
+ lock_duration,
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
@@ -1385,17 +1366,15 @@ fn test_watcher_validate_taker_fee_eth() {
_ => panic!("Expected `WrongPaymentTx` invalid public key, found {:?}", error),
}
- let error = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: taker_pubkey.to_vec(),
- min_block_number: std::u64::MAX,
- fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
- lock_duration,
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: taker_pubkey.to_vec(),
+ min_block_number: std::u64::MAX,
+ fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
+ lock_duration,
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -1407,17 +1386,15 @@ fn test_watcher_validate_taker_fee_eth() {
),
}
- let error = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: taker_pubkey.to_vec(),
- min_block_number: 0,
- fee_addr: taker_pubkey.to_vec(),
- lock_duration,
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: taker_pubkey.to_vec(),
+ min_block_number: 0,
+ fee_addr: taker_pubkey.to_vec(),
+ lock_duration,
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -1441,15 +1418,13 @@ fn test_watcher_validate_taker_fee_erc20() {
let taker_amount = MmNumber::from((1, 1));
let fee_amount = dex_fee_amount_from_taker_coin(&taker_coin, "ETH", &taker_amount);
- let taker_fee = taker_coin
- .send_taker_fee(
- &DEX_FEE_ADDR_RAW_PUBKEY,
- fee_amount,
- Uuid::new_v4().as_bytes(),
- lock_duration,
- )
- .wait()
- .unwrap();
+ let taker_fee = block_on_f01(taker_coin.send_taker_fee(
+ &DEX_FEE_ADDR_RAW_PUBKEY,
+ fee_amount,
+ Uuid::new_v4().as_bytes(),
+ lock_duration,
+ ))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_fee.tx_hex(),
@@ -1458,31 +1433,27 @@ fn test_watcher_validate_taker_fee_erc20() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
-
- let validate_taker_fee_res = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: taker_pubkey.to_vec(),
- min_block_number: 0,
- fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
- lock_duration,
- })
- .wait();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
+
+ let validate_taker_fee_res = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: taker_pubkey.to_vec(),
+ min_block_number: 0,
+ fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
+ lock_duration,
+ }));
assert!(validate_taker_fee_res.is_ok());
let wrong_keypair = key_pair_from_secret(random_secp256k1_secret().as_slice()).unwrap();
- let error = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: wrong_keypair.public().to_vec(),
- min_block_number: 0,
- fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
- lock_duration,
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: wrong_keypair.public().to_vec(),
+ min_block_number: 0,
+ fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
+ lock_duration,
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
@@ -1492,17 +1463,15 @@ fn test_watcher_validate_taker_fee_erc20() {
_ => panic!("Expected `WrongPaymentTx` invalid public key, found {:?}", error),
}
- let error = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: taker_pubkey.to_vec(),
- min_block_number: std::u64::MAX,
- fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
- lock_duration,
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: taker_pubkey.to_vec(),
+ min_block_number: std::u64::MAX,
+ fee_addr: DEX_FEE_ADDR_RAW_PUBKEY.to_vec(),
+ lock_duration,
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -1514,17 +1483,15 @@ fn test_watcher_validate_taker_fee_erc20() {
),
}
- let error = taker_coin
- .watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
- taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
- sender_pubkey: taker_pubkey.to_vec(),
- min_block_number: 0,
- fee_addr: taker_pubkey.to_vec(),
- lock_duration,
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_fee(WatcherValidateTakerFeeInput {
+ taker_fee_hash: taker_fee.tx_hash_as_bytes().into_vec(),
+ sender_pubkey: taker_pubkey.to_vec(),
+ min_block_number: 0,
+ fee_addr: taker_pubkey.to_vec(),
+ lock_duration,
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -1552,21 +1519,19 @@ fn test_watcher_validate_taker_payment_utxo() {
let secret_hash = dhash160(&generate_secret().unwrap());
- let taker_payment = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pubkey,
- secret_hash: secret_hash.as_slice(),
- amount: BigDecimal::from(10),
- swap_contract_address: &None,
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: None,
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pubkey,
+ secret_hash: secret_hash.as_slice(),
+ amount: BigDecimal::from(10),
+ swap_contract_address: &None,
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: None,
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_payment.tx_hex(),
@@ -1575,21 +1540,19 @@ fn test_watcher_validate_taker_payment_utxo() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let taker_payment_refund_preimage = taker_coin
- .create_taker_payment_refund_preimage(
- &taker_payment.tx_hex(),
- time_lock,
- maker_pubkey,
- secret_hash.as_slice(),
- &None,
- &[],
- )
- .wait()
- .unwrap();
- let validate_taker_payment_res = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ let taker_payment_refund_preimage = block_on_f01(taker_coin.create_taker_payment_refund_preimage(
+ &taker_payment.tx_hex(),
+ time_lock,
+ maker_pubkey,
+ secret_hash.as_slice(),
+ &None,
+ &[],
+ ))
+ .unwrap();
+ let validate_taker_payment_res =
+ block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
payment_tx: taker_payment.tx_hex(),
taker_payment_refund_preimage: taker_payment_refund_preimage.tx_hex(),
time_lock,
@@ -1599,25 +1562,22 @@ fn test_watcher_validate_taker_payment_utxo() {
wait_until: timeout,
confirmations: 1,
maker_coin: MmCoinEnum::UtxoCoin(maker_coin.clone()),
- })
- .wait();
+ }));
assert!(validate_taker_payment_res.is_ok());
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment.tx_hex(),
- taker_payment_refund_preimage: taker_payment_refund_preimage.tx_hex(),
- time_lock,
- taker_pub: maker_pubkey.to_vec(),
- maker_pub: maker_pubkey.to_vec(),
- secret_hash: secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::UtxoCoin(maker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment.tx_hex(),
+ taker_payment_refund_preimage: taker_payment_refund_preimage.tx_hex(),
+ time_lock,
+ taker_pub: maker_pubkey.to_vec(),
+ maker_pub: maker_pubkey.to_vec(),
+ secret_hash: secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::UtxoCoin(maker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
@@ -1629,21 +1589,19 @@ fn test_watcher_validate_taker_payment_utxo() {
// Used to get wrong swap id
let wrong_secret_hash = dhash160(&generate_secret().unwrap());
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment.tx_hex(),
- taker_payment_refund_preimage: taker_payment_refund_preimage.tx_hex(),
- time_lock,
- taker_pub: taker_pubkey.to_vec(),
- maker_pub: maker_pubkey.to_vec(),
- secret_hash: wrong_secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::UtxoCoin(maker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment.tx_hex(),
+ taker_payment_refund_preimage: taker_payment_refund_preimage.tx_hex(),
+ time_lock,
+ taker_pub: taker_pubkey.to_vec(),
+ maker_pub: maker_pubkey.to_vec(),
+ secret_hash: wrong_secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::UtxoCoin(maker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
@@ -1656,21 +1614,19 @@ fn test_watcher_validate_taker_payment_utxo() {
),
}
- let taker_payment_wrong_secret = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pubkey,
- secret_hash: wrong_secret_hash.as_slice(),
- amount: BigDecimal::from(10),
- swap_contract_address: &taker_coin.swap_contract_address(),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: None,
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment_wrong_secret = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pubkey,
+ secret_hash: wrong_secret_hash.as_slice(),
+ amount: BigDecimal::from(10),
+ swap_contract_address: &taker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: None,
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_payment_wrong_secret.tx_hex(),
@@ -1679,23 +1635,21 @@ fn test_watcher_validate_taker_payment_utxo() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment.tx_hex(),
- taker_payment_refund_preimage: taker_payment_refund_preimage.tx_hex(),
- time_lock: 500,
- taker_pub: taker_pubkey.to_vec(),
- maker_pub: maker_pubkey.to_vec(),
- secret_hash: wrong_secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::UtxoCoin(maker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment.tx_hex(),
+ taker_payment_refund_preimage: taker_payment_refund_preimage.tx_hex(),
+ time_lock: 500,
+ taker_pub: taker_pubkey.to_vec(),
+ maker_pub: maker_pubkey.to_vec(),
+ secret_hash: wrong_secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::UtxoCoin(maker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
@@ -1708,33 +1662,29 @@ fn test_watcher_validate_taker_payment_utxo() {
),
}
- let wrong_taker_payment_refund_preimage = taker_coin
- .create_taker_payment_refund_preimage(
- &taker_payment.tx_hex(),
- time_lock,
- maker_pubkey,
- wrong_secret_hash.as_slice(),
- &None,
- &[],
- )
- .wait()
- .unwrap();
+ let wrong_taker_payment_refund_preimage = block_on_f01(taker_coin.create_taker_payment_refund_preimage(
+ &taker_payment.tx_hex(),
+ time_lock,
+ maker_pubkey,
+ wrong_secret_hash.as_slice(),
+ &None,
+ &[],
+ ))
+ .unwrap();
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment.tx_hex(),
- taker_payment_refund_preimage: wrong_taker_payment_refund_preimage.tx_hex(),
- time_lock,
- taker_pub: taker_pubkey.to_vec(),
- maker_pub: maker_pubkey.to_vec(),
- secret_hash: secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::UtxoCoin(maker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment.tx_hex(),
+ taker_payment_refund_preimage: wrong_taker_payment_refund_preimage.tx_hex(),
+ time_lock,
+ taker_pub: taker_pubkey.to_vec(),
+ maker_pub: maker_pubkey.to_vec(),
+ secret_hash: secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::UtxoCoin(maker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
@@ -1777,21 +1727,19 @@ fn test_watcher_validate_taker_payment_eth() {
.unwrap(),
);
- let taker_payment = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pub,
- secret_hash: secret_hash.as_slice(),
- amount: taker_amount.clone(),
- swap_contract_address: &taker_coin.swap_contract_address(),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: watcher_reward.clone(),
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pub,
+ secret_hash: secret_hash.as_slice(),
+ amount: taker_amount.clone(),
+ swap_contract_address: &taker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: watcher_reward.clone(),
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_payment.tx_hex(),
@@ -1800,10 +1748,10 @@ fn test_watcher_validate_taker_payment_eth() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let validate_taker_payment_res = taker_coin
- .watcher_validate_taker_payment(coins::WatcherValidatePaymentInput {
+ let validate_taker_payment_res = block_on_f01(taker_coin.watcher_validate_taker_payment(
+ coins::WatcherValidatePaymentInput {
payment_tx: taker_payment.tx_hex(),
taker_payment_refund_preimage: Vec::new(),
time_lock,
@@ -1813,12 +1761,12 @@ fn test_watcher_validate_taker_payment_eth() {
wait_until: timeout,
confirmations: 1,
maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait();
+ },
+ ));
assert!(validate_taker_payment_res.is_ok());
- let error = taker_coin
- .watcher_validate_taker_payment(coins::WatcherValidatePaymentInput {
+ let error = block_on_f01(
+ taker_coin.watcher_validate_taker_payment(coins::WatcherValidatePaymentInput {
payment_tx: taker_payment.tx_hex(),
taker_payment_refund_preimage: Vec::new(),
time_lock,
@@ -1828,10 +1776,10 @@ fn test_watcher_validate_taker_payment_eth() {
wait_until: timeout,
confirmations: 1,
maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ }),
+ )
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -1843,24 +1791,22 @@ fn test_watcher_validate_taker_payment_eth() {
),
}
- let taker_payment_wrong_contract = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pub,
- secret_hash: secret_hash.as_slice(),
- amount: taker_amount.clone(),
- swap_contract_address: &Some("9130b257d37a52e52f21054c4da3450c72f595ce".into()),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: watcher_reward.clone(),
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment_wrong_contract = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pub,
+ secret_hash: secret_hash.as_slice(),
+ amount: taker_amount.clone(),
+ swap_contract_address: &Some("9130b257d37a52e52f21054c4da3450c72f595ce".into()),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: watcher_reward.clone(),
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
- let error = taker_coin
- .watcher_validate_taker_payment(coins::WatcherValidatePaymentInput {
+ let error = block_on_f01(
+ taker_coin.watcher_validate_taker_payment(coins::WatcherValidatePaymentInput {
payment_tx: taker_payment_wrong_contract.tx_hex(),
taker_payment_refund_preimage: Vec::new(),
time_lock,
@@ -1870,10 +1816,10 @@ fn test_watcher_validate_taker_payment_eth() {
wait_until: timeout,
confirmations: 1,
maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ }),
+ )
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -1887,8 +1833,8 @@ fn test_watcher_validate_taker_payment_eth() {
// Used to get wrong swap id
let wrong_secret_hash = dhash160(&generate_secret().unwrap());
- let error = taker_coin
- .watcher_validate_taker_payment(coins::WatcherValidatePaymentInput {
+ let error = block_on_f01(
+ taker_coin.watcher_validate_taker_payment(coins::WatcherValidatePaymentInput {
payment_tx: taker_payment.tx_hex(),
taker_payment_refund_preimage: Vec::new(),
time_lock,
@@ -1898,10 +1844,10 @@ fn test_watcher_validate_taker_payment_eth() {
wait_until: timeout,
confirmations: 1,
maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ }),
+ )
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::UnexpectedPaymentState(err) => {
@@ -1913,21 +1859,19 @@ fn test_watcher_validate_taker_payment_eth() {
),
}
- let taker_payment_wrong_secret = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pub,
- secret_hash: wrong_secret_hash.as_slice(),
- amount: taker_amount,
- swap_contract_address: &taker_coin.swap_contract_address(),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward,
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment_wrong_secret = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pub,
+ secret_hash: wrong_secret_hash.as_slice(),
+ amount: taker_amount,
+ swap_contract_address: &taker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward,
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_payment_wrong_secret.tx_hex(),
@@ -1936,23 +1880,21 @@ fn test_watcher_validate_taker_payment_eth() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment.tx_hex(),
- taker_payment_refund_preimage: Vec::new(),
- time_lock,
- taker_pub: taker_pub.to_vec(),
- maker_pub: maker_pub.to_vec(),
- secret_hash: wrong_secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment.tx_hex(),
+ taker_payment_refund_preimage: Vec::new(),
+ time_lock,
+ taker_pub: taker_pub.to_vec(),
+ maker_pub: maker_pub.to_vec(),
+ secret_hash: wrong_secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -1964,21 +1906,19 @@ fn test_watcher_validate_taker_payment_eth() {
),
}
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment.tx_hex(),
- taker_payment_refund_preimage: Vec::new(),
- time_lock,
- taker_pub: taker_pub.to_vec(),
- maker_pub: taker_pub.to_vec(),
- secret_hash: secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment.tx_hex(),
+ taker_payment_refund_preimage: Vec::new(),
+ time_lock,
+ taker_pub: taker_pub.to_vec(),
+ maker_pub: taker_pub.to_vec(),
+ secret_hash: secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -2023,21 +1963,19 @@ fn test_watcher_validate_taker_payment_erc20() {
.unwrap(),
);
- let taker_payment = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pub,
- secret_hash: secret_hash.as_slice(),
- amount: taker_amount.clone(),
- swap_contract_address: &taker_coin.swap_contract_address(),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: watcher_reward.clone(),
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pub,
+ secret_hash: secret_hash.as_slice(),
+ amount: taker_amount.clone(),
+ swap_contract_address: &taker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: watcher_reward.clone(),
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_payment.tx_hex(),
@@ -2046,10 +1984,10 @@ fn test_watcher_validate_taker_payment_erc20() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let validate_taker_payment_res = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ let validate_taker_payment_res =
+ block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
payment_tx: taker_payment.tx_hex(),
taker_payment_refund_preimage: Vec::new(),
time_lock,
@@ -2059,25 +1997,22 @@ fn test_watcher_validate_taker_payment_erc20() {
wait_until: timeout,
confirmations: 1,
maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait();
+ }));
assert!(validate_taker_payment_res.is_ok());
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment.tx_hex(),
- taker_payment_refund_preimage: Vec::new(),
- time_lock,
- taker_pub: maker_pub.to_vec(),
- maker_pub: maker_pub.to_vec(),
- secret_hash: secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment.tx_hex(),
+ taker_payment_refund_preimage: Vec::new(),
+ time_lock,
+ taker_pub: maker_pub.to_vec(),
+ maker_pub: maker_pub.to_vec(),
+ secret_hash: secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -2089,37 +2024,33 @@ fn test_watcher_validate_taker_payment_erc20() {
),
}
- let taker_payment_wrong_contract = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pub,
- secret_hash: secret_hash.as_slice(),
- amount: taker_amount.clone(),
- swap_contract_address: &Some("9130b257d37a52e52f21054c4da3450c72f595ce".into()),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: watcher_reward.clone(),
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment_wrong_contract = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pub,
+ secret_hash: secret_hash.as_slice(),
+ amount: taker_amount.clone(),
+ swap_contract_address: &Some("9130b257d37a52e52f21054c4da3450c72f595ce".into()),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: watcher_reward.clone(),
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment_wrong_contract.tx_hex(),
- taker_payment_refund_preimage: Vec::new(),
- time_lock,
- taker_pub: taker_pub.to_vec(),
- maker_pub: maker_pub.to_vec(),
- secret_hash: secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment_wrong_contract.tx_hex(),
+ taker_payment_refund_preimage: Vec::new(),
+ time_lock,
+ taker_pub: taker_pub.to_vec(),
+ maker_pub: maker_pub.to_vec(),
+ secret_hash: secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -2133,21 +2064,19 @@ fn test_watcher_validate_taker_payment_erc20() {
// Used to get wrong swap id
let wrong_secret_hash = dhash160(&generate_secret().unwrap());
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment.tx_hex(),
- taker_payment_refund_preimage: Vec::new(),
- time_lock,
- taker_pub: taker_pub.to_vec(),
- maker_pub: maker_pub.to_vec(),
- secret_hash: wrong_secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment.tx_hex(),
+ taker_payment_refund_preimage: Vec::new(),
+ time_lock,
+ taker_pub: taker_pub.to_vec(),
+ maker_pub: maker_pub.to_vec(),
+ secret_hash: wrong_secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::UnexpectedPaymentState(err) => {
@@ -2159,21 +2088,19 @@ fn test_watcher_validate_taker_payment_erc20() {
),
}
- let taker_payment_wrong_secret = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pub,
- secret_hash: wrong_secret_hash.as_slice(),
- amount: taker_amount,
- swap_contract_address: &taker_coin.swap_contract_address(),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward,
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment_wrong_secret = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pub,
+ secret_hash: wrong_secret_hash.as_slice(),
+ amount: taker_amount,
+ swap_contract_address: &taker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward,
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_payment_wrong_secret.tx_hex(),
@@ -2182,23 +2109,21 @@ fn test_watcher_validate_taker_payment_erc20() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment.tx_hex(),
- taker_payment_refund_preimage: Vec::new(),
- time_lock,
- taker_pub: taker_pub.to_vec(),
- maker_pub: maker_pub.to_vec(),
- secret_hash: wrong_secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment.tx_hex(),
+ taker_payment_refund_preimage: Vec::new(),
+ time_lock,
+ taker_pub: taker_pub.to_vec(),
+ maker_pub: maker_pub.to_vec(),
+ secret_hash: wrong_secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -2210,21 +2135,19 @@ fn test_watcher_validate_taker_payment_erc20() {
),
}
- let error = taker_coin
- .watcher_validate_taker_payment(WatcherValidatePaymentInput {
- payment_tx: taker_payment.tx_hex(),
- taker_payment_refund_preimage: Vec::new(),
- time_lock,
- taker_pub: taker_pub.to_vec(),
- maker_pub: taker_pub.to_vec(),
- secret_hash: secret_hash.to_vec(),
- wait_until: timeout,
- confirmations: 1,
- maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
- })
- .wait()
- .unwrap_err()
- .into_inner();
+ let error = block_on_f01(taker_coin.watcher_validate_taker_payment(WatcherValidatePaymentInput {
+ payment_tx: taker_payment.tx_hex(),
+ taker_payment_refund_preimage: Vec::new(),
+ time_lock,
+ taker_pub: taker_pub.to_vec(),
+ maker_pub: taker_pub.to_vec(),
+ secret_hash: secret_hash.to_vec(),
+ wait_until: timeout,
+ confirmations: 1,
+ maker_coin: MmCoinEnum::EthCoin(taker_coin.clone()),
+ }))
+ .unwrap_err()
+ .into_inner();
log!("error: {:?}", error);
match error {
ValidatePaymentError::WrongPaymentTx(err) => {
@@ -2250,21 +2173,19 @@ fn test_taker_validates_taker_payment_refund_utxo() {
let secret_hash = dhash160(&generate_secret().unwrap());
- let taker_payment = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pubkey,
- secret_hash: secret_hash.as_slice(),
- amount: BigDecimal::from(10),
- swap_contract_address: &None,
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: None,
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pubkey,
+ secret_hash: secret_hash.as_slice(),
+ amount: BigDecimal::from(10),
+ swap_contract_address: &None,
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: None,
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_payment.tx_hex(),
@@ -2273,34 +2194,30 @@ fn test_taker_validates_taker_payment_refund_utxo() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let taker_payment_refund_preimage = taker_coin
- .create_taker_payment_refund_preimage(
- &taker_payment.tx_hex(),
- time_lock,
- maker_pubkey,
- secret_hash.as_slice(),
- &None,
- &[],
- )
- .wait()
- .unwrap();
+ let taker_payment_refund_preimage = block_on_f01(taker_coin.create_taker_payment_refund_preimage(
+ &taker_payment.tx_hex(),
+ time_lock,
+ maker_pubkey,
+ secret_hash.as_slice(),
+ &None,
+ &[],
+ ))
+ .unwrap();
- let taker_payment_refund = taker_coin
- .send_taker_payment_refund_preimage(RefundPaymentArgs {
- payment_tx: &taker_payment_refund_preimage.tx_hex(),
- other_pubkey: maker_pubkey,
- tx_type_with_secret_hash: SwapTxTypeWithSecretHash::TakerOrMakerPayment {
- maker_secret_hash: secret_hash.as_slice(),
- },
- time_lock,
- swap_contract_address: &None,
- swap_unique_data: &[],
- watcher_reward: false,
- })
- .wait()
- .unwrap();
+ let taker_payment_refund = block_on_f01(taker_coin.send_taker_payment_refund_preimage(RefundPaymentArgs {
+ payment_tx: &taker_payment_refund_preimage.tx_hex(),
+ other_pubkey: maker_pubkey,
+ tx_type_with_secret_hash: SwapTxTypeWithSecretHash::TakerOrMakerPayment {
+ maker_secret_hash: secret_hash.as_slice(),
+ },
+ time_lock,
+ swap_contract_address: &None,
+ swap_unique_data: &[],
+ watcher_reward: false,
+ }))
+ .unwrap();
let validate_input = ValidateWatcherSpendInput {
payment_tx: taker_payment_refund.tx_hex(),
@@ -2313,9 +2230,7 @@ fn test_taker_validates_taker_payment_refund_utxo() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let validate_watcher_refund = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait();
+ let validate_watcher_refund = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input));
assert!(validate_watcher_refund.is_ok());
}
@@ -2347,21 +2262,19 @@ fn test_taker_validates_taker_payment_refund_eth() {
))
.unwrap();
- let taker_payment = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pub,
- secret_hash: secret_hash.as_slice(),
- amount: taker_amount.clone(),
- swap_contract_address: &taker_coin.swap_contract_address(),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: Some(watcher_reward.clone()),
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pub,
+ secret_hash: secret_hash.as_slice(),
+ amount: taker_amount.clone(),
+ swap_contract_address: &taker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: Some(watcher_reward.clone()),
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_payment.tx_hex(),
@@ -2370,19 +2283,17 @@ fn test_taker_validates_taker_payment_refund_eth() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let taker_payment_refund_preimage = taker_coin
- .create_taker_payment_refund_preimage(
- &taker_payment.tx_hex(),
- time_lock,
- taker_pub,
- secret_hash.as_slice(),
- &taker_coin.swap_contract_address(),
- &[],
- )
- .wait()
- .unwrap();
+ let taker_payment_refund_preimage = block_on_f01(taker_coin.create_taker_payment_refund_preimage(
+ &taker_payment.tx_hex(),
+ time_lock,
+ taker_pub,
+ secret_hash.as_slice(),
+ &taker_coin.swap_contract_address(),
+ &[],
+ ))
+ .unwrap();
let validate_input = ValidateWatcherSpendInput {
payment_tx: taker_payment_refund_preimage.tx_hex(),
@@ -2395,9 +2306,7 @@ fn test_taker_validates_taker_payment_refund_eth() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -2411,20 +2320,18 @@ fn test_taker_validates_taker_payment_refund_eth() {
),
}
- let taker_payment_refund = taker_coin
- .send_taker_payment_refund_preimage(RefundPaymentArgs {
- payment_tx: &taker_payment_refund_preimage.tx_hex(),
- other_pubkey: taker_pub,
- tx_type_with_secret_hash: SwapTxTypeWithSecretHash::TakerOrMakerPayment {
- maker_secret_hash: secret_hash.as_slice(),
- },
- time_lock,
- swap_contract_address: &taker_coin.swap_contract_address(),
- swap_unique_data: &[],
- watcher_reward: true,
- })
- .wait()
- .unwrap();
+ let taker_payment_refund = block_on_f01(taker_coin.send_taker_payment_refund_preimage(RefundPaymentArgs {
+ payment_tx: &taker_payment_refund_preimage.tx_hex(),
+ other_pubkey: taker_pub,
+ tx_type_with_secret_hash: SwapTxTypeWithSecretHash::TakerOrMakerPayment {
+ maker_secret_hash: secret_hash.as_slice(),
+ },
+ time_lock,
+ swap_contract_address: &taker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ watcher_reward: true,
+ }))
+ .unwrap();
let validate_input = ValidateWatcherSpendInput {
payment_tx: taker_payment_refund.tx_hex(),
@@ -2437,9 +2344,7 @@ fn test_taker_validates_taker_payment_refund_eth() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let validate_watcher_refund = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait();
+ let validate_watcher_refund = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input));
assert!(validate_watcher_refund.is_ok());
let validate_input = ValidateWatcherSpendInput {
@@ -2452,9 +2357,7 @@ fn test_taker_validates_taker_payment_refund_eth() {
watcher_reward: Some(watcher_reward.clone()),
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -2479,9 +2382,7 @@ fn test_taker_validates_taker_payment_refund_eth() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let error = maker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(maker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -2506,9 +2407,7 @@ fn test_taker_validates_taker_payment_refund_eth() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -2536,9 +2435,7 @@ fn test_taker_validates_taker_payment_refund_eth() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -2566,9 +2463,7 @@ fn test_taker_validates_taker_payment_refund_eth() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -2596,9 +2491,7 @@ fn test_taker_validates_taker_payment_refund_eth() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -2623,9 +2516,7 @@ fn test_taker_validates_taker_payment_refund_eth() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -2672,21 +2563,19 @@ fn test_taker_validates_taker_payment_refund_erc20() {
.unwrap(),
);
- let taker_payment = taker_coin
- .send_taker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: maker_pub,
- secret_hash: secret_hash.as_slice(),
- amount: taker_amount.clone(),
- swap_contract_address: &taker_coin.swap_contract_address(),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: watcher_reward.clone(),
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let taker_payment = block_on_f01(taker_coin.send_taker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: maker_pub,
+ secret_hash: secret_hash.as_slice(),
+ amount: taker_amount.clone(),
+ swap_contract_address: &taker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: watcher_reward.clone(),
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: taker_payment.tx_hex(),
@@ -2695,34 +2584,30 @@ fn test_taker_validates_taker_payment_refund_erc20() {
wait_until: timeout,
check_every: 1,
};
- taker_coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(taker_coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let taker_payment_refund_preimage = taker_coin
- .create_taker_payment_refund_preimage(
- &taker_payment.tx_hex(),
- time_lock,
- taker_pub,
- secret_hash.as_slice(),
- &taker_coin.swap_contract_address(),
- &[],
- )
- .wait()
- .unwrap();
+ let taker_payment_refund_preimage = block_on_f01(taker_coin.create_taker_payment_refund_preimage(
+ &taker_payment.tx_hex(),
+ time_lock,
+ taker_pub,
+ secret_hash.as_slice(),
+ &taker_coin.swap_contract_address(),
+ &[],
+ ))
+ .unwrap();
- let taker_payment_refund = taker_coin
- .send_taker_payment_refund_preimage(RefundPaymentArgs {
- payment_tx: &taker_payment_refund_preimage.tx_hex(),
- other_pubkey: taker_pub,
- tx_type_with_secret_hash: SwapTxTypeWithSecretHash::TakerOrMakerPayment {
- maker_secret_hash: secret_hash.as_slice(),
- },
- time_lock,
- swap_contract_address: &taker_coin.swap_contract_address(),
- swap_unique_data: &[],
- watcher_reward: true,
- })
- .wait()
- .unwrap();
+ let taker_payment_refund = block_on_f01(taker_coin.send_taker_payment_refund_preimage(RefundPaymentArgs {
+ payment_tx: &taker_payment_refund_preimage.tx_hex(),
+ other_pubkey: taker_pub,
+ tx_type_with_secret_hash: SwapTxTypeWithSecretHash::TakerOrMakerPayment {
+ maker_secret_hash: secret_hash.as_slice(),
+ },
+ time_lock,
+ swap_contract_address: &taker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ watcher_reward: true,
+ }))
+ .unwrap();
let validate_input = ValidateWatcherSpendInput {
payment_tx: taker_payment_refund.tx_hex(),
@@ -2735,9 +2620,7 @@ fn test_taker_validates_taker_payment_refund_erc20() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let validate_watcher_refund = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait();
+ let validate_watcher_refund = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input));
assert!(validate_watcher_refund.is_ok());
let validate_input = ValidateWatcherSpendInput {
@@ -2751,9 +2634,7 @@ fn test_taker_validates_taker_payment_refund_erc20() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -2783,54 +2664,48 @@ fn test_taker_validates_maker_payment_spend_utxo() {
let secret = generate_secret().unwrap();
let secret_hash = dhash160(&secret);
- let maker_payment = maker_coin
- .send_maker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: taker_pubkey,
- secret_hash: secret_hash.as_slice(),
- amount: BigDecimal::from(10),
- swap_contract_address: &None,
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: None,
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let maker_payment = block_on_f01(maker_coin.send_maker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: taker_pubkey,
+ secret_hash: secret_hash.as_slice(),
+ amount: BigDecimal::from(10),
+ swap_contract_address: &None,
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: None,
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
- maker_coin
- .wait_for_confirmations(ConfirmPaymentInput {
- payment_tx: maker_payment.tx_hex(),
- confirmations: 1,
- requires_nota: false,
- wait_until: timeout,
- check_every: 1,
- })
- .wait()
- .unwrap();
+ block_on_f01(maker_coin.wait_for_confirmations(ConfirmPaymentInput {
+ payment_tx: maker_payment.tx_hex(),
+ confirmations: 1,
+ requires_nota: false,
+ wait_until: timeout,
+ check_every: 1,
+ }))
+ .unwrap();
- let maker_payment_spend_preimage = taker_coin
- .create_maker_payment_spend_preimage(
- &maker_payment.tx_hex(),
- time_lock,
- maker_pubkey,
- secret_hash.as_slice(),
- &[],
- )
- .wait()
- .unwrap();
+ let maker_payment_spend_preimage = block_on_f01(taker_coin.create_maker_payment_spend_preimage(
+ &maker_payment.tx_hex(),
+ time_lock,
+ maker_pubkey,
+ secret_hash.as_slice(),
+ &[],
+ ))
+ .unwrap();
- let maker_payment_spend = taker_coin
- .send_maker_payment_spend_preimage(SendMakerPaymentSpendPreimageInput {
+ let maker_payment_spend = block_on_f01(taker_coin.send_maker_payment_spend_preimage(
+ SendMakerPaymentSpendPreimageInput {
preimage: &maker_payment_spend_preimage.tx_hex(),
secret_hash: secret_hash.as_slice(),
secret: secret.as_slice(),
taker_pub: taker_pubkey,
watcher_reward: false,
- })
- .wait()
- .unwrap();
+ },
+ ))
+ .unwrap();
let validate_input = ValidateWatcherSpendInput {
payment_tx: maker_payment_spend.tx_hex(),
@@ -2843,9 +2718,7 @@ fn test_taker_validates_maker_payment_spend_utxo() {
spend_type: WatcherSpendType::TakerPaymentRefund,
};
- let validate_watcher_spend = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait();
+ let validate_watcher_spend = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input));
assert!(validate_watcher_spend.is_ok());
}
@@ -2877,43 +2750,37 @@ fn test_taker_validates_maker_payment_spend_eth() {
.unwrap()
.unwrap();
- let maker_payment = maker_coin
- .send_maker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: taker_pub,
- secret_hash: secret_hash.as_slice(),
- amount: maker_amount.clone(),
- swap_contract_address: &maker_coin.swap_contract_address(),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: Some(watcher_reward.clone()),
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let maker_payment = block_on_f01(maker_coin.send_maker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: taker_pub,
+ secret_hash: secret_hash.as_slice(),
+ amount: maker_amount.clone(),
+ swap_contract_address: &maker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: Some(watcher_reward.clone()),
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
- maker_coin
- .wait_for_confirmations(ConfirmPaymentInput {
- payment_tx: maker_payment.tx_hex(),
- confirmations: 1,
- requires_nota: false,
- wait_until: timeout,
- check_every: 1,
- })
- .wait()
- .unwrap();
+ block_on_f01(maker_coin.wait_for_confirmations(ConfirmPaymentInput {
+ payment_tx: maker_payment.tx_hex(),
+ confirmations: 1,
+ requires_nota: false,
+ wait_until: timeout,
+ check_every: 1,
+ }))
+ .unwrap();
- let maker_payment_spend_preimage = taker_coin
- .create_maker_payment_spend_preimage(
- &maker_payment.tx_hex(),
- time_lock,
- maker_pub,
- secret_hash.as_slice(),
- &[],
- )
- .wait()
- .unwrap();
+ let maker_payment_spend_preimage = block_on_f01(taker_coin.create_maker_payment_spend_preimage(
+ &maker_payment.tx_hex(),
+ time_lock,
+ maker_pub,
+ secret_hash.as_slice(),
+ &[],
+ ))
+ .unwrap();
let validate_input = ValidateWatcherSpendInput {
payment_tx: maker_payment_spend_preimage.tx_hex(),
@@ -2926,9 +2793,7 @@ fn test_taker_validates_maker_payment_spend_eth() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -2942,27 +2807,25 @@ fn test_taker_validates_maker_payment_spend_eth() {
),
}
- let maker_payment_spend = taker_coin
- .send_maker_payment_spend_preimage(SendMakerPaymentSpendPreimageInput {
+ let maker_payment_spend = block_on_f01(taker_coin.send_maker_payment_spend_preimage(
+ SendMakerPaymentSpendPreimageInput {
preimage: &maker_payment_spend_preimage.tx_hex(),
secret_hash: secret_hash.as_slice(),
secret: secret.as_slice(),
taker_pub,
watcher_reward: true,
- })
- .wait()
- .unwrap();
+ },
+ ))
+ .unwrap();
- maker_coin
- .wait_for_confirmations(ConfirmPaymentInput {
- payment_tx: maker_payment_spend.tx_hex(),
- confirmations: 1,
- requires_nota: false,
- wait_until: timeout,
- check_every: 1,
- })
- .wait()
- .unwrap();
+ block_on_f01(maker_coin.wait_for_confirmations(ConfirmPaymentInput {
+ payment_tx: maker_payment_spend.tx_hex(),
+ confirmations: 1,
+ requires_nota: false,
+ wait_until: timeout,
+ check_every: 1,
+ }))
+ .unwrap();
let validate_input = ValidateWatcherSpendInput {
payment_tx: maker_payment_spend.tx_hex(),
@@ -2975,10 +2838,7 @@ fn test_taker_validates_maker_payment_spend_eth() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
- .unwrap();
+ block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input)).unwrap();
let validate_input = ValidateWatcherSpendInput {
payment_tx: maker_payment_spend.tx_hex(),
@@ -2991,9 +2851,7 @@ fn test_taker_validates_maker_payment_spend_eth() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -3018,9 +2876,7 @@ fn test_taker_validates_maker_payment_spend_eth() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -3045,9 +2901,7 @@ fn test_taker_validates_maker_payment_spend_eth() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- let error = maker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(maker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -3075,9 +2929,7 @@ fn test_taker_validates_maker_payment_spend_eth() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -3105,9 +2957,7 @@ fn test_taker_validates_maker_payment_spend_eth() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -3135,9 +2985,7 @@ fn test_taker_validates_maker_payment_spend_eth() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -3162,9 +3010,7 @@ fn test_taker_validates_maker_payment_spend_eth() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -3206,65 +3052,57 @@ fn test_taker_validates_maker_payment_spend_erc20() {
))
.unwrap();
- let maker_payment = maker_coin
- .send_maker_payment(SendPaymentArgs {
- time_lock_duration,
- time_lock,
- other_pubkey: taker_pub,
- secret_hash: secret_hash.as_slice(),
- amount: maker_amount.clone(),
- swap_contract_address: &maker_coin.swap_contract_address(),
- swap_unique_data: &[],
- payment_instructions: &None,
- watcher_reward: watcher_reward.clone(),
- wait_for_confirmation_until,
- })
- .wait()
- .unwrap();
+ let maker_payment = block_on_f01(maker_coin.send_maker_payment(SendPaymentArgs {
+ time_lock_duration,
+ time_lock,
+ other_pubkey: taker_pub,
+ secret_hash: secret_hash.as_slice(),
+ amount: maker_amount.clone(),
+ swap_contract_address: &maker_coin.swap_contract_address(),
+ swap_unique_data: &[],
+ payment_instructions: &None,
+ watcher_reward: watcher_reward.clone(),
+ wait_for_confirmation_until,
+ }))
+ .unwrap();
- maker_coin
- .wait_for_confirmations(ConfirmPaymentInput {
- payment_tx: maker_payment.tx_hex(),
- confirmations: 1,
- requires_nota: false,
- wait_until: timeout,
- check_every: 1,
- })
- .wait()
- .unwrap();
+ block_on_f01(maker_coin.wait_for_confirmations(ConfirmPaymentInput {
+ payment_tx: maker_payment.tx_hex(),
+ confirmations: 1,
+ requires_nota: false,
+ wait_until: timeout,
+ check_every: 1,
+ }))
+ .unwrap();
- let maker_payment_spend_preimage = taker_coin
- .create_maker_payment_spend_preimage(
- &maker_payment.tx_hex(),
- time_lock,
- maker_pub,
- secret_hash.as_slice(),
- &[],
- )
- .wait()
- .unwrap();
+ let maker_payment_spend_preimage = block_on_f01(taker_coin.create_maker_payment_spend_preimage(
+ &maker_payment.tx_hex(),
+ time_lock,
+ maker_pub,
+ secret_hash.as_slice(),
+ &[],
+ ))
+ .unwrap();
- let maker_payment_spend = taker_coin
- .send_maker_payment_spend_preimage(SendMakerPaymentSpendPreimageInput {
+ let maker_payment_spend = block_on_f01(taker_coin.send_maker_payment_spend_preimage(
+ SendMakerPaymentSpendPreimageInput {
preimage: &maker_payment_spend_preimage.tx_hex(),
secret_hash: secret_hash.as_slice(),
secret: secret.as_slice(),
taker_pub,
watcher_reward: true,
- })
- .wait()
- .unwrap();
+ },
+ ))
+ .unwrap();
- maker_coin
- .wait_for_confirmations(ConfirmPaymentInput {
- payment_tx: maker_payment_spend.tx_hex(),
- confirmations: 1,
- requires_nota: false,
- wait_until: timeout,
- check_every: 1,
- })
- .wait()
- .unwrap();
+ block_on_f01(maker_coin.wait_for_confirmations(ConfirmPaymentInput {
+ payment_tx: maker_payment_spend.tx_hex(),
+ confirmations: 1,
+ requires_nota: false,
+ wait_until: timeout,
+ check_every: 1,
+ }))
+ .unwrap();
let validate_input = ValidateWatcherSpendInput {
payment_tx: maker_payment_spend.tx_hex(),
@@ -3277,10 +3115,7 @@ fn test_taker_validates_maker_payment_spend_erc20() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
- .unwrap();
+ block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input)).unwrap();
let validate_input = ValidateWatcherSpendInput {
payment_tx: maker_payment_spend.tx_hex(),
@@ -3293,9 +3128,7 @@ fn test_taker_validates_maker_payment_spend_erc20() {
spend_type: WatcherSpendType::MakerPaymentSpend,
};
- let error = taker_coin
- .taker_validates_payment_spend_or_refund(validate_input)
- .wait()
+ let error = block_on_f01(taker_coin.taker_validates_payment_spend_or_refund(validate_input))
.unwrap_err()
.into_inner();
log!("error: {:?}", error);
@@ -3329,7 +3162,7 @@ fn test_send_taker_payment_refund_preimage_utxo() {
watcher_reward: None,
wait_for_confirmation_until: 0,
};
- let tx = coin.send_taker_payment(taker_payment_args).wait().unwrap();
+ let tx = block_on_f01(coin.send_taker_payment(taker_payment_args)).unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: tx.tx_hex(),
@@ -3338,27 +3171,30 @@ fn test_send_taker_payment_refund_preimage_utxo() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
- let refund_tx = coin
- .create_taker_payment_refund_preimage(&tx.tx_hex(), time_lock, my_public_key, &[0; 20], &None, &[])
- .wait()
- .unwrap();
+ let refund_tx = block_on_f01(coin.create_taker_payment_refund_preimage(
+ &tx.tx_hex(),
+ time_lock,
+ my_public_key,
+ &[0; 20],
+ &None,
+ &[],
+ ))
+ .unwrap();
- let refund_tx = coin
- .send_taker_payment_refund_preimage(RefundPaymentArgs {
- payment_tx: &refund_tx.tx_hex(),
- swap_contract_address: &None,
- tx_type_with_secret_hash: SwapTxTypeWithSecretHash::TakerOrMakerPayment {
- maker_secret_hash: &[0; 20],
- },
- other_pubkey: my_public_key,
- time_lock,
- swap_unique_data: &[],
- watcher_reward: false,
- })
- .wait()
- .unwrap();
+ let refund_tx = block_on_f01(coin.send_taker_payment_refund_preimage(RefundPaymentArgs {
+ payment_tx: &refund_tx.tx_hex(),
+ swap_contract_address: &None,
+ tx_type_with_secret_hash: SwapTxTypeWithSecretHash::TakerOrMakerPayment {
+ maker_secret_hash: &[0; 20],
+ },
+ other_pubkey: my_public_key,
+ time_lock,
+ swap_unique_data: &[],
+ watcher_reward: false,
+ }))
+ .unwrap();
let confirm_payment_input = ConfirmPaymentInput {
payment_tx: refund_tx.tx_hex(),
@@ -3367,7 +3203,7 @@ fn test_send_taker_payment_refund_preimage_utxo() {
wait_until: timeout,
check_every: 1,
};
- coin.wait_for_confirmations(confirm_payment_input).wait().unwrap();
+ block_on_f01(coin.wait_for_confirmations(confirm_payment_input)).unwrap();
let search_input = SearchForSwapTxSpendInput {
time_lock,
diff --git a/mm2src/mm2_main/tests/mm2_tests/mm2_tests_inner.rs b/mm2src/mm2_main/tests/mm2_tests/mm2_tests_inner.rs
index 137eb6ef09..57a4709758 100644
--- a/mm2src/mm2_main/tests/mm2_tests/mm2_tests_inner.rs
+++ b/mm2src/mm2_main/tests/mm2_tests/mm2_tests_inner.rs
@@ -14,15 +14,15 @@ use mm2_test_helpers::electrums::*;
use mm2_test_helpers::for_tests::wait_check_stats_swap_status;
use mm2_test_helpers::for_tests::{account_balance, btc_segwit_conf, btc_with_spv_conf, btc_with_sync_starting_header,
check_recent_swaps, enable_qrc20, enable_utxo_v2_electrum, eth_dev_conf,
- find_metrics_in_json, from_env_file, get_new_address, get_shared_db_id, mm_spat,
- morty_conf, my_balance, rick_conf, sign_message, start_swaps, tbtc_conf,
- tbtc_segwit_conf, tbtc_with_spv_conf, test_qrc20_history_impl, tqrc20_conf,
- verify_message, wait_for_swaps_finish_and_check_status,
- wait_till_history_has_records, MarketMakerIt, Mm2InitPrivKeyPolicy, Mm2TestConf,
- Mm2TestConfForSwap, RaiiDump, DOC_ELECTRUM_ADDRS, ETH_MAINNET_NODE,
- ETH_MAINNET_SWAP_CONTRACT, ETH_SEPOLIA_NODES, ETH_SEPOLIA_SWAP_CONTRACT,
- MARTY_ELECTRUM_ADDRS, MORTY, QRC20_ELECTRUMS, RICK, RICK_ELECTRUM_ADDRS,
- TBTC_ELECTRUMS, T_BCH_ELECTRUMS};
+ find_metrics_in_json, from_env_file, get_new_address, get_shared_db_id,
+ get_wallet_names, mm_spat, morty_conf, my_balance, rick_conf, sign_message,
+ start_swaps, tbtc_conf, tbtc_segwit_conf, tbtc_with_spv_conf,
+ test_qrc20_history_impl, tqrc20_conf, verify_message,
+ wait_for_swaps_finish_and_check_status, wait_till_history_has_records,
+ MarketMakerIt, Mm2InitPrivKeyPolicy, Mm2TestConf, Mm2TestConfForSwap, RaiiDump,
+ DOC_ELECTRUM_ADDRS, ETH_MAINNET_NODE, ETH_MAINNET_SWAP_CONTRACT, ETH_SEPOLIA_NODES,
+ ETH_SEPOLIA_SWAP_CONTRACT, MARTY_ELECTRUM_ADDRS, MORTY, QRC20_ELECTRUMS, RICK,
+ RICK_ELECTRUM_ADDRS, TBTC_ELECTRUMS, T_BCH_ELECTRUMS};
use mm2_test_helpers::get_passphrase;
use mm2_test_helpers::structs::*;
use serde_json::{self as json, json, Value as Json};
@@ -2351,7 +2351,7 @@ fn test_electrum_tx_history() {
{"coin":"RICK","asset":"RICK","rpcport":8923,"txversion":4,"overwintered":1,"protocol":{"type":"UTXO"}},
]);
- let mut mm = MarketMakerIt::start(
+ let mm_bob = MarketMakerIt::start(
json! ({
"gui": "nogui",
"netid": 9998,
@@ -2367,14 +2367,26 @@ fn test_electrum_tx_history() {
None,
)
.unwrap();
+ let (_dump_log, _dump_dashboard) = mm_bob.mm_dump();
+ log!("log path: {}", mm_bob.log_path.display());
+
+ let bob_electrum = block_on(enable_electrum(&mm_bob, "RICK", false, DOC_ELECTRUM_ADDRS));
+ let mut enable_res_bob = HashMap::new();
+ enable_res_bob.insert("RICK", bob_electrum);
+ log!("enable_coins_bob: {:?}", enable_res_bob);
+
+ let mmconf = Mm2TestConf::seednode_with_wallet_name(&coins, "wallet", "pass");
+ let mut mm = MarketMakerIt::start(mmconf.conf, mmconf.rpc_password, None).unwrap();
let (_dump_log, _dump_dashboard) = mm.mm_dump();
log!("log path: {}", mm.log_path.display());
// Enable RICK electrum client with tx_history loop.
let electrum = block_on(enable_electrum(&mm, "RICK", true, DOC_ELECTRUM_ADDRS));
+ log!("enable_coins: {:?}", electrum);
+ let receiving_address = electrum.address;
// Wait till tx_history will not be loaded
- block_on(mm.wait_for_log(500., |log| log.contains("history has been loaded successfully"))).unwrap();
+ block_on(mm.wait_for_log(5., |log| log.contains("history has been loaded successfully"))).unwrap();
// tx_history is requested every 30 seconds, wait another iteration
thread::sleep(Duration::from_secs(31));
@@ -2384,16 +2396,13 @@ fn test_electrum_tx_history() {
assert_eq!(get_tx_history_request_count(&mm), 1);
// make a transaction to change balance
- let mut enable_res = HashMap::new();
- enable_res.insert("RICK", electrum);
- log!("enable_coins: {:?}", enable_res);
withdraw_and_send(
- &mm,
+ &mm_bob,
"RICK",
None,
- "RRYmiZSDo3UdHHqj1rLKf8cbJroyv9NxXw",
- &enable_res,
- "-0.00001",
+ &receiving_address,
+ &enable_res_bob,
+ "-0.00101",
0.001,
);
@@ -5809,6 +5818,41 @@ fn test_get_shared_db_id() {
);
}
+#[test]
+#[cfg(not(target_arch = "wasm32"))]
+fn test_get_wallet_names() {
+ let coins = json!([]);
+
+ // Initialize the first wallet with a specific name
+ let wallet_1 = Mm2TestConf::seednode_with_wallet_name(&coins, "wallet_1", "pass");
+ let mm_wallet_1 = MarketMakerIt::start(wallet_1.conf, wallet_1.rpc_password, None).unwrap();
+
+ // Retrieve and verify the wallet names for the first wallet
+ let get_wallet_names_1 = block_on(get_wallet_names(&mm_wallet_1));
+ assert_eq!(get_wallet_names_1.wallet_names, vec!["wallet_1"]);
+ assert_eq!(get_wallet_names_1.activated_wallet.unwrap(), "wallet_1");
+
+ // Initialize the second wallet with a different name
+ let mut wallet_2 = Mm2TestConf::seednode_with_wallet_name(&coins, "wallet_2", "pass");
+
+ // Set the database directory for the second wallet to the same as the first wallet
+ wallet_2.conf["dbdir"] = mm_wallet_1.folder.join("DB").to_str().unwrap().into();
+
+ // Stop the first wallet before starting the second one
+ block_on(mm_wallet_1.stop()).unwrap();
+
+ // Start the second wallet
+ let mm_wallet_2 = MarketMakerIt::start(wallet_2.conf, wallet_2.rpc_password, None).unwrap();
+
+ // Retrieve and verify the wallet names for the second wallet
+ let get_wallet_names_2 = block_on(get_wallet_names(&mm_wallet_2));
+ assert_eq!(get_wallet_names_2.wallet_names, vec!["wallet_1", "wallet_2"]);
+ assert_eq!(get_wallet_names_2.activated_wallet.unwrap(), "wallet_2");
+
+ // Stop the second wallet
+ block_on(mm_wallet_2.stop()).unwrap();
+}
+
#[test]
#[cfg(not(target_arch = "wasm32"))]
fn test_sign_raw_transaction_rick() {
diff --git a/mm2src/mm2_test_helpers/src/for_tests.rs b/mm2src/mm2_test_helpers/src/for_tests.rs
index 57084a72e2..df5a488cf9 100644
--- a/mm2src/mm2_test_helpers/src/for_tests.rs
+++ b/mm2src/mm2_test_helpers/src/for_tests.rs
@@ -310,6 +310,21 @@ impl Mm2TestConf {
}
}
+ pub fn seednode_with_wallet_name(coins: &Json, wallet_name: &str, wallet_password: &str) -> Self {
+ Mm2TestConf {
+ conf: json!({
+ "gui": "nogui",
+ "netid": 9998,
+ "coins": coins,
+ "rpc_password": DEFAULT_RPC_PASSWORD,
+ "i_am_seed": true,
+ "wallet_name": wallet_name,
+ "wallet_password": wallet_password,
+ }),
+ rpc_password: DEFAULT_RPC_PASSWORD.into(),
+ }
+ }
+
pub fn light_node(passphrase: &str, coins: &Json, seednodes: &[&str]) -> Self {
Mm2TestConf {
conf: json!({
@@ -1351,17 +1366,49 @@ impl MarketMakerIt {
/// Start a new MarketMaker locally.
///
/// * `conf` - The command-line configuration passed to the MarketMaker.
+ /// * `userpass` - RPC API key.
+ /// * `local` - Function to start the MarketMaker locally.
+ /// * `envs` - The environment variables passed to the process.
+ /// The argument is ignored for nodes running in a browser.
+ #[cfg(target_arch = "wasm32")]
+ pub async fn start_with_envs(
+ conf: Json,
+ userpass: String,
+ local: Option,
+ _envs: &[(&str, &str)],
+ ) -> Result {
+ MarketMakerIt::start_market_maker(conf, userpass, local, None).await
+ }
+
+ /// Start a new MarketMaker locally with a specific database namespace.
+ ///
+ /// * `conf` - The command-line configuration passed to the MarketMaker.
+ /// * `userpass` - RPC API key.
+ /// * `local` - Function to start the MarketMaker locally.
+ /// * `db_namespace_id` - The test database namespace identifier.
+ #[cfg(target_arch = "wasm32")]
+ pub async fn start_with_db(
+ conf: Json,
+ userpass: String,
+ local: Option,
+ db_namespace_id: u64,
+ ) -> Result {
+ MarketMakerIt::start_market_maker(conf, userpass, local, Some(db_namespace_id)).await
+ }
+
+ /// Common helper function to start the MarketMaker.
+ ///
+ /// * `conf` - The command-line configuration passed to the MarketMaker.
/// Unique P2P in-memory port is injected as `p2p_in_memory_port` unless this field is already present.
/// * `userpass` - RPC API key. We should probably extract it automatically from the MM log.
/// * `local` - Function to start the MarketMaker locally. Required for nodes running in a browser.
- /// * `envs` - The enviroment variables passed to the process.
- /// The argument is ignore for nodes running in a browser.
+ /// * `db_namespace_id` - Optional test database namespace identifier.
#[cfg(target_arch = "wasm32")]
- pub async fn start_with_envs(
+ async fn start_market_maker(
mut conf: Json,
userpass: String,
local: Option,
- _envs: &[(&str, &str)],
+ db_namespace_id: Option,
) -> Result {
if conf["p2p_in_memory"].is_null() {
conf["p2p_in_memory"] = Json::Bool(true);
@@ -1377,10 +1424,19 @@ impl MarketMakerIt {
conf["p2p_in_memory_port"] = Json::Number(new_p2p_port.into());
}
- let ctx = mm2_core::mm_ctx::MmCtxBuilder::new()
- .with_conf(conf.clone())
- .with_test_db_namespace()
- .into_mm_arc();
+ let ctx = {
+ let builder = MmCtxBuilder::new()
+ .with_conf(conf.clone());
+
+ let builder = if let Some(ns) = db_namespace_id {
+ builder.with_test_db_namespace_with_id(ns)
+ } else {
+ builder.with_test_db_namespace()
+ };
+
+ builder.into_mm_arc()
+ };
+
let local = try_s!(local.ok_or("!local"));
local(ctx.clone());
@@ -2838,6 +2894,20 @@ pub async fn get_shared_db_id(mm: &MarketMakerIt) -> GetSharedDbIdResult {
res.result
}
+pub async fn get_wallet_names(mm: &MarketMakerIt) -> GetWalletNamesResult {
+ let request = mm
+ .rpc(&json!({
+ "userpass": mm.userpass,
+ "method": "get_wallet_names",
+ "mmrpc": "2.0",
+ }))
+ .await
+ .unwrap();
+ assert_eq!(request.0, StatusCode::OK, "'get_wallet_names' failed: {}", request.1);
+ let res: RpcSuccessResponse<_> = json::from_str(&request.1).unwrap();
+ res.result
+}
+
pub async fn max_maker_vol(mm: &MarketMakerIt, coin: &str) -> RpcResponse {
let rc = mm
.rpc(&json!({
diff --git a/mm2src/mm2_test_helpers/src/structs.rs b/mm2src/mm2_test_helpers/src/structs.rs
index aa2246186c..8bdcfec722 100644
--- a/mm2src/mm2_test_helpers/src/structs.rs
+++ b/mm2src/mm2_test_helpers/src/structs.rs
@@ -827,6 +827,13 @@ pub struct GetSharedDbIdResult {
pub shared_db_id: String,
}
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct GetWalletNamesResult {
+ pub wallet_names: Vec,
+ pub activated_wallet: Option,
+}
+
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RpcV2Response {