mirror of
https://github.com/mimblewimble/grin-wallet.git
synced 2025-01-21 11:31:09 +03:00
d774272fee
* move api deser types into separate types mod * rustfmt * missing types file * make all exports from libwallet more explicit * rustfmt * add version check function to foreign api * rustfmt * change check_version return value to result, for consistency
148 lines
4.6 KiB
Rust
148 lines
4.6 KiB
Rust
// Copyright 2018 The Grin Developers
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
//! Test a wallet sending to self
|
|
#[macro_use]
|
|
extern crate log;
|
|
extern crate grin_wallet_controller as wallet;
|
|
extern crate grin_wallet_impls as impls;
|
|
|
|
use grin_wallet_util::grin_core as core;
|
|
use grin_wallet_util::grin_keychain as keychain;
|
|
use grin_wallet_util::grin_util as util;
|
|
|
|
use self::core::global;
|
|
use self::core::global::ChainTypes;
|
|
use self::keychain::ExtKeychain;
|
|
use grin_wallet_libwallet as libwallet;
|
|
use impls::test_framework::{self, LocalWalletClient, WalletProxy};
|
|
use libwallet::InitTxArgs;
|
|
use std::fs;
|
|
use std::thread;
|
|
use std::time::Duration;
|
|
|
|
fn clean_output_dir(test_dir: &str) {
|
|
let _ = fs::remove_dir_all(test_dir);
|
|
}
|
|
|
|
fn setup(test_dir: &str) {
|
|
util::init_test_logger();
|
|
clean_output_dir(test_dir);
|
|
global::set_mining_mode(ChainTypes::AutomatedTesting);
|
|
}
|
|
|
|
/// self send impl
|
|
fn self_send_test_impl(test_dir: &str) -> Result<(), libwallet::Error> {
|
|
setup(test_dir);
|
|
// Create a new proxy to simulate server and wallet responses
|
|
let mut wallet_proxy: WalletProxy<LocalWalletClient, ExtKeychain> = WalletProxy::new(test_dir);
|
|
let chain = wallet_proxy.chain.clone();
|
|
|
|
// Create a new wallet test client, and set its queues to communicate with the
|
|
// proxy
|
|
let client1 = LocalWalletClient::new("wallet1", wallet_proxy.tx.clone());
|
|
let wallet1 =
|
|
test_framework::create_wallet(&format!("{}/wallet1", test_dir), client1.clone(), None);
|
|
wallet_proxy.add_wallet("wallet1", client1.get_send_instance(), wallet1.clone());
|
|
|
|
// Set the wallet proxy listener running
|
|
thread::spawn(move || {
|
|
if let Err(e) = wallet_proxy.run() {
|
|
error!("Wallet Proxy error: {}", e);
|
|
}
|
|
});
|
|
|
|
// few values to keep things shorter
|
|
let reward = core::consensus::REWARD;
|
|
|
|
// add some accounts
|
|
wallet::controller::owner_single_use(wallet1.clone(), |api| {
|
|
api.create_account_path("mining")?;
|
|
api.create_account_path("listener")?;
|
|
Ok(())
|
|
})?;
|
|
|
|
// Get some mining done
|
|
{
|
|
let mut w = wallet1.lock();
|
|
w.set_parent_key_id_by_name("mining")?;
|
|
}
|
|
let mut bh = 10u64;
|
|
let _ = test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), bh as usize, false);
|
|
|
|
// Should have 5 in account1 (5 spendable), 5 in account (2 spendable)
|
|
wallet::controller::owner_single_use(wallet1.clone(), |api| {
|
|
let (wallet1_refreshed, wallet1_info) = api.retrieve_summary_info(true, 1)?;
|
|
assert!(wallet1_refreshed);
|
|
assert_eq!(wallet1_info.last_confirmed_height, bh);
|
|
assert_eq!(wallet1_info.total, bh * reward);
|
|
// send to send
|
|
let args = InitTxArgs {
|
|
src_acct_name: Some("mining".to_owned()),
|
|
amount: reward * 2,
|
|
minimum_confirmations: 2,
|
|
max_outputs: 500,
|
|
num_change_outputs: 1,
|
|
selection_strategy_is_use_all: true,
|
|
..Default::default()
|
|
};
|
|
let mut slate = api.initiate_tx(args)?;
|
|
api.tx_lock_outputs(&slate)?;
|
|
// Send directly to self
|
|
wallet::controller::foreign_single_use(wallet1.clone(), |api| {
|
|
slate = api.receive_tx(&slate, Some("listener"), None)?;
|
|
Ok(())
|
|
})?;
|
|
slate = api.finalize_tx(&slate)?;
|
|
api.post_tx(&slate.tx, false)?; // mines a block
|
|
bh += 1;
|
|
Ok(())
|
|
})?;
|
|
|
|
let _ = test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), 3, false);
|
|
bh += 3;
|
|
|
|
// Check total in mining account
|
|
wallet::controller::owner_single_use(wallet1.clone(), |api| {
|
|
let (wallet1_refreshed, wallet1_info) = api.retrieve_summary_info(true, 1)?;
|
|
assert!(wallet1_refreshed);
|
|
assert_eq!(wallet1_info.last_confirmed_height, bh);
|
|
assert_eq!(wallet1_info.total, bh * reward - reward * 2);
|
|
Ok(())
|
|
})?;
|
|
|
|
// Check total in 'listener' account
|
|
{
|
|
let mut w = wallet1.lock();
|
|
w.set_parent_key_id_by_name("listener")?;
|
|
}
|
|
wallet::controller::owner_single_use(wallet1.clone(), |api| {
|
|
let (wallet1_refreshed, wallet1_info) = api.retrieve_summary_info(true, 1)?;
|
|
assert!(wallet1_refreshed);
|
|
assert_eq!(wallet1_info.last_confirmed_height, bh);
|
|
assert_eq!(wallet1_info.total, 2 * reward);
|
|
Ok(())
|
|
})?;
|
|
|
|
// let logging finish
|
|
thread::sleep(Duration::from_millis(200));
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn wallet_self_send() {
|
|
let test_dir = "test_output/self_send";
|
|
if let Err(e) = self_send_test_impl(test_dir) {
|
|
panic!("Libwallet Error: {} - {}", e, e.backtrace().unwrap());
|
|
}
|
|
}
|