grin-wallet/controller/tests/contract_srs_mwmixnet.rs

// Copyright 2022 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 doing contract SRS flow
// #[macro_use]
extern crate grin_wallet_controller as wallet;
extern crate grin_wallet_impls as impls;
extern crate log;

use grin_util::{secp::SecretKey, static_secp_instance};
use grin_wallet_libwallet as libwallet;

use impls::test_framework::{self};
use libwallet::contract::types::{ContractNewArgsAPI, ContractSetupArgsAPI};
use libwallet::mwixnet::MixnetReqCreationParams;
use libwallet::{Slate, SlateState};
use std::sync::atomic::Ordering;
use std::thread;
use std::time::Duration;

#[macro_use]
mod common;
use common::{clean_output_dir, create_wallets, setup};
use std::path::PathBuf;

/// contract SRS flow - just creating an mwixnet tx at the moment
fn contract_srs_mwixnet_tx_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
	// create two wallets and mine 4 blocks in each (we want both to have balance to get a payjoin)
	let (wallets, chain, stopper, _bh) =
		create_wallets(vec![vec![("default", 4)], vec![("default", 4)]], test_dir).unwrap();
	let send_wallet = wallets[0].0.clone();
	let send_mask = wallets[0].1.as_ref();
	let recv_wallet = wallets[1].0.clone();
	let recv_mask = wallets[1].1.as_ref();

	let mut slate = Slate::blank(0, true); // this gets overriden below

	wallet::controller::owner_single_use(
		send_wallet.clone(),
		send_mask,
		PathBuf::from(test_dir),
		|api, m| {
			// Send wallet inititates a standard transaction with --send=5
			let args = &mut ContractNewArgsAPI {
				setup_args: ContractSetupArgsAPI {
					selection_args: common::contract_selection_args(),
					net_change: Some(-5_000_000_000),
					..Default::default()
				},
				..Default::default()
			};
			slate = api.contract_new(m, args)?;
			Ok(())
		},
	)?;
	assert_eq!(slate.state, SlateState::Standard1);

	wallet::controller::owner_single_use(
		recv_wallet.clone(),
		recv_mask,
		PathBuf::from(test_dir),
		|api, m| {
			// Receive wallet calls --receive=5
			let args = &mut ContractSetupArgsAPI {
				selection_args: common::contract_selection_args(),
				net_change: Some(5_000_000_000),
				..Default::default()
			};
			args.proof_args.suppress_proof = true;
			slate = api.contract_sign(m, &slate, args)?;
			Ok(())
		},
	)?;
	assert_eq!(slate.state, SlateState::Standard2);

	// Send wallet finalizes and posts
	wallet::controller::owner_single_use(
		send_wallet.clone(),
		send_mask,
		PathBuf::from(test_dir),
		|api, m| {
			let args = &mut ContractSetupArgsAPI {
				selection_args: common::contract_selection_args(),
				..Default::default()
			};
			args.proof_args.suppress_proof = true;
			slate = api.contract_sign(m, &slate, args)?;
			Ok(())
		},
	)?;
	assert_eq!(slate.state, SlateState::Standard3);

	wallet::controller::owner_single_use(
		send_wallet.clone(),
		send_mask,
		PathBuf::from(test_dir),
		|api, m| {
			api.post_tx(m, &slate, false)?;
			Ok(())
		},
	)?;

	let _ =
		test_framework::award_blocks_to_wallet(&chain, send_wallet.clone(), send_mask, 3, false);

	// Recipient wallet sends outputs to mwixnet
	wallet::controller::owner_single_use(
		recv_wallet.clone(),
		recv_mask,
		PathBuf::from(test_dir),
		|api, m| {
			let secp_locked = static_secp_instance();
			let secp = secp_locked.lock();
			let server_pubkey_str_1 =
				"97444ae673bb92c713c1a2f7b8882ffbfc1c67401a280a775dce1a8651584332";
			let server_pubkey_str_2 =
				"0c9414341f2140ed34a5a12a6479bf5a6404820d001ab81d9d3e8cc38f049b4e";
			let server_pubkey_str_3 =
				"b58ece97d60e71bb7e53218400b0d67bfe6a3cb7d3b4a67a44f8fb7c525cbca5";
			let server_key_1 =
				SecretKey::from_slice(&secp, &grin_util::from_hex(&server_pubkey_str_1).unwrap())
					.unwrap();
			let server_key_2 =
				SecretKey::from_slice(&secp, &grin_util::from_hex(&server_pubkey_str_2).unwrap())
					.unwrap();
			let server_key_3 =
				SecretKey::from_slice(&secp, &grin_util::from_hex(&server_pubkey_str_3).unwrap())
					.unwrap();
			let params = MixnetReqCreationParams {
				server_keys: vec![server_key_1, server_key_2, server_key_3],
				fee_per_hop: 50_000_000,
			};
			let outputs = api.retrieve_outputs(recv_mask, false, false, None)?;
			// get last output
			let last_output = outputs.1[outputs.1.len() - 1].clone();

			api.create_mwixnet_req(m, &params, &last_output.commit, true)?;

			// check output we created comsig for is indeed locked
			let outputs = api.retrieve_outputs(recv_mask, false, false, None)?;
			// get last output
			let last_output = outputs.1[outputs.1.len() - 1].clone();
			assert!(last_output.output.status == libwallet::OutputStatus::Locked);

			Ok(())
		},
	)?;

	// let logging finish
	stopper.store(false, Ordering::Relaxed);
	thread::sleep(Duration::from_millis(200));

	Ok(())
}

#[test]
fn wallet_contract_srs_mwixnet_tx() -> Result<(), libwallet::Error> {
	let test_dir = "test_output/contract_srs_mwixnet_tx";
	setup(test_dir);
	contract_srs_mwixnet_tx_impl(test_dir)?;
	clean_output_dir(test_dir);
	Ok(())
}