github/darkfi
1
1
Fork 0
mirror of https://github.com/darkrenaissance/darkfi.git synced 2026-04-28 03:00:18 -04:00
Code Issues Packages Projects Releases Wiki Activity

contract/money/tests: mint_pay_swap updated and fixed

Browse Source
This commit is contained in:
aggstam
2023-02-23 23:46:07 +02:00
committed by parazyd
parent f1fe5fe846
commit 389838f082
2 changed files with 228 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

486
src/contract/money/tests/mint_pay_swap.rs
View File

@@ -31,21 +31,19 @@ use darkfi::{tx::Transaction, Result};
use darkfi_sdk::{
crypto::{
merkle_prelude::*, pallas, pasta_prelude::*, poseidon_hash, Coin, MerkleNode, Nullifier,
ValueBlind,
ValueBlind, MONEY_CONTRACT_ID,
},
ContractCall,
};
use darkfi_serial::Encodable;
use darkfi_serial::{deserialize, Encodable};
use log::info;
use rand::rngs::OsRng;
use darkfi_money_contract::{
client::{
mint_v1::MintCallBuilder, swap_v1::SwapCallBuilder, transfer_v1::TransferCallBuilder,
MoneyNote, OwnCoin,
},
client::{swap_v1::SwapCallBuilder, transfer_v1::TransferCallBuilder, MoneyNote, OwnCoin},
model::MoneyTransferParamsV1 as MoneyTransferParams,
MoneyFunction::{MintV1 as MoneyMint, OtcSwapV1 as MoneyOtcSwap, TransferV1 as MoneyTransfer},
MoneyFunction::{OtcSwapV1 as MoneyOtcSwap, TransferV1 as MoneyTransfer},
MONEY_CONTRACT_ZKAS_BURN_NS_V1, MONEY_CONTRACT_ZKAS_MINT_NS_V1,
};
mod harness;
@@ -53,7 +51,7 @@ use harness::{init_logger, MoneyTestHarness};
#[async_std::test]
async fn money_contract_transfer() -> Result<()> {
init_logger()?;
init_logger();
// Some numbers we want to assert
const ALICE_INITIAL: u64 = 100;
@@ -66,7 +64,11 @@ async fn money_contract_transfer() -> Result<()> {
// Bob = 20 BOB + 50 ALICE
const BOB_FIRST_SEND: u64 = BOB_INITIAL - 20;
// Initialize harness
let mut th = MoneyTestHarness::new().await?;
let (mint_pk, mint_zkbin) = th.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1).unwrap();
let (burn_pk, burn_zkbin) = th.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1).unwrap();
let contract_id = *MONEY_CONTRACT_ID;
// We're just going to be using a zero spend-hook and user-data
let rcpt_spend_hook = pallas::Base::zero();
@@ -81,120 +83,80 @@ async fn money_contract_transfer() -> Result<()> {
let mut alice_owncoins = vec![];
let mut bob_owncoins = vec![];
info!(target: "money", "[Alice] ==================================================");
info!(target: "money", "[Alice] Building Money::Mint params for Alice's token mint");
info!(target: "money", "[Alice] ==================================================");
let alice_call_debris = MintCallBuilder {
mint_authority: th.alice_kp,
recipient: th.alice_kp.public,
amount: ALICE_INITIAL,
spend_hook: rcpt_spend_hook,
user_data: rcpt_user_data,
token_mint_zkbin: th.token_mint_zkbin.clone(),
token_mint_pk: th.token_mint_pk.clone(),
}
.build()?;
let (alice_params, alice_proofs) = (alice_call_debris.params, alice_call_debris.proofs);
info!(target: "money", "[Alice] ================================");
info!(target: "money", "[Alice] Building token mint tx for Alice");
info!(target: "money", "[Alice] ================================");
let (alice_mint_tx, alice_params) =
th.mint_token(th.alice.keypair, ALICE_INITIAL, th.alice.keypair.public)?;
info!(target: "money", "[Bob] ================================================");
info!(target: "money", "[Bob] Building Money::Mint params for Bob's token mint");
info!(target: "money", "[Bob] ================================================");
let bob_call_debris = MintCallBuilder {
mint_authority: th.bob_kp,
recipient: th.bob_kp.public,
amount: BOB_INITIAL,
spend_hook: rcpt_spend_hook,
user_data: rcpt_user_data,
token_mint_zkbin: th.token_mint_zkbin.clone(),
token_mint_pk: th.token_mint_pk.clone(),
}
.build()?;
let (bob_params, bob_proofs) = (bob_call_debris.params, bob_call_debris.proofs);
info!(target: "money", "[Alice] ========================================");
info!(target: "money", "[Alice] Building token mint tx with Alice params");
info!(target: "money", "[Alice] ========================================");
let mut data = vec![MoneyMint as u8];
alice_params.encode(&mut data)?;
let calls = vec![ContractCall { contract_id: th.money_contract_id, data }];
let proofs = vec![alice_proofs];
let mut alice_mint_tx = Transaction { calls, proofs, signatures: vec![] };
let sigs = alice_mint_tx.create_sigs(&mut OsRng, &[th.alice_kp.secret])?;
alice_mint_tx.signatures = vec![sigs];
info!(target: "money", "[Bob] ======================================");
info!(target: "money", "[Bob] Building token mint tx with Bob params");
info!(target: "money", "[Bob] ======================================");
let mut data = vec![MoneyMint as u8];
bob_params.encode(&mut data)?;
let calls = vec![ContractCall { contract_id: th.money_contract_id, data }];
let proofs = vec![bob_proofs];
let mut bob_mint_tx = Transaction { calls, proofs, signatures: vec![] };
let sigs = bob_mint_tx.create_sigs(&mut OsRng, &[th.bob_kp.secret])?;
bob_mint_tx.signatures = vec![sigs];
info!(target: "money", "[Bob] ==============================");
info!(target: "money", "[Bob] Building token mint tx for Bob");
info!(target: "money", "[Bob] ==============================");
let (bob_mint_tx, bob_params) =
th.mint_token(th.bob.keypair, BOB_INITIAL, th.bob.keypair.public)?;
info!(target: "money", "[Faucet] =============================");
info!(target: "money", "[Faucet] Executing Alice token mint tx");
info!(target: "money", "[Faucet] =============================");
th.faucet_state.read().await.verify_transactions(&[alice_mint_tx.clone()], true).await?;
th.faucet_merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
th.faucet.state.read().await.verify_transactions(&[alice_mint_tx.clone()], true).await?;
th.faucet.merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
info!(target: "money", "[Faucet] ===========================");
info!(target: "money", "[Faucet] Executing Bob token mint tx");
info!(target: "money", "[Faucet] ===========================");
th.faucet_state.read().await.verify_transactions(&[bob_mint_tx.clone()], true).await?;
th.faucet_merkle_tree.append(&MerkleNode::from(bob_params.output.coin.inner()));
th.faucet.state.read().await.verify_transactions(&[bob_mint_tx.clone()], true).await?;
th.faucet.merkle_tree.append(&MerkleNode::from(bob_params.output.coin.inner()));
info!(target: "money", "[Alice] =============================");
info!(target: "money", "[Alice] Executing Alice token mint tx");
info!(target: "money", "[Alice] =============================");
th.alice_state.read().await.verify_transactions(&[alice_mint_tx.clone()], true).await?;
th.alice_merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
th.alice.state.read().await.verify_transactions(&[alice_mint_tx.clone()], true).await?;
th.alice.merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
// Alice has to witness this coin because it's hers.
let alice_leaf_pos = th.alice_merkle_tree.witness().unwrap();
let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
info!(target: "money", "[Alice] ===========================");
info!(target: "money", "[Alice] Executing Bob token mint tx");
info!(target: "money", "[Alice] ===========================");
th.alice_state.read().await.verify_transactions(&[bob_mint_tx.clone()], true).await?;
th.alice_merkle_tree.append(&MerkleNode::from(bob_params.output.coin.inner()));
th.alice.state.read().await.verify_transactions(&[bob_mint_tx.clone()], true).await?;
th.alice.merkle_tree.append(&MerkleNode::from(bob_params.output.coin.inner()));
info!(target: "money", "[Bob] =============================");
info!(target: "money", "[Bob] Executing Alice token mint tx");
info!(target: "money", "[Bob] =============================");
th.bob_state.read().await.verify_transactions(&[alice_mint_tx.clone()], true).await?;
th.bob_merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
th.bob.state.read().await.verify_transactions(&[alice_mint_tx.clone()], true).await?;
th.bob.merkle_tree.append(&MerkleNode::from(alice_params.output.coin.inner()));
info!(target: "money", "[Bob] ===========================");
info!(target: "money", "[Bob] Executing Bob token mint tx");
info!(target: "money", "[Bob] ===========================");
th.bob_state.read().await.verify_transactions(&[bob_mint_tx.clone()], true).await?;
th.bob_merkle_tree.append(&MerkleNode::from(bob_params.output.coin.inner()));
let bob_leaf_pos = th.bob_merkle_tree.witness().unwrap();
th.bob.state.read().await.verify_transactions(&[bob_mint_tx.clone()], true).await?;
th.bob.merkle_tree.append(&MerkleNode::from(bob_params.output.coin.inner()));
let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
assert!(th.alice_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.faucet_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
assert!(th.faucet.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
// Alice builds an `OwnCoin` from her airdrop
let note: MoneyNote = alice_params.output.note.decrypt(&th.alice_kp.secret)?;
let note: MoneyNote = alice_params.output.note.decrypt(&th.alice.keypair.secret)?;
let alice_token_id = note.token_id;
let alice_oc = OwnCoin {
coin: Coin::from(alice_params.output.coin),
note: note.clone(),
secret: th.alice_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.alice_kp.secret.inner(), note.serial])),
secret: th.alice.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.alice.keypair.secret.inner(), note.serial])),
leaf_position: alice_leaf_pos,
};
alice_owncoins.push(alice_oc);
// Bob too
let note: MoneyNote = bob_params.output.note.decrypt(&th.bob_kp.secret)?;
let note: MoneyNote = bob_params.output.note.decrypt(&th.bob.keypair.secret)?;
let bob_token_id = note.token_id;
let bob_oc = OwnCoin {
coin: Coin::from(bob_params.output.coin),
note: note.clone(),
secret: th.bob_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob_kp.secret.inner(), note.serial])),
secret: th.bob.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob.keypair.secret.inner(), note.serial])),
leaf_position: bob_leaf_pos,
};
bob_owncoins.push(bob_oc);
@@ -204,8 +166,8 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Alice] Building Money::Transfer params for a payment to Bob");
info!(target: "money", "[Alice] ====================================================");
let alice2bob_call_debris = TransferCallBuilder {
keypair: th.alice_kp,
recipient: th.bob_kp.public,
keypair: th.alice.keypair,
recipient: th.bob.keypair.public,
value: ALICE_FIRST_SEND,
token_id: alice_token_id,
rcpt_spend_hook,
@@ -215,11 +177,11 @@ async fn money_contract_transfer() -> Result<()> {
change_user_data,
change_user_data_blind,
coins: alice_owncoins.clone(),
tree: th.alice_merkle_tree.clone(),
mint_zkbin: th.mint_zkbin.clone(),
mint_pk: th.mint_pk.clone(),
burn_zkbin: th.burn_zkbin.clone(),
burn_pk: th.burn_pk.clone(),
tree: th.alice.merkle_tree.clone(),
mint_zkbin: mint_zkbin.clone(),
mint_pk: mint_pk.clone(),
burn_zkbin: burn_zkbin.clone(),
burn_pk: burn_pk.clone(),
clear_input: false,
}
.build()?;
@@ -241,7 +203,7 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Alice] ==========================");
let mut data = vec![MoneyTransfer as u8];
alice2bob_params.encode(&mut data)?;
let calls = vec![ContractCall { contract_id: th.money_contract_id, data }];
let calls = vec![ContractCall { contract_id, data }];
let proofs = vec![alice2bob_proofs];
let mut alice2bob_tx = Transaction { calls, proofs, signatures: vec![] };
let sigs = alice2bob_tx.create_sigs(&mut OsRng, &alice2bob_secret_keys)?;
@@ -250,47 +212,47 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Faucet] ==============================");
info!(target: "money", "[Faucet] Executing Alice2Bob payment tx");
info!(target: "money", "[Faucet] ==============================");
th.faucet_state.read().await.verify_transactions(&[alice2bob_tx.clone()], true).await?;
th.faucet_merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
th.faucet_merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
th.faucet.state.read().await.verify_transactions(&[alice2bob_tx.clone()], true).await?;
th.faucet.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
th.faucet.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
info!(target: "money", "[Alice] ==============================");
info!(target: "money", "[Alice] Executing Alice2Bob payment tx");
info!(target: "money", "[Alice] ==============================");
th.alice_state.read().await.verify_transactions(&[alice2bob_tx.clone()], true).await?;
th.alice_merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
let alice_leaf_pos = th.alice_merkle_tree.witness().unwrap();
th.alice_merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
th.alice.state.read().await.verify_transactions(&[alice2bob_tx.clone()], true).await?;
th.alice.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
th.alice.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
info!(target: "money", "[Bob] ==============================");
info!(target: "money", "[Bob] Executing Alice2Bob payment tx");
info!(target: "money", "[Bob] ==============================");
th.bob_state.read().await.verify_transactions(&[alice2bob_tx.clone()], true).await?;
th.bob_merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
th.bob_merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
let bob_leaf_pos = th.bob_merkle_tree.witness().unwrap();
th.bob.state.read().await.verify_transactions(&[alice2bob_tx.clone()], true).await?;
th.bob.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[0].coin.inner()));
th.bob.merkle_tree.append(&MerkleNode::from(alice2bob_params.outputs[1].coin.inner()));
let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
assert!(th.alice_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.faucet_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
assert!(th.faucet.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
// Alice should now have one OwnCoin with the change from the above transaction.
let note: MoneyNote = alice2bob_params.outputs[0].note.decrypt(&th.alice_kp.secret)?;
let note: MoneyNote = alice2bob_params.outputs[0].note.decrypt(&th.alice.keypair.secret)?;
let alice_oc = OwnCoin {
coin: Coin::from(alice2bob_params.outputs[0].coin),
note: note.clone(),
secret: th.alice_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.alice_kp.secret.inner(), note.serial])),
secret: th.alice.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.alice.keypair.secret.inner(), note.serial])),
leaf_position: alice_leaf_pos,
};
alice_owncoins.push(alice_oc);
// Bob should have his old one, and this new one.
let note: MoneyNote = alice2bob_params.outputs[1].note.decrypt(&th.bob_kp.secret)?;
let note: MoneyNote = alice2bob_params.outputs[1].note.decrypt(&th.bob.keypair.secret)?;
let bob_oc = OwnCoin {
coin: Coin::from(alice2bob_params.outputs[1].coin),
note: note.clone(),
secret: th.bob_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob_kp.secret.inner(), note.serial])),
secret: th.bob.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob.keypair.secret.inner(), note.serial])),
leaf_position: bob_leaf_pos,
};
bob_owncoins.push(bob_oc);
@@ -305,8 +267,8 @@ async fn money_contract_transfer() -> Result<()> {
let mut bob_owncoins_tmp = bob_owncoins.clone();
bob_owncoins_tmp.retain(|x| x.note.token_id == bob_token_id);
let bob2alice_call_debris = TransferCallBuilder {
keypair: th.bob_kp,
recipient: th.alice_kp.public,
keypair: th.bob.keypair,
recipient: th.alice.keypair.public,
value: BOB_FIRST_SEND,
token_id: bob_token_id,
rcpt_spend_hook,
@@ -315,12 +277,12 @@ async fn money_contract_transfer() -> Result<()> {
change_spend_hook,
change_user_data,
change_user_data_blind,
coins: bob_owncoins.clone(),
tree: th.bob_merkle_tree.clone(),
mint_zkbin: th.mint_zkbin.clone(),
mint_pk: th.mint_pk.clone(),
burn_zkbin: th.burn_zkbin.clone(),
burn_pk: th.burn_pk.clone(),
coins: bob_owncoins_tmp.clone(),
tree: th.bob.merkle_tree.clone(),
mint_zkbin: mint_zkbin.clone(),
mint_pk: mint_pk.clone(),
burn_zkbin: burn_zkbin.clone(),
burn_pk: burn_pk.clone(),
clear_input: false,
}
.build()?;
@@ -342,7 +304,7 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Bob] ============================");
let mut data = vec![MoneyTransfer as u8];
bob2alice_params.encode(&mut data)?;
let calls = vec![ContractCall { contract_id: th.money_contract_id, data }];
let calls = vec![ContractCall { contract_id, data }];
let proofs = vec![bob2alice_proofs];
let mut bob2alice_tx = Transaction { calls, proofs, signatures: vec![] };
let sigs = bob2alice_tx.create_sigs(&mut OsRng, &bob2alice_secret_keys)?;
@@ -351,52 +313,52 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Faucet] ==============================");
info!(target: "money", "[Faucet] Executing Bob2Alice payment tx");
info!(target: "money", "[Faucet] ==============================");
th.faucet_state.read().await.verify_transactions(&[bob2alice_tx.clone()], true).await?;
th.faucet_merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
th.faucet_merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
th.faucet.state.read().await.verify_transactions(&[bob2alice_tx.clone()], true).await?;
th.faucet.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
th.faucet.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
info!(target: "money", "[Alice] ==============================");
info!(target: "money", "[Alice] Executing Bob2Alice payment tx");
info!(target: "money", "[Alice] ==============================");
th.alice_state.read().await.verify_transactions(&[bob2alice_tx.clone()], true).await?;
th.alice_merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
th.alice_merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
let alice_leaf_pos = th.alice_merkle_tree.witness().unwrap();
th.alice.state.read().await.verify_transactions(&[bob2alice_tx.clone()], true).await?;
th.alice.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
th.alice.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
info!(target: "money", "[Bob] ==================+===========");
info!(target: "money", "[Bob] Executing Bob2Alice payment tx");
info!(target: "money", "[Bob] ==================+===========");
th.bob_state.read().await.verify_transactions(&[bob2alice_tx.clone()], true).await?;
th.bob_merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
let bob_leaf_pos = th.bob_merkle_tree.witness().unwrap();
th.bob_merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
th.bob.state.read().await.verify_transactions(&[bob2alice_tx.clone()], true).await?;
th.bob.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[0].coin.inner()));
let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
th.bob.merkle_tree.append(&MerkleNode::from(bob2alice_params.outputs[1].coin.inner()));
// Alice should now have two OwnCoins
let note: MoneyNote = bob2alice_params.outputs[1].note.decrypt(&th.alice_kp.secret)?;
let note: MoneyNote = bob2alice_params.outputs[1].note.decrypt(&th.alice.keypair.secret)?;
let alice_oc = OwnCoin {
coin: Coin::from(bob2alice_params.outputs[1].coin),
note: note.clone(),
secret: th.alice_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.alice_kp.secret.inner(), note.serial])),
secret: th.alice.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.alice.keypair.secret.inner(), note.serial])),
leaf_position: alice_leaf_pos,
};
alice_owncoins.push(alice_oc);
// Bob should have two with the change from the above tx
let note: MoneyNote = bob2alice_params.outputs[0].note.decrypt(&th.bob_kp.secret)?;
let note: MoneyNote = bob2alice_params.outputs[0].note.decrypt(&th.bob.keypair.secret)?;
let bob_oc = OwnCoin {
coin: Coin::from(bob2alice_params.outputs[0].coin),
note: note.clone(),
secret: th.bob_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob_kp.secret.inner(), note.serial])),
secret: th.bob.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob.keypair.secret.inner(), note.serial])),
leaf_position: bob_leaf_pos,
};
bob_owncoins.push(bob_oc);
assert!(alice_owncoins.len() == 2);
assert!(bob_owncoins.len() == 2);
assert!(th.alice_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.faucet_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
assert!(th.faucet.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
assert!(alice_owncoins[0].note.value == ALICE_INITIAL - ALICE_FIRST_SEND);
assert!(alice_owncoins[0].note.token_id == alice_token_id);
@@ -414,13 +376,11 @@ async fn money_contract_transfer() -> Result<()> {
// Generating swap blinds
let value_send_blind = ValueBlind::random(&mut OsRng);
let value_recv_blind = ValueBlind::random(&mut OsRng);
let value_blinds = [value_send_blind, value_recv_blind];
let token_send_blind = ValueBlind::random(&mut OsRng);
let token_recv_blind = ValueBlind::random(&mut OsRng);
let token_blinds = [token_send_blind, token_recv_blind];
let alice_swap_call_debris = SwapCallBuilder {
pubkey: th.alice_kp.public,
pubkey: th.alice.keypair.public,
value_send: BOB_FIRST_SEND,
token_id_send: bob_token_id,
value_recv: ALICE_FIRST_SEND,
@@ -428,14 +388,14 @@ async fn money_contract_transfer() -> Result<()> {
user_data_blind_send: rcpt_user_data_blind,
spend_hook_recv: rcpt_spend_hook,
user_data_recv: rcpt_user_data,
value_blinds,
token_blinds,
value_blinds: [value_send_blind, value_recv_blind],
token_blinds: [token_send_blind, token_recv_blind],
coin: alice_owncoins[1].clone(),
tree: th.alice_merkle_tree.clone(),
mint_zkbin: th.mint_zkbin.clone(),
mint_pk: th.mint_pk.clone(),
burn_zkbin: th.burn_zkbin.clone(),
burn_pk: th.burn_pk.clone(),
tree: th.alice.merkle_tree.clone(),
mint_zkbin: mint_zkbin.clone(),
mint_pk: mint_pk.clone(),
burn_zkbin: burn_zkbin.clone(),
burn_pk: burn_pk.clone(),
}
.build()?;
let (alice_swap_params, alice_swap_proofs) =
@@ -449,7 +409,7 @@ async fn money_contract_transfer() -> Result<()> {
// Alice sends Bob necessary data and he builds his half.
info!(target: "money", "[Bob] Building OtcSwap half");
let bob_swap_call_debris = SwapCallBuilder {
pubkey: th.bob_kp.public,
pubkey: th.bob.keypair.public,
value_send: ALICE_FIRST_SEND,
token_id_send: alice_token_id,
value_recv: BOB_FIRST_SEND,
@@ -457,14 +417,14 @@ async fn money_contract_transfer() -> Result<()> {
user_data_blind_send: rcpt_user_data_blind,
spend_hook_recv: rcpt_spend_hook,
user_data_recv: rcpt_user_data,
value_blinds,
token_blinds,
value_blinds: [value_recv_blind, value_send_blind],
token_blinds: [token_recv_blind, token_send_blind],
coin: bob_owncoins[0].clone(),
tree: th.bob_merkle_tree.clone(),
mint_zkbin: th.mint_zkbin.clone(),
mint_pk: th.mint_pk.clone(),
burn_zkbin: th.burn_zkbin.clone(),
burn_pk: th.burn_pk.clone(),
tree: th.bob.merkle_tree.clone(),
mint_zkbin: mint_zkbin.clone(),
mint_pk: mint_pk.clone(),
burn_zkbin: burn_zkbin.clone(),
burn_pk: burn_pk.clone(),
}
.build()?;
let (bob_swap_params, bob_swap_proofs) =
@@ -493,50 +453,57 @@ async fn money_contract_transfer() -> Result<()> {
let mut data = vec![MoneyOtcSwap as u8];
swap_full_params.encode(&mut data)?;
let mut alicebob_swap_tx = Transaction {
calls: vec![ContractCall { contract_id: th.money_contract_id, data }],
calls: vec![ContractCall { contract_id, data }],
proofs: vec![swap_full_proofs],
signatures: vec![],
};
let sigs = alicebob_swap_tx.create_sigs(&mut OsRng, &[th.bob_kp.secret])?;
let bob_note: MoneyNote = swap_full_params.outputs[1].note.decrypt(&th.bob.keypair.secret)?;
let sigs = alicebob_swap_tx.create_sigs(&mut OsRng, &[deserialize(&bob_note.memo)?])?;
alicebob_swap_tx.signatures = vec![sigs];
// Alice gets the partially signed transaction and adds her signature
let sigs = alicebob_swap_tx.create_sigs(&mut OsRng, &[th.alice_kp.secret])?;
let alice_note: MoneyNote =
swap_full_params.outputs[0].note.decrypt(&th.alice.keypair.secret)?;
let sigs = alicebob_swap_tx.create_sigs(&mut OsRng, &[deserialize(&alice_note.memo)?])?;
alicebob_swap_tx.signatures[0].insert(0, sigs[0]);
info!(target: "money", "[Faucet] ==========================");
info!(target: "money", "[Faucet] Executing AliceBob swap tx");
info!(target: "money", "[Faucet] ==========================");
th.faucet_state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.faucet_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
th.faucet_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
th.faucet.state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.faucet.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
th.faucet.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
info!(target: "money", "[Alice] ==========================");
info!(target: "money", "[Alice] Executing AliceBob swap tx");
info!(target: "money", "[Alice] ==========================");
th.alice_state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.alice_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
let alice_leaf_pos = th.alice_merkle_tree.witness().unwrap();
th.alice_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
th.alice.state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.alice.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
th.alice.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
info!(target: "money", "[Bob] ==========================");
info!(target: "money", "[Bob] Executing AliceBob swap tx");
info!(target: "money", "[Bob] ==========================");
th.bob_state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.bob_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
th.bob_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
let bob_leaf_pos = th.bob_merkle_tree.witness().unwrap();
th.bob.state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.bob.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
th.bob.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
assert!(th.alice_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.faucet_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
assert!(th.faucet.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
// Alice should now have two OwnCoins with the same token ID (ALICE)
let note: MoneyNote = swap_full_params.outputs[0].note.decrypt(&th.alice_kp.secret)?;
let alice_note: MoneyNote =
swap_full_params.outputs[0].note.decrypt(&th.alice.keypair.secret)?;
let alice_oc = OwnCoin {
coin: Coin::from(swap_full_params.outputs[0].coin),
note: note.clone(),
secret: th.alice_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.alice_kp.secret.inner(), note.serial])),
note: alice_note.clone(),
secret: th.alice.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([
th.alice.keypair.secret.inner(),
alice_note.serial,
])),
leaf_position: alice_leaf_pos,
};
alice_owncoins.push(alice_oc);
@@ -546,12 +513,11 @@ async fn money_contract_transfer() -> Result<()> {
assert!(alice_owncoins[1].note.token_id == alice_token_id);
// Same for Bob with BOB tokens
let note: MoneyNote = swap_full_params.outputs[1].note.decrypt(&th.bob_kp.secret)?;
let bob_oc = OwnCoin {
coin: Coin::from(swap_full_params.outputs[1].coin),
note: note.clone(),
secret: th.bob_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob_kp.secret.inner(), note.serial])),
note: bob_note.clone(),
secret: th.bob.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob.keypair.secret.inner(), bob_note.serial])),
leaf_position: bob_leaf_pos,
};
bob_owncoins.push(bob_oc);
@@ -565,8 +531,8 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Alice] Building Money::Transfer params for a payment to Alice");
info!(target: "money", "[Alice] =======================================================");
let alice2alice_call_debris = TransferCallBuilder {
keypair: th.alice_kp,
recipient: th.alice_kp.public,
keypair: th.alice.keypair,
recipient: th.alice.keypair.public,
value: ALICE_INITIAL,
token_id: alice_token_id,
rcpt_spend_hook,
@@ -576,11 +542,11 @@ async fn money_contract_transfer() -> Result<()> {
change_user_data,
change_user_data_blind,
coins: alice_owncoins.clone(),
tree: th.alice_merkle_tree.clone(),
mint_zkbin: th.mint_zkbin.clone(),
mint_pk: th.mint_pk.clone(),
burn_zkbin: th.burn_zkbin.clone(),
burn_pk: th.burn_pk.clone(),
tree: th.alice.merkle_tree.clone(),
mint_zkbin: mint_zkbin.clone(),
mint_pk: mint_pk.clone(),
burn_zkbin: burn_zkbin.clone(),
burn_pk: burn_pk.clone(),
clear_input: false,
}
.build()?;
@@ -603,7 +569,7 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Alice] ============================");
let mut data = vec![MoneyTransfer as u8];
alice2alice_params.encode(&mut data)?;
let calls = vec![ContractCall { contract_id: th.money_contract_id, data }];
let calls = vec![ContractCall { contract_id, data }];
let proofs = vec![alice2alice_proofs];
let mut alice2alice_tx = Transaction { calls, proofs, signatures: vec![] };
let sigs = alice2alice_tx.create_sigs(&mut OsRng, &alice2alice_secret_keys)?;
@@ -612,32 +578,32 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Faucet] ================================");
info!(target: "money", "[Faucet] Executing Alice2Alice payment tx");
info!(target: "money", "[Faucet] ================================");
th.faucet_state.read().await.verify_transactions(&[alice2alice_tx.clone()], true).await?;
th.faucet_merkle_tree.append(&MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
th.faucet.state.read().await.verify_transactions(&[alice2alice_tx.clone()], true).await?;
th.faucet.merkle_tree.append(&MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
info!(target: "money", "[Alice] ================================");
info!(target: "money", "[Alice] Executing Alice2Alice payment tx");
info!(target: "money", "[Alice] ================================");
th.alice_state.read().await.verify_transactions(&[alice2alice_tx.clone()], true).await?;
th.alice_merkle_tree.append(&MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
let alice_leaf_pos = th.alice_merkle_tree.witness().unwrap();
th.alice.state.read().await.verify_transactions(&[alice2alice_tx.clone()], true).await?;
th.alice.merkle_tree.append(&MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
info!(target: "money", "[Bob] ================================");
info!(target: "money", "[Bob] Executing Alice2Alice payment tx");
info!(target: "money", "[Bob] ================================");
th.bob_state.read().await.verify_transactions(&[alice2alice_tx.clone()], true).await?;
th.bob_merkle_tree.append(&MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
th.bob.state.read().await.verify_transactions(&[alice2alice_tx.clone()], true).await?;
th.bob.merkle_tree.append(&MerkleNode::from(alice2alice_params.outputs[0].coin.inner()));
assert!(th.alice_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.faucet_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
assert!(th.faucet.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
// Alice should now have a single OwnCoin with her initial airdrop
let note: MoneyNote = alice2alice_params.outputs[0].note.decrypt(&th.alice_kp.secret)?;
let note: MoneyNote = alice2alice_params.outputs[0].note.decrypt(&th.alice.keypair.secret)?;
let alice_oc = OwnCoin {
coin: Coin::from(alice2alice_params.outputs[0].coin),
note: note.clone(),
secret: th.alice_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.alice_kp.secret.inner(), note.serial])),
secret: th.alice.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.alice.keypair.secret.inner(), note.serial])),
leaf_position: alice_leaf_pos,
};
alice_owncoins.push(alice_oc);
@@ -651,8 +617,8 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Bob] Building Money::Transfer params for a payment to Bob");
info!(target: "money", "[Bob] ====================================================");
let bob2bob_call_debris = TransferCallBuilder {
keypair: th.bob_kp,
recipient: th.bob_kp.public,
keypair: th.bob.keypair,
recipient: th.bob.keypair.public,
value: BOB_INITIAL,
token_id: bob_token_id,
rcpt_spend_hook,
@@ -662,11 +628,11 @@ async fn money_contract_transfer() -> Result<()> {
change_user_data,
change_user_data_blind,
coins: bob_owncoins.clone(),
tree: th.bob_merkle_tree.clone(),
mint_zkbin: th.mint_zkbin.clone(),
mint_pk: th.mint_pk.clone(),
burn_zkbin: th.burn_zkbin.clone(),
burn_pk: th.burn_pk.clone(),
tree: th.bob.merkle_tree.clone(),
mint_zkbin: mint_zkbin.clone(),
mint_pk: mint_pk.clone(),
burn_zkbin: burn_zkbin.clone(),
burn_pk: burn_pk.clone(),
clear_input: false,
}
.build()?;
@@ -689,7 +655,7 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Bob] ==========================");
let mut data = vec![MoneyTransfer as u8];
bob2bob_params.encode(&mut data)?;
let calls = vec![ContractCall { contract_id: th.money_contract_id, data }];
let calls = vec![ContractCall { contract_id, data }];
let proofs = vec![bob2bob_proofs];
let mut bob2bob_tx = Transaction { calls, proofs, signatures: vec![] };
let sigs = bob2bob_tx.create_sigs(&mut OsRng, &bob2bob_secret_keys)?;
@@ -698,32 +664,32 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Faucet] ============================");
info!(target: "money", "[Faucet] Executing Bob2Bob payment tx");
info!(target: "money", "[Faucet] ============================");
th.faucet_state.read().await.verify_transactions(&[bob2bob_tx.clone()], true).await?;
th.faucet_merkle_tree.append(&MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
th.faucet.state.read().await.verify_transactions(&[bob2bob_tx.clone()], true).await?;
th.faucet.merkle_tree.append(&MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
info!(target: "money", "[Alice] ============================");
info!(target: "money", "[Alice] Executing Bob2Bob payment tx");
info!(target: "money", "[Alice] ============================");
th.alice_state.read().await.verify_transactions(&[bob2bob_tx.clone()], true).await?;
th.alice_merkle_tree.append(&MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
th.alice.state.read().await.verify_transactions(&[bob2bob_tx.clone()], true).await?;
th.alice.merkle_tree.append(&MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
info!(target: "money", "[Bob] ============================");
info!(target: "money", "[Bob] Executing Bob2Bob payment tx");
info!(target: "money", "[Bob] ============================");
th.bob_state.read().await.verify_transactions(&[bob2bob_tx.clone()], true).await?;
th.bob_merkle_tree.append(&MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
let bob_leaf_pos = th.bob_merkle_tree.witness().unwrap();
th.bob.state.read().await.verify_transactions(&[bob2bob_tx.clone()], true).await?;
th.bob.merkle_tree.append(&MerkleNode::from(bob2bob_params.outputs[0].coin.inner()));
let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
assert!(th.alice_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.faucet_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
assert!(th.faucet.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
// Bob should now have a single OwnCoin with her initial airdrop
let note: MoneyNote = bob2bob_params.outputs[0].note.decrypt(&th.bob_kp.secret)?;
let note: MoneyNote = bob2bob_params.outputs[0].note.decrypt(&th.bob.keypair.secret)?;
let bob_oc = OwnCoin {
coin: Coin::from(bob2bob_params.outputs[0].coin),
note: note.clone(),
secret: th.bob_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob_kp.secret.inner(), note.serial])),
secret: th.bob.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob.keypair.secret.inner(), note.serial])),
leaf_position: bob_leaf_pos,
};
bob_owncoins.push(bob_oc);
@@ -737,13 +703,11 @@ async fn money_contract_transfer() -> Result<()> {
// Generating swap blinds
let value_send_blind = ValueBlind::random(&mut OsRng);
let value_recv_blind = ValueBlind::random(&mut OsRng);
let value_blinds = [value_send_blind, value_recv_blind];
let token_send_blind = ValueBlind::random(&mut OsRng);
let token_recv_blind = ValueBlind::random(&mut OsRng);
let token_blinds = [token_send_blind, token_recv_blind];
let alice_swap_call_debris = SwapCallBuilder {
pubkey: th.alice_kp.public,
pubkey: th.alice.keypair.public,
value_send: ALICE_INITIAL,
token_id_send: alice_token_id,
value_recv: BOB_INITIAL,
@@ -751,14 +715,14 @@ async fn money_contract_transfer() -> Result<()> {
user_data_blind_send: rcpt_user_data_blind,
spend_hook_recv: rcpt_spend_hook,
user_data_recv: rcpt_user_data,
value_blinds,
token_blinds,
value_blinds: [value_send_blind, value_recv_blind],
token_blinds: [token_send_blind, token_recv_blind],
coin: alice_owncoins[0].clone(),
tree: th.alice_merkle_tree.clone(),
mint_zkbin: th.mint_zkbin.clone(),
mint_pk: th.mint_pk.clone(),
burn_zkbin: th.burn_zkbin.clone(),
burn_pk: th.burn_pk.clone(),
tree: th.alice.merkle_tree.clone(),
mint_zkbin: mint_zkbin.clone(),
mint_pk: mint_pk.clone(),
burn_zkbin: burn_zkbin.clone(),
burn_pk: burn_pk.clone(),
}
.build()?;
let (alice_swap_params, alice_swap_proofs) =
@@ -771,7 +735,7 @@ async fn money_contract_transfer() -> Result<()> {
info!(target: "money", "[Bob] Building OtcSwap half");
let bob_swap_call_debris = SwapCallBuilder {
pubkey: th.bob_kp.public,
pubkey: th.bob.keypair.public,
value_send: BOB_INITIAL,
token_id_send: bob_token_id,
value_recv: ALICE_INITIAL,
@@ -779,14 +743,14 @@ async fn money_contract_transfer() -> Result<()> {
user_data_blind_send: rcpt_user_data_blind,
spend_hook_recv: rcpt_spend_hook,
user_data_recv: rcpt_user_data,
value_blinds,
token_blinds,
value_blinds: [value_recv_blind, value_send_blind],
token_blinds: [token_recv_blind, token_send_blind],
coin: bob_owncoins[0].clone(),
tree: th.bob_merkle_tree.clone(),
mint_zkbin: th.mint_zkbin.clone(),
mint_pk: th.mint_pk.clone(),
burn_zkbin: th.burn_zkbin.clone(),
burn_pk: th.burn_pk.clone(),
tree: th.bob.merkle_tree.clone(),
mint_zkbin: mint_zkbin.clone(),
mint_pk: mint_pk.clone(),
burn_zkbin: burn_zkbin.clone(),
burn_pk: burn_pk.clone(),
}
.build()?;
let (bob_swap_params, bob_swap_proofs) =
@@ -814,50 +778,55 @@ async fn money_contract_transfer() -> Result<()> {
let mut data = vec![MoneyOtcSwap as u8];
swap_full_params.encode(&mut data)?;
let mut alicebob_swap_tx = Transaction {
calls: vec![ContractCall { contract_id: th.money_contract_id, data }],
calls: vec![ContractCall { contract_id, data }],
proofs: vec![swap_full_proofs],
signatures: vec![],
};
let sigs = alicebob_swap_tx.create_sigs(&mut OsRng, &[th.bob_kp.secret])?;
let bob_note: MoneyNote = swap_full_params.outputs[1].note.decrypt(&th.bob.keypair.secret)?;
let sigs = alicebob_swap_tx.create_sigs(&mut OsRng, &[deserialize(&bob_note.memo)?])?;
alicebob_swap_tx.signatures = vec![sigs];
// Alice gets the partially signed transaction and adds her signature
let sigs = alicebob_swap_tx.create_sigs(&mut OsRng, &[th.alice_kp.secret])?;
let alice_note: MoneyNote =
swap_full_params.outputs[0].note.decrypt(&th.alice.keypair.secret)?;
let sigs = alicebob_swap_tx.create_sigs(&mut OsRng, &[deserialize(&alice_note.memo)?])?;
alicebob_swap_tx.signatures[0].insert(0, sigs[0]);
info!(target: "money", "[Faucet] ==========================");
info!(target: "money", "[Faucet] Executing AliceBob swap tx");
info!(target: "money", "[Faucet] ==========================");
th.faucet_state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.faucet_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
th.faucet_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
th.faucet.state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.faucet.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
th.faucet.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
info!(target: "money", "[Alice] ==========================");
info!(target: "money", "[Alice] Executing AliceBob swap tx");
info!(target: "money", "[Alice] ==========================");
th.alice_state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.alice_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
let alice_leaf_pos = th.alice_merkle_tree.witness().unwrap();
th.alice_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
th.alice.state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.alice.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
let alice_leaf_pos = th.alice.merkle_tree.witness().unwrap();
th.alice.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
info!(target: "money", "[Bob] ==========================");
info!(target: "money", "[Bob] Executing AliceBob swap tx");
info!(target: "money", "[Bob] ==========================");
th.bob_state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.bob_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
th.bob_merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
let bob_leaf_pos = th.bob_merkle_tree.witness().unwrap();
th.bob.state.read().await.verify_transactions(&[alicebob_swap_tx.clone()], true).await?;
th.bob.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[0].coin.inner()));
th.bob.merkle_tree.append(&MerkleNode::from(swap_full_params.outputs[1].coin.inner()));
let bob_leaf_pos = th.bob.merkle_tree.witness().unwrap();
assert!(th.alice_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.faucet_merkle_tree.root(0).unwrap() == th.bob_merkle_tree.root(0).unwrap());
assert!(th.alice.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
assert!(th.faucet.merkle_tree.root(0).unwrap() == th.bob.merkle_tree.root(0).unwrap());
// Alice should now have Bob's BOB tokens
let note: MoneyNote = swap_full_params.outputs[0].note.decrypt(&th.alice_kp.secret)?;
let alice_oc = OwnCoin {
coin: Coin::from(swap_full_params.outputs[0].coin),
note: note.clone(),
secret: th.alice_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.alice_kp.secret.inner(), note.serial])),
note: alice_note.clone(),
secret: th.alice.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([
th.alice.keypair.secret.inner(),
alice_note.serial,
])),
leaf_position: alice_leaf_pos,
};
alice_owncoins.push(alice_oc);
@@ -867,12 +836,11 @@ async fn money_contract_transfer() -> Result<()> {
assert!(alice_owncoins[0].note.token_id == bob_token_id);
// And Bob should have Alice's ALICE tokens
let note: MoneyNote = swap_full_params.outputs[1].note.decrypt(&th.bob_kp.secret)?;
let bob_oc = OwnCoin {
coin: Coin::from(swap_full_params.outputs[1].coin),
note: note.clone(),
secret: th.bob_kp.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob_kp.secret.inner(), note.serial])),
note: bob_note.clone(),
secret: th.bob.keypair.secret, // <-- What should this be?
nullifier: Nullifier::from(poseidon_hash([th.bob.keypair.secret.inner(), bob_note.serial])),
leaf_position: bob_leaf_pos,
};
bob_owncoins.push(bob_oc);

4
src/contract/money/tests/verification_bench.rs
View File

@@ -213,11 +213,9 @@ async fn alice2alice_random_amounts_multiplecoins() -> Result<()> {
let mut minted_amounts = vec![];
let mut owncoins = vec![];
for i in 0..10 {
let token_id = TokenId::from(pallas::Base::random(&mut OsRng));
let amount = rand::thread_rng().gen_range(1..1000);
info!(target: "money", "[Faucet] ===================================================");
info!(target: "money", "[Faucet] Building Money::Mint params for Alice's mint for token {}: ID {} - amount {}", i, token_id, amount);
info!(target: "money", "[Faucet] Building Money::Mint params for Alice's mint for token {} and amount {}", i, amount);
info!(target: "money", "[Faucet] ===================================================");
let (mint_tx, mint_params) =
th.mint_token(th.alice.keypair, amount, th.alice.keypair.public)?;