mirror of
https://github.com/jwinterm/grin-wallet.git
synced 2026-11-19 21:43:58 +01:00
Slatepack address index on send (#821)
* Store address_index into tx log entry to get address and decrypt slatepack message, increment over all values * Provide address index on send and issue_invoice command * Keep 0 index for receive * Use sender address index at payment proof Rust API users need to update to SlatepackAddressIndex and the Slatepack methods Keep a wallet database backup for pending transactions and saved address indices. Seed recovery alone does not restore these, and the address counter restarts at 1.
This commit is contained in:
@@ -32,6 +32,7 @@ use grin_wallet_libwallet::{InitTxArgs, IssueInvoiceTxArgs};
|
||||
#[macro_use]
|
||||
mod common;
|
||||
use common::{clean_output_dir, create_wallet_proxy, setup};
|
||||
use grin_wallet_libwallet::slatepack::SlatepackAddressIndex;
|
||||
|
||||
/// self send impl
|
||||
fn file_exchange_test_impl(test_dir: &'static str, use_bin: bool) -> Result<(), libwallet::Error> {
|
||||
@@ -235,7 +236,7 @@ fn file_exchange_test_impl(test_dir: &'static str, use_bin: bool) -> Result<(),
|
||||
format!("{}/standard_pp_S3.txbin", test_dir),
|
||||
),
|
||||
};
|
||||
let address = Some(api2.get_slatepack_address(mask2, 0)?);
|
||||
let address = Some(api2.get_slatepack_address(mask2, SlatepackAddressIndex(0))?);
|
||||
|
||||
// send to send
|
||||
let args = InitTxArgs {
|
||||
|
||||
@@ -28,6 +28,7 @@ use std::time::Duration;
|
||||
#[macro_use]
|
||||
mod common;
|
||||
use common::{clean_output_dir, create_wallet_proxy, setup};
|
||||
use grin_wallet_libwallet::slatepack::SlatepackAddressIndex;
|
||||
|
||||
/// Various tests on accounts within the same wallet
|
||||
fn payment_proofs_test_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
|
||||
@@ -78,7 +79,7 @@ fn payment_proofs_test_impl(test_dir: &'static str) -> Result<(), libwallet::Err
|
||||
let _ =
|
||||
test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, bh as usize, false);
|
||||
|
||||
let address = Some(api2.get_slatepack_address(mask2, 0)?);
|
||||
let address = Some(api2.get_slatepack_address(mask2, SlatepackAddressIndex(0))?);
|
||||
|
||||
println!("Public address is: {:?}", address);
|
||||
let amount = 60_000_000_000;
|
||||
@@ -121,7 +122,7 @@ fn payment_proofs_test_impl(test_dir: &'static str) -> Result<(), libwallet::Err
|
||||
slate_i.payment_proof.as_ref().unwrap().receiver_address
|
||||
);
|
||||
assert!(pp.receiver_signature.is_some());
|
||||
assert_eq!(pp.sender_address_path, 0);
|
||||
assert_eq!(pp.sender_address_path, SlatepackAddressIndex(1));
|
||||
assert_eq!(pp.sender_signature, None);
|
||||
|
||||
// check we should get an error at this point since proof is not complete
|
||||
|
||||
@@ -30,6 +30,7 @@ use std::time::Duration;
|
||||
#[macro_use]
|
||||
mod common;
|
||||
use common::{clean_output_dir, create_wallet_proxy, setup};
|
||||
use grin_wallet_libwallet::slatepack::SlatepackAddressIndex;
|
||||
|
||||
/// self send impl
|
||||
fn self_send_test_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
|
||||
@@ -171,7 +172,9 @@ fn late_lock_self_send_proof() -> Result<(), libwallet::Error> {
|
||||
amount: core::consensus::REWARD,
|
||||
minimum_confirmations: 2,
|
||||
late_lock: Some(true),
|
||||
payment_proof_recipient_address: Some(api1.get_slatepack_address(mask1, 0)?),
|
||||
payment_proof_recipient_address: Some(
|
||||
api1.get_slatepack_address(mask1, SlatepackAddressIndex(0))?,
|
||||
),
|
||||
..Default::default()
|
||||
},
|
||||
)?;
|
||||
|
||||
+298
-93
@@ -20,25 +20,30 @@ extern crate grin_wallet_impls as impls;
|
||||
use grin_core as core;
|
||||
use grin_wallet_config::GlobalWalletConfig;
|
||||
use grin_wallet_libwallet as libwallet;
|
||||
use std::path::PathBuf;
|
||||
|
||||
use impls::test_framework::{self, LocalWalletClient};
|
||||
use impls::{PathToSlatepack, SlatePutter as _};
|
||||
use impls::DefaultLCProvider;
|
||||
use std::fs::File;
|
||||
use std::io::Write;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
use std::{fs, thread};
|
||||
|
||||
use grin_wallet_libwallet::{
|
||||
InitTxArgs, InitTxSendArgs, IssueInvoiceTxArgs, Slate, Slatepack, SlatepackAddress,
|
||||
Slatepacker, SlatepackerArgs,
|
||||
slatepack, Error, InitTxArgs, InitTxSendArgs, IssueInvoiceTxArgs, Slate, Slatepack,
|
||||
SlatepackAddress, SlatepackBin, WalletHandle,
|
||||
};
|
||||
|
||||
use ed25519_dalek::SigningKey as edDalekSecretKey;
|
||||
use ed25519_dalek::VerifyingKey as edDalekPublicKey;
|
||||
|
||||
#[macro_use]
|
||||
mod common;
|
||||
use common::{clean_output_dir, create_wallet_proxy, setup};
|
||||
use grin_keychain::ExtKeychain;
|
||||
use grin_util::secp::SecretKey;
|
||||
use grin_wallet_libwallet::api_impl::owner::{decrypt_slatepack, deserialize_slatepack};
|
||||
use grin_wallet_libwallet::slatepack::{get_slatepack_file_contents, SlatepackAddressIndex};
|
||||
use grin_wallet_util::byte_ser;
|
||||
|
||||
fn output_slatepack(
|
||||
slate: &Slate,
|
||||
@@ -47,35 +52,55 @@ fn output_slatepack(
|
||||
use_bin: bool,
|
||||
sender: Option<SlatepackAddress>,
|
||||
recipients: Vec<SlatepackAddress>,
|
||||
) -> Result<(), libwallet::Error> {
|
||||
let packer = Slatepacker::new(SlatepackerArgs {
|
||||
sender,
|
||||
recipients,
|
||||
dec_key: None,
|
||||
});
|
||||
) -> Result<(), Error> {
|
||||
let mut file = file.into();
|
||||
if armored {
|
||||
file = format!("{}.armored", file);
|
||||
}
|
||||
PathToSlatepack::new(file.into(), &packer, armored).put_tx(slate, use_bin)
|
||||
let slatepack = slate.create_slatepack(sender, recipients)?;
|
||||
let mut pub_tx = File::create(&file)?;
|
||||
if use_bin {
|
||||
if armored {
|
||||
let armored = slatepack.armor()?;
|
||||
pub_tx.write_all(armored.as_bytes())?;
|
||||
} else {
|
||||
pub_tx.write_all(
|
||||
&byte_ser::to_bytes(&SlatepackBin(slatepack)).map_err(|_| Error::SlatepackSer)?,
|
||||
)?;
|
||||
}
|
||||
} else {
|
||||
pub_tx.write_all(
|
||||
serde_json::to_string_pretty(&slatepack)
|
||||
.map_err(|_| Error::SlateSer)?
|
||||
.as_bytes(),
|
||||
)?;
|
||||
}
|
||||
pub_tx.sync_all()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn slate_from_packed(
|
||||
wallet_inst: WalletHandle<
|
||||
DefaultLCProvider<LocalWalletClient, ExtKeychain>,
|
||||
LocalWalletClient,
|
||||
ExtKeychain,
|
||||
>,
|
||||
keychain_mask: Option<&SecretKey>,
|
||||
file: &str,
|
||||
armored: bool,
|
||||
dec_key: Option<&edDalekSecretKey>,
|
||||
) -> Result<(Slatepack, Slate), libwallet::Error> {
|
||||
let packer = Slatepacker::new(SlatepackerArgs {
|
||||
sender: None,
|
||||
recipients: vec![],
|
||||
dec_key,
|
||||
});
|
||||
) -> Result<(Slatepack, Slate), Error> {
|
||||
let mut file = file.into();
|
||||
if armored {
|
||||
file = format!("{}.armored", file);
|
||||
}
|
||||
let slatepack = PathToSlatepack::new(file.into(), &packer, armored).get_slatepack(true)?;
|
||||
Ok((slatepack.clone(), packer.get_slate(&slatepack)?))
|
||||
let data = get_slatepack_file_contents(&file.into())?;
|
||||
let slatepack = deserialize_slatepack(
|
||||
&data,
|
||||
wallet_inst,
|
||||
keychain_mask,
|
||||
vec![SlatepackAddressIndex(0)],
|
||||
)?;
|
||||
Ok((slatepack.clone(), slatepack.get_slate()?))
|
||||
}
|
||||
|
||||
/// self send impl
|
||||
@@ -84,7 +109,7 @@ fn slatepack_exchange_test_impl(
|
||||
use_bin: bool,
|
||||
use_armored: bool,
|
||||
use_encryption: bool,
|
||||
) -> Result<(), libwallet::Error> {
|
||||
) -> Result<(), Error> {
|
||||
// Create a new proxy to simulate server and wallet responses
|
||||
let mut wallet_proxy = create_wallet_proxy(test_dir);
|
||||
let chain = wallet_proxy.chain.clone();
|
||||
@@ -134,41 +159,49 @@ fn slatepack_exchange_test_impl(
|
||||
api2.create_account_path(mask2, "account1")?;
|
||||
api2.create_account_path(mask2, "account2")?;
|
||||
|
||||
// Get some mining done
|
||||
{
|
||||
wallet_inst!(wallet1, w);
|
||||
w.set_account_by_name("mining")?;
|
||||
}
|
||||
|
||||
{
|
||||
wallet_inst!(wallet2, w);
|
||||
w.set_account_by_name("account1")?;
|
||||
}
|
||||
|
||||
// Get some mining done
|
||||
let mut bh = 10u64;
|
||||
let _ =
|
||||
test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, bh as usize, false);
|
||||
|
||||
let (recipients_1, dec_key_1, sender_1) = match use_encryption {
|
||||
let (recipients_1, sender_1) = match use_encryption {
|
||||
true => {
|
||||
let sec_key = api1.get_slatepack_secret_key(mask1, 0)?;
|
||||
let sec_key = api1.get_slatepack_secret_key(mask1, SlatepackAddressIndex(0))?;
|
||||
let pub_key = edDalekPublicKey::from(&sec_key);
|
||||
let rec_address = SlatepackAddress::new(&pub_key);
|
||||
(
|
||||
vec![rec_address.clone()],
|
||||
Some(sec_key),
|
||||
Some(rec_address.clone()),
|
||||
)
|
||||
|
||||
let sen_index = SlatepackAddressIndex(7);
|
||||
let sec_key = api1.get_slatepack_secret_key(mask1, sen_index)?;
|
||||
let pub_key = edDalekPublicKey::from(&sec_key);
|
||||
let sen_address = SlatepackAddress::new(&pub_key);
|
||||
(vec![rec_address.clone()], Some(sen_address.clone()))
|
||||
}
|
||||
false => (vec![], None, None),
|
||||
false => (vec![], None),
|
||||
};
|
||||
|
||||
let (recipients_2, dec_key_2, sender_2) = match use_encryption {
|
||||
let (recipients_2, sender_2) = match use_encryption {
|
||||
true => {
|
||||
let sec_key = api2.get_slatepack_secret_key(mask2, 0)?;
|
||||
let sec_key = api2.get_slatepack_secret_key(mask2, SlatepackAddressIndex(0))?;
|
||||
let pub_key = edDalekPublicKey::from(&sec_key);
|
||||
let rec_address = SlatepackAddress::new(&pub_key);
|
||||
(
|
||||
vec![rec_address.clone()],
|
||||
Some(sec_key),
|
||||
Some(rec_address.clone()),
|
||||
)
|
||||
|
||||
let sen_index = SlatepackAddressIndex(11);
|
||||
let sec_key = api2.get_slatepack_secret_key(mask2, sen_index)?;
|
||||
let pub_key = edDalekPublicKey::from(&sec_key);
|
||||
let sen_address = SlatepackAddress::new(&pub_key);
|
||||
(vec![rec_address.clone()], Some(sen_address.clone()))
|
||||
}
|
||||
false => (vec![], None, None),
|
||||
false => (vec![], None),
|
||||
};
|
||||
|
||||
let (send_file, receive_file, final_file) = match use_bin {
|
||||
@@ -190,7 +223,7 @@ fn slatepack_exchange_test_impl(
|
||||
assert_eq!(wallet1_info.total, bh * reward);
|
||||
// send to send
|
||||
let args = InitTxArgs {
|
||||
src_acct_name: Some("mining".to_owned()),
|
||||
address_index: Some(SlatepackAddressIndex(7)),
|
||||
amount: reward * 2,
|
||||
minimum_confirmations: 2,
|
||||
max_outputs: 500,
|
||||
@@ -210,14 +243,8 @@ fn slatepack_exchange_test_impl(
|
||||
)?;
|
||||
api1.tx_lock_outputs(mask1, &slate)?;
|
||||
|
||||
// Get some mining done
|
||||
{
|
||||
wallet_inst!(wallet2, w);
|
||||
w.set_account_by_name("account1")?;
|
||||
}
|
||||
|
||||
let (mut slatepack, mut slate) =
|
||||
slate_from_packed(&send_file, use_armored, dec_key_2.as_ref())?;
|
||||
let (slatepack, mut slate) =
|
||||
slate_from_packed(wallet2.clone(), mask2, &send_file, use_armored)?;
|
||||
|
||||
// wallet 2 receives file, completes, sends file back
|
||||
wallet::controller::foreign_single_use(
|
||||
@@ -231,8 +258,8 @@ fn slatepack_exchange_test_impl(
|
||||
&receive_file,
|
||||
use_armored,
|
||||
use_bin,
|
||||
// re-encrypt for sender!
|
||||
sender_2.clone(),
|
||||
// re-encrypt for sender!
|
||||
match slatepack.sender.clone() {
|
||||
Some(s) => vec![s.clone()],
|
||||
None => vec![],
|
||||
@@ -243,23 +270,34 @@ fn slatepack_exchange_test_impl(
|
||||
)?;
|
||||
|
||||
// wallet 1 finalizes and posts
|
||||
let (_, mut slate) = slate_from_packed(&receive_file, use_armored, dec_key_1.as_ref())?;
|
||||
let (slatepack, mut slate) =
|
||||
slate_from_packed(wallet1.clone(), mask1, &receive_file, use_armored)?;
|
||||
slate = api1.finalize_tx(mask1, &slate)?;
|
||||
// Output final file for reference
|
||||
output_slatepack(&slate, &final_file, use_armored, use_bin, None, vec![])?;
|
||||
output_slatepack(
|
||||
&slate,
|
||||
&final_file,
|
||||
use_armored,
|
||||
use_bin,
|
||||
sender_1.clone(),
|
||||
match slatepack.sender {
|
||||
Some(s) => vec![s.clone()],
|
||||
None => vec![],
|
||||
},
|
||||
)?;
|
||||
api1.post_tx(mask1, &slate, false)?;
|
||||
bh += 1;
|
||||
|
||||
let _ = test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, 3, false);
|
||||
bh += 3;
|
||||
|
||||
// Check total in mining account
|
||||
// Check total in wallet 1 account
|
||||
let (wallet1_refreshed, wallet1_info) = api1.retrieve_summary_info(mask1, true, 1)?;
|
||||
assert!(wallet1_refreshed);
|
||||
assert_eq!(wallet1_info.last_confirmed_height, bh);
|
||||
assert_eq!(wallet1_info.total, bh * reward - reward * 2);
|
||||
|
||||
// Check total in 'wallet 2' account
|
||||
// Check total in wallet 2 account
|
||||
let (wallet2_refreshed, wallet2_info) = api2.retrieve_summary_info(mask2, true, 1)?;
|
||||
assert!(wallet2_refreshed);
|
||||
assert_eq!(wallet2_info.last_confirmed_height, bh);
|
||||
@@ -281,10 +319,11 @@ fn slatepack_exchange_test_impl(
|
||||
};
|
||||
|
||||
let args = IssueInvoiceTxArgs {
|
||||
address_index: Some(SlatepackAddressIndex(11)),
|
||||
amount: 1000000000,
|
||||
..Default::default()
|
||||
};
|
||||
let mut slate = api2.issue_invoice_tx(mask2, args)?;
|
||||
let slate = api2.issue_invoice_tx(mask2, args)?;
|
||||
output_slatepack(
|
||||
&slate,
|
||||
&send_file,
|
||||
@@ -303,9 +342,8 @@ fn slatepack_exchange_test_impl(
|
||||
selection_strategy_is_use_all: true,
|
||||
..Default::default()
|
||||
};
|
||||
let res = slate_from_packed(&send_file, use_armored, dec_key_1.as_ref())?;
|
||||
slatepack = res.0;
|
||||
slate = res.1;
|
||||
let (slatepack, mut slate) =
|
||||
slate_from_packed(wallet1.clone(), mask1, &send_file, use_armored)?;
|
||||
slate = api1.process_invoice_tx(mask1, &slate, args)?;
|
||||
api1.tx_lock_outputs(mask1, &slate)?;
|
||||
output_slatepack(
|
||||
@@ -314,25 +352,16 @@ fn slatepack_exchange_test_impl(
|
||||
use_armored,
|
||||
use_bin,
|
||||
sender_1.clone(),
|
||||
match slatepack.sender.clone() {
|
||||
match slatepack.sender {
|
||||
Some(s) => vec![s.clone()],
|
||||
None => vec![],
|
||||
},
|
||||
)?;
|
||||
wallet::controller::foreign_single_use(
|
||||
wallet2.clone(),
|
||||
PathBuf::from(test_dir),
|
||||
mask2_i.clone(),
|
||||
|api| {
|
||||
// Wallet 2 receives the invoice transaction
|
||||
let res = slate_from_packed(&receive_file, use_armored, dec_key_2.as_ref())?;
|
||||
slate = res.1;
|
||||
slate = api.finalize_tx(&slate, false)?;
|
||||
output_slatepack(&slate, &final_file, use_armored, use_bin, None, vec![])?;
|
||||
Ok(())
|
||||
},
|
||||
)?;
|
||||
api1.post_tx(mask1, &slate, false)?;
|
||||
// Wallet 2 receives the invoice transaction
|
||||
let (_, mut slate) = slate_from_packed(wallet2.clone(), mask2, &receive_file, use_armored)?;
|
||||
slate = api2.finalize_tx(mask2, &slate)?;
|
||||
output_slatepack(&slate, &final_file, use_armored, use_bin, None, vec![])?;
|
||||
api2.post_tx(mask2, &slate, false)?;
|
||||
|
||||
// Standard, with payment proof
|
||||
let _ = test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, 3, false);
|
||||
@@ -349,17 +378,17 @@ fn slatepack_exchange_test_impl(
|
||||
),
|
||||
};
|
||||
|
||||
let address = Some(api2.get_slatepack_address(mask2, 0)?);
|
||||
|
||||
// send to send
|
||||
// send from 1st wallet
|
||||
let args = InitTxArgs {
|
||||
src_acct_name: Some("mining".to_owned()),
|
||||
address_index: Some(SlatepackAddressIndex(7)),
|
||||
amount: reward,
|
||||
minimum_confirmations: 2,
|
||||
max_outputs: 500,
|
||||
num_change_outputs: 1,
|
||||
selection_strategy_is_use_all: true,
|
||||
payment_proof_recipient_address: address.clone(),
|
||||
payment_proof_recipient_address: Some(
|
||||
api2.get_slatepack_address(mask2, SlatepackAddressIndex(0))?,
|
||||
),
|
||||
..Default::default()
|
||||
};
|
||||
let mut slate = api1.init_send_tx(mask1, args)?;
|
||||
@@ -373,21 +402,21 @@ fn slatepack_exchange_test_impl(
|
||||
)?;
|
||||
api1.tx_lock_outputs(mask1, &slate)?;
|
||||
|
||||
// receive at 2nd wallet
|
||||
wallet::controller::foreign_single_use(
|
||||
wallet2.clone(),
|
||||
PathBuf::from(test_dir),
|
||||
mask2_i.clone(),
|
||||
|api| {
|
||||
let res = slate_from_packed(&send_file, use_armored, dec_key_2.as_ref())?;
|
||||
let slatepack = res.0;
|
||||
slate = res.1;
|
||||
let (slatepack, mut slate) =
|
||||
slate_from_packed(wallet2.clone(), mask2, &send_file, use_armored)?;
|
||||
slate = api.receive_tx(&slate, None, None)?;
|
||||
output_slatepack(
|
||||
&slate,
|
||||
&receive_file,
|
||||
use_armored,
|
||||
use_bin,
|
||||
sender_2,
|
||||
sender_2.clone(),
|
||||
match slatepack.sender {
|
||||
Some(s) => vec![s.clone()],
|
||||
None => vec![],
|
||||
@@ -398,7 +427,7 @@ fn slatepack_exchange_test_impl(
|
||||
)?;
|
||||
|
||||
// wallet 1 finalizes and posts
|
||||
let res = slate_from_packed(&receive_file, use_armored, dec_key_1.as_ref())?;
|
||||
let res = slate_from_packed(wallet1.clone(), mask1, &receive_file, use_armored)?;
|
||||
slate = res.1;
|
||||
slate = api1.finalize_tx(mask1, &slate)?;
|
||||
// Output final file for reference
|
||||
@@ -450,7 +479,6 @@ fn slatepack_api_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
|
||||
test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, bh as usize, false);
|
||||
|
||||
let args = InitTxArgs {
|
||||
src_acct_name: Some("mining".to_owned()),
|
||||
amount: reward * 2,
|
||||
minimum_confirmations: 2,
|
||||
max_outputs: 500,
|
||||
@@ -458,15 +486,141 @@ fn slatepack_api_impl(test_dir: &'static str) -> Result<(), libwallet::Error> {
|
||||
selection_strategy_is_use_all: true,
|
||||
..Default::default()
|
||||
};
|
||||
for index in [SlatepackAddressIndex::MAX + 1, u32::MAX] {
|
||||
assert!(matches!(
|
||||
api1.init_send_tx(
|
||||
mask1,
|
||||
InitTxArgs {
|
||||
address_index: Some(SlatepackAddressIndex(index)),
|
||||
..args.clone()
|
||||
}
|
||||
),
|
||||
Err(Error::SlatepackAddress(_))
|
||||
));
|
||||
assert!(matches!(
|
||||
api1.issue_invoice_tx(
|
||||
mask1,
|
||||
IssueInvoiceTxArgs {
|
||||
amount: reward,
|
||||
address_index: Some(SlatepackAddressIndex(index)),
|
||||
..Default::default()
|
||||
}
|
||||
),
|
||||
Err(Error::SlatepackAddress(_))
|
||||
));
|
||||
}
|
||||
api1.init_send_tx(
|
||||
mask1,
|
||||
InitTxArgs {
|
||||
estimate_only: Some(true),
|
||||
..args.clone()
|
||||
},
|
||||
)?;
|
||||
let slate = api1.init_send_tx(mask1, args)?;
|
||||
// create an encrypted slatepack (just encrypted for self)
|
||||
let enc_addr = api1.get_slatepack_address(mask1, 0)?;
|
||||
let slatepack = api1.create_slatepack_message(mask1, &slate, Some(0), vec![enc_addr])?;
|
||||
println!("{}", slatepack);
|
||||
let slatepack_raw = api1.decode_slatepack_message(mask1, slatepack.clone(), vec![0])?;
|
||||
println!("{}", slatepack_raw);
|
||||
let decoded_slate = api1.slate_from_slatepack_message(mask1, slatepack, vec![0])?;
|
||||
println!("{}", decoded_slate);
|
||||
let address_index = SlatepackAddressIndex(0);
|
||||
let enc_addr = api1.get_slatepack_address(mask1, address_index)?;
|
||||
let slatepack =
|
||||
api1.create_slatepack_message(mask1, &slate, Some(address_index), vec![enc_addr])?;
|
||||
let mut encrypted = api1.decode_slatepack_message(mask1, slatepack.clone(), vec![])?;
|
||||
assert_eq!(encrypted.mode, 1);
|
||||
decrypt_slatepack(&mut encrypted, wallet1.clone(), mask1, vec![address_index])?;
|
||||
assert_eq!(encrypted.get_slate()?.id, slate.id);
|
||||
let slatepack_raw =
|
||||
api1.decode_slatepack_message(mask1, slatepack.clone(), vec![address_index])?;
|
||||
assert_eq!(slatepack_raw.mode, 0);
|
||||
assert_eq!(slatepack_raw.get_slate()?.id, slate.id);
|
||||
let decoded_slate = api1.slate_from_slatepack_message(mask1, slatepack, vec![address_index])?;
|
||||
assert_eq!(decoded_slate.id, slate.id);
|
||||
|
||||
let unknown_index = SlatepackAddressIndex(77);
|
||||
let unknown_address = api1.get_slatepack_address(mask1, unknown_index)?;
|
||||
let message = api1.create_slatepack_message(mask1, &slate, None, vec![unknown_address])?;
|
||||
let encrypted = api1.decode_slatepack_message(mask1, message.clone(), vec![])?;
|
||||
let decoded = api1.decode_slatepack_message(mask1, message.clone(), vec![address_index])?;
|
||||
assert_eq!(decoded.mode, 1);
|
||||
assert_eq!(decoded.payload, encrypted.payload);
|
||||
assert!(matches!(
|
||||
api1.slate_from_slatepack_message(mask1, message.clone(), vec![address_index]),
|
||||
Err(Error::SlatepackDecryption(_))
|
||||
));
|
||||
let mut api1 = api1;
|
||||
assert!(matches!(
|
||||
wallet::command::parse_slatepack(&mut api1, mask1, None, Some(message)),
|
||||
Err(wallet::Error::LibWallet(Error::SlatepackDecryption(_)))
|
||||
));
|
||||
|
||||
let index = {
|
||||
wallet_inst!(wallet1, w);
|
||||
w.get_private_context(mask1, slate.id.as_bytes())?
|
||||
.payment_proof_derivation_index
|
||||
.unwrap()
|
||||
};
|
||||
assert_eq!(index, SlatepackAddressIndex(1));
|
||||
let address = api1.get_slatepack_address(mask1, index)?;
|
||||
let message = api1.create_slatepack_message(mask1, &slate, None, vec![address])?;
|
||||
let decoded = api1.decode_slatepack_message(mask1, message.clone(), vec![address_index])?;
|
||||
assert_eq!(decoded.mode, 0);
|
||||
assert_eq!(decoded.get_slate()?.id, slate.id);
|
||||
|
||||
api1.create_account_path(mask1, "other")?;
|
||||
api1.set_active_account(mask1, "other")?;
|
||||
test_framework::award_blocks_to_wallet(&chain, wallet1.clone(), mask1, 6, false)?;
|
||||
api1.set_active_account(mask1, "default")?;
|
||||
let invoice = api1.issue_invoice_tx(
|
||||
mask1,
|
||||
IssueInvoiceTxArgs {
|
||||
amount: reward,
|
||||
dest_acct_name: Some("other".into()),
|
||||
..Default::default()
|
||||
},
|
||||
)?;
|
||||
let send = api1.init_send_tx(
|
||||
mask1,
|
||||
InitTxArgs {
|
||||
amount: reward,
|
||||
src_acct_name: Some("other".into()),
|
||||
minimum_confirmations: 2,
|
||||
..Default::default()
|
||||
},
|
||||
)?;
|
||||
api1.set_active_account(mask1, "other")?;
|
||||
let next = api1.issue_invoice_tx(
|
||||
mask1,
|
||||
IssueInvoiceTxArgs {
|
||||
amount: reward,
|
||||
..Default::default()
|
||||
},
|
||||
)?;
|
||||
for (slate, expected) in [(&invoice, 1), (&send, 2), (&next, 3)] {
|
||||
wallet_inst!(wallet1, w);
|
||||
let context = w.get_private_context(mask1, slate.id.as_bytes())?;
|
||||
assert_eq!(context.parent_key_id, w.parent_key_id());
|
||||
assert_eq!(
|
||||
context.payment_proof_derivation_index,
|
||||
Some(SlatepackAddressIndex(expected))
|
||||
);
|
||||
}
|
||||
api1.set_active_account(mask1, "default")?;
|
||||
let invoice = api1.issue_invoice_tx(
|
||||
mask1,
|
||||
IssueInvoiceTxArgs {
|
||||
amount: reward,
|
||||
..Default::default()
|
||||
},
|
||||
)?;
|
||||
{
|
||||
wallet_inst!(wallet1, w);
|
||||
assert_eq!(
|
||||
w.get_private_context(mask1, invoice.id.as_bytes())?
|
||||
.payment_proof_derivation_index,
|
||||
Some(SlatepackAddressIndex(2))
|
||||
);
|
||||
}
|
||||
|
||||
api1.close_wallet(None)?;
|
||||
let encrypted = api1.decode_slatepack_message(None, message, vec![])?;
|
||||
assert_eq!(encrypted.mode, 1);
|
||||
|
||||
// let logging finish
|
||||
stopper.store(false, Ordering::Relaxed);
|
||||
@@ -526,7 +680,6 @@ fn slatepack_address_validation(test_dir: &'static str) -> Result<(), libwallet:
|
||||
)?;
|
||||
|
||||
let args = InitTxArgs {
|
||||
src_acct_name: Some("mining".to_owned()),
|
||||
amount: reward,
|
||||
minimum_confirmations: 2,
|
||||
max_outputs: 500,
|
||||
@@ -566,6 +719,15 @@ fn slatepack_address_validation(test_dir: &'static str) -> Result<(), libwallet:
|
||||
fluff: false,
|
||||
skip_tor: Some(true),
|
||||
});
|
||||
let missing_config = PathBuf::from(test_dir).join("missing.toml");
|
||||
let api = grin_wallet_api::Owner::new(wallet1.clone(), None, missing_config);
|
||||
assert!(api
|
||||
.process_invoice_tx(mask1, &slate, valid_args.clone())
|
||||
.is_err());
|
||||
{
|
||||
wallet_inst!(wallet1, w);
|
||||
assert!(w.get_private_context(mask1, slate.id.as_bytes()).is_err());
|
||||
}
|
||||
api1.process_invoice_tx(mask1, &slate, valid_args.clone())?;
|
||||
api1.init_send_tx(mask1, valid_args)?;
|
||||
|
||||
@@ -660,3 +822,46 @@ fn slatepack_address() {
|
||||
}
|
||||
clean_output_dir(test_dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn slatepack_file_contents() {
|
||||
let test_dir = "test_output/slatepack_file_contents";
|
||||
setup(test_dir);
|
||||
|
||||
fs::create_dir_all(test_dir).unwrap();
|
||||
let sp_path = PathBuf::from(test_dir).join("pack_file");
|
||||
|
||||
// set Slatepack file to minimum allowable size
|
||||
{
|
||||
let f = File::create(sp_path.clone()).unwrap();
|
||||
f.set_len(slatepack::min_size()).unwrap();
|
||||
}
|
||||
|
||||
let mut pack_path = get_slatepack_file_contents(&sp_path);
|
||||
assert!(pack_path.is_ok());
|
||||
|
||||
// set Slatepack file to maximum allowable size
|
||||
{
|
||||
let f = File::create(sp_path.clone()).unwrap();
|
||||
f.set_len(slatepack::max_size()).unwrap();
|
||||
}
|
||||
pack_path = get_slatepack_file_contents(&sp_path);
|
||||
assert!(pack_path.is_ok());
|
||||
|
||||
// set Slatepack file below minimum allowable size
|
||||
{
|
||||
let f = File::create(sp_path.clone()).unwrap();
|
||||
f.set_len(slatepack::min_size() - 1).unwrap();
|
||||
}
|
||||
pack_path = get_slatepack_file_contents(&sp_path);
|
||||
assert!(pack_path.is_err());
|
||||
|
||||
// set Slatepack file above maximum allowable size
|
||||
{
|
||||
let f = File::create(sp_path.clone()).unwrap();
|
||||
f.set_len(slatepack::max_size() + 1).unwrap();
|
||||
}
|
||||
pack_path = get_slatepack_file_contents(&sp_path);
|
||||
assert!(pack_path.is_err());
|
||||
clean_output_dir(test_dir);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user