zecfoundation
/
libbolt
mirror of https://github.com/ZcashFoundation/libbolt.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

More clean up and renaming structs for cust/merch

This commit is contained in:
J. Ayo Akinyele 2019-08-16 12:29:01 -04:00
parent 6ea87ec752
commit aaaccaeba0
7 changed files with 174 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.toml
View File

@ -1,7 +1,7 @@
[package]
name = "bolt"
version = "0.3.0"
authors = ["J. Ayo Akinyele <ayo@boltlabs.io>"]
authors = ["Bolt Labs, Inc <info@boltlabs.io>"]
description = "library for Blind Off-chain Lightweight Transactions (BOLT)"
keywords = ["zcash", "payment channels", "bolt"]
readme = "README.md"

54
src/channels.rs
View File

@ -195,7 +195,7 @@ struct WalletKeyPair {
<E as pairing::Engine>::G1: serde::Deserialize<'de>, \
<E as pairing::Engine>::G2: serde::Deserialize<'de>"
))]
pub struct CustomerWallet<E: Engine> {
pub struct CustomerState<E: Engine> {
pub name: String,
pub pk_c: secp256k1::PublicKey,
sk_c: secp256k1::SecretKey,
@ -212,7 +212,7 @@ pub struct CustomerWallet<E: Engine> {
pay_tokens: HashMap<i32, Signature<E>>
}
impl<E: Engine> CustomerWallet<E> {
impl<E: Engine> CustomerState<E> {
pub fn new<R: Rng>(csprng: &mut R, channel: &ChannelState<E>, channel_token: &mut ChannelToken<E>, cust_bal: i32, merch_bal: i32, name: String) -> Self {
let mut kp = secp256k1::Secp256k1::new();
kp.randomize(csprng);
@ -244,7 +244,7 @@ impl<E: Engine> CustomerWallet<E> {
let mut pt_db= HashMap::new();
println!("Customer wallet formed -> now returning the structure to the caller.");
return CustomerWallet {
return CustomerState {
name: name,
pk_c: pk_c,
sk_c: sk_c,
@ -275,7 +275,7 @@ impl<E: Engine> CustomerWallet<E> {
// generate nizk proof of knowledge of commitment opening
pub fn generate_proof<R: Rng>(&self, csprng: &mut R, channel_token: &ChannelToken<E>) -> CommitmentProof<E> {
return CommitmentProof::<E>::new(csprng, &channel_token.comParams, &self.w_com.c, &self.wallet.as_fr_vec(), &self.t);
return CommitmentProof::<E>::new(csprng, &channel_token.comParams, &self.w_com.c, &self.wallet.as_fr_vec(), &self.t, &vec![]);
}
pub fn verify_close_token(&mut self, channel: &ChannelState<E>, close_token: &Signature<E>) -> bool {
@ -335,7 +335,7 @@ impl<E: Engine> CustomerWallet<E> {
}
// for channel pay
pub fn generate_payment<R: Rng>(&self, csprng: &mut R, channel: &ChannelState<E>, amount: i32) -> (Proof<E>, Commitment<E>, secp256k1::PublicKey, CustomerWallet<E>) {
pub fn generate_payment<R: Rng>(&self, csprng: &mut R, channel: &ChannelState<E>, amount: i32) -> (Proof<E>, Commitment<E>, secp256k1::PublicKey, CustomerState<E>) {
// 1 - chooose new wpk/wsk pair
let mut kp = secp256k1::Secp256k1::new();
kp.randomize(csprng);
@ -362,7 +362,7 @@ impl<E: Engine> CustomerWallet<E> {
new_wcom.clone(), new_t, &prev_pay_token);
// update internal state after proof has been verified by remote
let new_cw = CustomerWallet {
let new_cw = CustomerState {
name: self.name.clone(),
pk_c: self.pk_c.clone(),
sk_c: self.sk_c.clone(),
@ -383,7 +383,7 @@ impl<E: Engine> CustomerWallet<E> {
}
// update the internal state of the customer wallet
pub fn update(&mut self, new_wallet: CustomerWallet<E>) -> bool {
pub fn update(&mut self, new_wallet: CustomerState<E>) -> bool {
// update everything except for the wpk/wsk pair
assert!(self.name == new_wallet.name);
self.cust_balance = new_wallet.cust_balance;
@ -419,14 +419,14 @@ impl<E: Engine> CustomerWallet<E> {
}
impl<E: Engine> fmt::Display for CustomerWallet<E> {
impl<E: Engine> fmt::Display for CustomerState<E> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut content = String::new();
content = format!("pk = {}\n", &self.pk_c);
content = format!("{}sk = {}\n", content, &self.sk_c);
content = format!("{}cust-bal = {}\n", content, &self.cust_balance);
content = format!("{}merch-bal = {}\n", content, &self.merch_balance);
write!(f, "CustomerWallet : (\n{}\n)", &content)
write!(f, "CustomerState : (\n{}\n)", &content)
}
}
@ -443,7 +443,7 @@ impl<E: Engine> fmt::Display for CustomerWallet<E> {
<E as pairing::Engine>::G1: serde::Deserialize<'de>, \
<E as pairing::Engine>::G2: serde::Deserialize<'de>"
))]
pub struct MerchantWallet<E: Engine> {
pub struct MerchantState<E: Engine> {
keypair: cl::BlindKeyPair<E>,
pub balance: i32,
pk: secp256k1::PublicKey, // pk_m
@ -453,7 +453,7 @@ pub struct MerchantWallet<E: Engine> {
pub pay_tokens: HashMap<String, cl::Signature<E>>
}
impl<E: Engine> MerchantWallet<E> {
impl<E: Engine> MerchantState<E> {
pub fn new<R: Rng>(csprng: &mut R, channel: &mut ChannelState<E>, id: String) -> Self {
// generate keys here
let mut tx_kp = secp256k1::Secp256k1::new();
@ -461,7 +461,7 @@ impl<E: Engine> MerchantWallet<E> {
let (wsk, wpk) = tx_kp.generate_keypair(csprng);
let cp = channel.cp.as_ref().unwrap(); // if not set, then panic!
MerchantWallet {
MerchantState {
keypair: cp.pub_params.keypair.clone(),
balance: 0,
pk: wpk,
@ -582,57 +582,57 @@ mod tests {
// each party executes the init algorithm on the agreed initial challenge balance
// in order to derive the channel tokens
// initialize on the merchant side with balance: b0_merch
let mut merch_wallet = MerchantWallet::<Bls12>::new(rng, &mut channel, String::from("Merchant B"));
let mut merch_state = MerchantState::<Bls12>::new(rng, &mut channel, String::from("Merchant B"));
// initialize the merchant wallet with the balance
let mut channel_token = merch_wallet.init(rng, &mut channel);
let mut channel_token = merch_state.init(rng, &mut channel);
// retrieve commitment setup params (using merchant long lived pk params)
// initialize on the customer side with balance: b0_cust
let mut cust_wallet = CustomerWallet::<Bls12>::new(rng, &mut channel, &mut channel_token, b0_cust, b0_merch, String::from("Alice"));
let mut cust_state = CustomerState::<Bls12>::new(rng, &mut channel, &mut channel_token, b0_cust, b0_merch, String::from("Alice"));
// lets establish the channel
let cust_com_proof = cust_wallet.generate_proof(rng, &mut channel_token);
let cust_com_proof = cust_state.generate_proof(rng, &mut channel_token);
// first return the close token, then wait for escrow-tx confirmation
// then send the pay-token after confirmation
let (close_token, pay_token) = merch_wallet.verify_proof(rng, &channel, &cust_wallet.w_com, &cust_com_proof).unwrap();
let (close_token, pay_token) = merch_state.verify_proof(rng, &channel, &cust_state.w_com, &cust_com_proof).unwrap();
// unblind tokens and verify signatures
assert!(cust_wallet.verify_close_token(&channel, &close_token));
assert!(cust_state.verify_close_token(&channel, &close_token));
assert!(cust_wallet.verify_pay_token(&channel, &pay_token));
assert!(cust_state.verify_pay_token(&channel, &pay_token));
println!("Done!");
// pay protocol tests
let amount = 10;
let (pay_proof, new_com, old_wpk, new_cw) = cust_wallet.generate_payment(rng, &channel, amount);
let (pay_proof, new_com, old_wpk, new_cw) = cust_state.generate_payment(rng, &channel, amount);
// println!("{}", new_com);
// println!("wpk => {}", old_wpk);
// println!("{}", new_cw);
// new pay_token is not sent until revoke_token is obtained from the customer
let new_close_token = merch_wallet.verify_payment(rng, &channel, &pay_proof, &new_com, &old_wpk, amount).unwrap();
let new_close_token = merch_state.verify_payment(rng, &channel, &pay_proof, &new_com, &old_wpk, amount).unwrap();
//println!("1 - Updated close Token : {}", new_close_token);
// unblind tokens and verify signatures
// assuming the pay_proof checks out, can go ahead and update internal state of cust_wallet
assert!(cust_wallet.update(new_cw));
// assuming the pay_proof checks out, can go ahead and update internal state of cust_state
assert!(cust_state.update(new_cw));
//println!("2 - updated customer wallet!");
assert!(cust_wallet.verify_close_token(&channel, &new_close_token));
assert!(cust_state.verify_close_token(&channel, &new_close_token));
//println!("3 - verified the close token!");
// invalidate the previous state only if close token checks out
let (revoke_msg, revoke_sig) = cust_wallet.generate_revoke_token(&channel, &new_close_token).unwrap();
let (revoke_msg, revoke_sig) = cust_state.generate_revoke_token(&channel, &new_close_token).unwrap();
//println!("4 - Generated revoke token successfully.");
//println!("5 - Revoke token => {}", revoke_token);
let new_pay_token = merch_wallet.verify_revoke_token(&revoke_sig, &revoke_msg, &old_wpk).unwrap();
assert!(cust_wallet.verify_pay_token(&channel, &new_pay_token));
let new_pay_token = merch_state.verify_revoke_token(&revoke_sig, &revoke_msg, &old_wpk).unwrap();
assert!(cust_state.verify_pay_token(&channel, &new_pay_token));
//println!("Validated revoke token!");
}

1
src/cl.rs
View File

@ -493,6 +493,7 @@ impl<E: Engine> BlindKeyPair<E> {
let mut t = tOptional.unwrap_or(Vec::<E::Fr>::with_capacity(self.public.Y2.len()));
let tt = ttOptional.unwrap_or(E::Fr::rand(rng));
let mut a = E::Fqk::one();
// TODO: consider optimizations to pairing in loop
for j in 0..self.public.Y2.len() {
if t.len() == j {
t.push(E::Fr::rand(rng));

92
src/ffishim.rs
View File

@ -80,11 +80,11 @@ pub mod ffishim {
let bytes = unsafe { CStr::from_ptr(name_ptr).to_bytes() };
let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8
let (channel_token, mut merch_wallet) = bidirectional::init_merchant(rng, &mut channel_state, name);
// initialize the balance for merch_wallet
merch_wallet.init_balance(balance);
let (channel_token, mut merch_state) = bidirectional::init_merchant(rng, &mut channel_state, name);
// initialize the balance for merch_state
merch_state.init_balance(balance);
let ser = ["{\'channel_token\':\'", serde_json::to_string(&channel_token).unwrap().as_str(), "\', \'merch_wallet\':\'", serde_json::to_string(&merch_wallet).unwrap().as_str() ,"\'}"].concat();
let ser = ["{\'channel_token\':\'", serde_json::to_string(&channel_token).unwrap().as_str(), "\', \'merch_state\':\'", serde_json::to_string(&merch_state).unwrap().as_str() ,"\'}"].concat();
let cser = CString::new(ser).unwrap();
cser.into_raw()
@ -102,15 +102,15 @@ pub mod ffishim {
let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8
// We change the channel state
let cust_wallet = bidirectional::init_customer(rng, &channel_state, &mut channel_token, balance_customer, balance_merchant, name);
let ser = ["{\'cust_wallet\':\'", serde_json::to_string(&cust_wallet).unwrap().as_str(), "\', \'channel_token\':\'", serde_json::to_string(&channel_token).unwrap().as_str() ,"\'}"].concat();
let cust_state = bidirectional::init_customer(rng, &channel_state, &mut channel_token, balance_customer, balance_merchant, name);
let ser = ["{\'cust_state\':\'", serde_json::to_string(&cust_state).unwrap().as_str(), "\', \'channel_token\':\'", serde_json::to_string(&channel_token).unwrap().as_str() ,"\'}"].concat();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
// ESTABLISH
#[no_mangle] // bidirectional::establish_customer_generate_proof(rng, &mut channel_token, &mut cust_wallet);
#[no_mangle] // bidirectional::establish_customer_generate_proof(rng, &mut channel_token, &mut cust_state);
pub extern fn ffishim_bidirectional_establish_customer_generate_proof(ser_channel_token: *mut c_char,
ser_customer_wallet: *mut c_char) -> *mut c_char {
let mut rng = &mut rand::thread_rng();
@ -118,11 +118,11 @@ pub mod ffishim {
let mut channel_token: bidirectional::ChannelToken<Bls12> = deserialize_object(ser_channel_token);
// Deserialize the cust wallet
let mut cust_wallet: bidirectional::CustomerWallet<Bls12> = deserialize_object(ser_customer_wallet);
let mut cust_state: bidirectional::CustomerState<Bls12> = deserialize_object(ser_customer_wallet);
let (com, com_proof) = bidirectional::establish_customer_generate_proof(rng, &mut channel_token, &mut cust_wallet);
let (com, com_proof) = bidirectional::establish_customer_generate_proof(rng, &mut channel_token, &mut cust_state);
let ser = ["{\'cust_wallet\':\'", serde_json::to_string(&cust_wallet).unwrap().as_str(),
let ser = ["{\'cust_state\':\'", serde_json::to_string(&cust_state).unwrap().as_str(),
"\', \'channel_token\':\'", serde_json::to_string(&channel_token).unwrap().as_str(),
"\', \'com\':\'", serde_json::to_string(&com).unwrap().as_str(),
"\', \'com_proof\':\'", serde_json::to_string(&com_proof).unwrap().as_str(),
@ -132,7 +132,7 @@ pub mod ffishim {
}
#[no_mangle]
pub extern fn ffishim_bidirectional_establish_merchant_issue_close_token(ser_channel_state: *mut c_char, ser_com: *mut c_char, ser_com_proof: *mut c_char, ser_merch_wallet: *mut c_char) -> *mut c_char {
pub extern fn ffishim_bidirectional_establish_merchant_issue_close_token(ser_channel_state: *mut c_char, ser_com: *mut c_char, ser_com_proof: *mut c_char, ser_merch_state: *mut c_char) -> *mut c_char {
let mut rng = &mut rand::thread_rng();
// Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
@ -144,9 +144,9 @@ pub mod ffishim {
let com_proof: bidirectional::CommitmentProof<Bls12> = deserialize_object(ser_com_proof);
// Deserialize the merchant wallet
let merch_wallet: bidirectional::MerchantWallet<Bls12> = deserialize_object(ser_merch_wallet);
let merch_state: bidirectional::MerchantState<Bls12> = deserialize_object(ser_merch_state);
let close_token = bolt_try!(bidirectional::establish_merchant_issue_close_token(rng, &channel_state, &com, &com_proof, &merch_wallet));
let close_token = bolt_try!(bidirectional::establish_merchant_issue_close_token(rng, &channel_state, &com, &com_proof, &merch_state));
let ser = ["{\'close_token\':\'", serde_json::to_string(&close_token).unwrap().as_str(), "\'}"].concat();
let cser = CString::new(ser).unwrap();
@ -154,7 +154,7 @@ pub mod ffishim {
}
#[no_mangle]
pub extern fn ffishim_bidirectional_establish_merchant_issue_pay_token(ser_channel_state: *mut c_char, ser_com: *mut c_char, ser_merch_wallet: *mut c_char) -> *mut c_char {
pub extern fn ffishim_bidirectional_establish_merchant_issue_pay_token(ser_channel_state: *mut c_char, ser_com: *mut c_char, ser_merch_state: *mut c_char) -> *mut c_char {
let mut rng = &mut rand::thread_rng();
// Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
@ -163,9 +163,9 @@ pub mod ffishim {
let com: bidirectional::Commitment<Bls12> = deserialize_object(ser_com);
// Deserialize the merchant wallet
let merch_wallet: bidirectional::MerchantWallet<Bls12> = deserialize_object(ser_merch_wallet);
let merch_state: bidirectional::MerchantState<Bls12> = deserialize_object(ser_merch_state);
let pay_token = bidirectional::establish_merchant_issue_pay_token(rng, &channel_state, &com, &merch_wallet);
let pay_token = bidirectional::establish_merchant_issue_pay_token(rng, &channel_state, &com, &merch_state);
let ser = ["{\'pay_token\':\'", serde_json::to_string(&pay_token).unwrap().as_str(), "\'}"].concat();
let cser = CString::new(ser).unwrap();
@ -178,14 +178,14 @@ pub mod ffishim {
let mut channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet
let mut cust_wallet: bidirectional::CustomerWallet<Bls12> = deserialize_object(ser_customer_wallet);
let mut cust_state: bidirectional::CustomerState<Bls12> = deserialize_object(ser_customer_wallet);
// Deserialize the close token
let close_token: bidirectional::Signature<Bls12> = deserialize_object(ser_close_token);
let is_close_token_valid = cust_wallet.verify_close_token(&mut channel_state, &close_token);
let is_close_token_valid = cust_state.verify_close_token(&mut channel_state, &close_token);
let ser = ["{\'cust_wallet\':\'", serde_json::to_string(&cust_wallet).unwrap().as_str(),
let ser = ["{\'cust_state\':\'", serde_json::to_string(&cust_state).unwrap().as_str(),
"\', \'is_token_valid\':\'", serde_json::to_string(&is_close_token_valid).unwrap().as_str(),
"\', \'channel_state\':\'", serde_json::to_string(&channel_state).unwrap().as_str() ,"\'}"].concat();
let cser = CString::new(ser).unwrap();
@ -199,14 +199,14 @@ pub mod ffishim {
let mut channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet
let mut cust_wallet: bidirectional::CustomerWallet<Bls12> = deserialize_object(ser_customer_wallet);
let mut cust_state: bidirectional::CustomerState<Bls12> = deserialize_object(ser_customer_wallet);
// Deserialize the custdata
let pay_token: bidirectional::Signature<Bls12> = deserialize_object(ser_pay_token);
let is_channel_established = bidirectional::establish_customer_final(&mut channel_state, &mut cust_wallet, &pay_token);
let is_channel_established = bidirectional::establish_customer_final(&mut channel_state, &mut cust_state, &pay_token);
let ser = ["{\'cust_wallet\':\'", serde_json::to_string(&cust_wallet).unwrap().as_str(),
let ser = ["{\'cust_state\':\'", serde_json::to_string(&cust_state).unwrap().as_str(),
"\', \'is_established\':\'", serde_json::to_string(&is_channel_established).unwrap().as_str(),
"\', \'channel_state\':\'", serde_json::to_string(&channel_state).unwrap().as_str() ,"\'}"].concat();
let cser = CString::new(ser).unwrap();
@ -224,11 +224,11 @@ pub mod ffishim {
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet
let cust_wallet: bidirectional::CustomerWallet<Bls12> = deserialize_object(ser_customer_wallet);
let cust_state: bidirectional::CustomerState<Bls12> = deserialize_object(ser_customer_wallet);
let (payment, new_cust_wallet) = bidirectional::generate_payment_proof(rng, &channel_state, &cust_wallet, amount);
let (payment, new_cust_state) = bidirectional::generate_payment_proof(rng, &channel_state, &cust_state, amount);
let ser = ["{\'payment\':\'", serde_json::to_string(&payment).unwrap().as_str(),
"\', \'cust_wallet\':\'", serde_json::to_string(&new_cust_wallet).unwrap().as_str() ,"\'}"].concat();
"\', \'cust_state\':\'", serde_json::to_string(&new_cust_state).unwrap().as_str() ,"\'}"].concat();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
@ -236,7 +236,7 @@ pub mod ffishim {
#[no_mangle]
pub extern fn ffishim_bidirectional_pay_verify_payment_proof(ser_channel_state: *mut c_char,
ser_pay_proof: *mut c_char,
ser_merch_wallet: *mut c_char) -> *mut c_char {
ser_merch_state: *mut c_char) -> *mut c_char {
let mut rng = &mut rand::thread_rng();
// Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
@ -245,64 +245,64 @@ pub mod ffishim {
let payment: bidirectional::Payment<Bls12> = deserialize_object(ser_pay_proof);
// Deserialize the merch wallet
let mut merch_wallet: bidirectional::MerchantWallet<Bls12> = deserialize_object(ser_merch_wallet);
let mut merch_state: bidirectional::MerchantState<Bls12> = deserialize_object(ser_merch_state);
let close_token = bidirectional::verify_payment_proof(rng, &channel_state, &payment, &mut merch_wallet);
let close_token = bidirectional::verify_payment_proof(rng, &channel_state, &payment, &mut merch_state);
let ser = ["{\'close_token\':\'", serde_json::to_string(&close_token).unwrap().as_str(),
"\', \'merch_wallet\':\'", serde_json::to_string(&merch_wallet).unwrap().as_str() ,"\'}"].concat();
"\', \'merch_state\':\'", serde_json::to_string(&merch_state).unwrap().as_str() ,"\'}"].concat();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_pay_generate_revoke_token(ser_channel_state: *mut c_char,
ser_cust_wallet: *mut c_char,
ser_new_cust_wallet: *mut c_char,
ser_cust_state: *mut c_char,
ser_new_cust_state: *mut c_char,
ser_close_token: *mut c_char) -> *mut c_char {
// Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet
let mut cust_wallet: bidirectional::CustomerWallet<Bls12> = deserialize_object(ser_cust_wallet);
let mut cust_state: bidirectional::CustomerState<Bls12> = deserialize_object(ser_cust_state);
// Deserialize the cust wallet
let new_cust_wallet: bidirectional::CustomerWallet<Bls12> = deserialize_object(ser_new_cust_wallet);
let new_cust_state: bidirectional::CustomerState<Bls12> = deserialize_object(ser_new_cust_state);
// Deserialize the close token
let close_token: bidirectional::Signature<Bls12> = deserialize_object(ser_close_token);
let revoke_token = bidirectional::generate_revoke_token(&channel_state, &mut cust_wallet, new_cust_wallet, &close_token);
let revoke_token = bidirectional::generate_revoke_token(&channel_state, &mut cust_state, new_cust_state, &close_token);
let ser = ["{\'revoke_token\':\'", serde_json::to_string(&revoke_token).unwrap().as_str(),
"\', \'cust_wallet\':\'", serde_json::to_string(&cust_wallet).unwrap().as_str() ,"\'}"].concat();
"\', \'cust_state\':\'", serde_json::to_string(&cust_state).unwrap().as_str() ,"\'}"].concat();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_pay_verify_revoke_token(ser_revoke_token: *mut c_char,
ser_merch_wallet: *mut c_char) -> *mut c_char {
ser_merch_state: *mut c_char) -> *mut c_char {
// Deserialize the revoke token
let revoke_token: bidirectional::RevokeToken = deserialize_object(ser_revoke_token);
// Deserialize the cust wallet
let mut merch_wallet: bidirectional::MerchantWallet<Bls12> = deserialize_object(ser_merch_wallet);
let mut merch_state: bidirectional::MerchantState<Bls12> = deserialize_object(ser_merch_state);
// send revoke token and get pay-token in response
let pay_token = bidirectional::verify_revoke_token(&revoke_token, &mut merch_wallet);
let pay_token = bidirectional::verify_revoke_token(&revoke_token, &mut merch_state);
let ser = ["{\'pay_token\':\'", serde_json::to_string(&pay_token).unwrap().as_str(),
"\', \'merch_wallet\':\'", serde_json::to_string(&merch_wallet).unwrap().as_str() ,"\'}"].concat();
"\', \'merch_state\':\'", serde_json::to_string(&merch_state).unwrap().as_str() ,"\'}"].concat();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_pay_verify_payment_token(ser_channel_state: *mut c_char, ser_cust_wallet: *mut c_char, ser_pay_token: *mut c_char) -> *mut c_char {
pub extern fn ffishim_bidirectional_pay_verify_payment_token(ser_channel_state: *mut c_char, ser_cust_state: *mut c_char, ser_pay_token: *mut c_char) -> *mut c_char {
// Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet
let mut cust_wallet: bidirectional::CustomerWallet<Bls12> = deserialize_object(ser_cust_wallet);
let mut cust_state: bidirectional::CustomerState<Bls12> = deserialize_object(ser_cust_state);
// Deserialize the pay token
let pay_token: bidirectional::Signature<Bls12> = deserialize_object(ser_pay_token);
// verify the pay token and update internal state
let is_pay_valid = cust_wallet.verify_pay_token(&channel_state, &pay_token);
let ser = ["{\'cust_wallet\':\'", serde_json::to_string(&cust_wallet).unwrap().as_str(),
let is_pay_valid = cust_state.verify_pay_token(&channel_state, &pay_token);
let ser = ["{\'cust_state\':\'", serde_json::to_string(&cust_state).unwrap().as_str(),
"\', \'is_pay_valid\':\'", serde_json::to_string(&is_pay_valid).unwrap().as_str(), "\'}"].concat();
let cser = CString::new(ser).unwrap();
cser.into_raw()
@ -312,13 +312,13 @@ pub mod ffishim {
#[no_mangle]
pub extern fn ffishim_bidirectional_customer_close(ser_channel_state: *mut c_char,
ser_cust_wallet: *mut c_char) -> *mut c_char {
ser_cust_state: *mut c_char) -> *mut c_char {
// Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet
let cust_wallet: bidirectional::CustomerWallet<Bls12> = deserialize_object(ser_cust_wallet);
let cust_state: bidirectional::CustomerState<Bls12> = deserialize_object(ser_cust_state);
let cust_close = bidirectional::customer_close(&channel_state, &cust_wallet);
let cust_close = bidirectional::customer_close(&channel_state, &cust_state);
let ser = ["{\'cust_close\':\'", serde_json::to_string(&cust_close).unwrap().as_str(), "\'}"].concat();
let cser = CString::new(ser).unwrap();
cser.into_raw()

172
src/lib.rs
View File

@ -131,7 +131,7 @@ pub mod bidirectional {
pub use ped92::Commitment;
pub use cl::{PublicKey, Signature};
pub use BoltResult;
pub use channels::{ChannelState, ChannelToken, CustomerWallet, MerchantWallet, PubKeyMap, ChannelParams, BoltError, ResultBoltSig};
pub use channels::{ChannelState, ChannelToken, CustomerState, MerchantState, PubKeyMap, ChannelParams, BoltError, ResultBoltSig};
pub use nizk::Proof;
pub use util::CommitmentProof;
@ -183,14 +183,14 @@ pub mod bidirectional {
/// init_merchant - takes as input the public params, merchant balance and keypair.
/// Generates merchant data which consists of channel token and merchant wallet.
///
pub fn init_merchant<'a, R: Rng, E: Engine>(csprng: &mut R, channel_state: &mut ChannelState<E>, name: &'a str) -> (ChannelToken<E>, MerchantWallet<E>) {
pub fn init_merchant<'a, R: Rng, E: Engine>(csprng: &mut R, channel_state: &mut ChannelState<E>, name: &'a str) -> (ChannelToken<E>, MerchantState<E>) {
// create new merchant wallet
let merch_name = String::from(name);
let mut merch_wallet = MerchantWallet::<E>::new(csprng, channel_state, merch_name);
let mut merch_state = MerchantState::<E>::new(csprng, channel_state, merch_name);
// initialize the merchant wallet
let mut channel_token = merch_wallet.init(csprng, channel_state);
let mut channel_token = merch_state.init(csprng, channel_state);
return (channel_token, merch_wallet);
return (channel_token, merch_state);
}
///
@ -200,12 +200,12 @@ pub mod bidirectional {
///
pub fn init_customer<'a, R: Rng, E: Engine>(csprng: &mut R, channel_state: &ChannelState<E>,
channel_token: &mut ChannelToken<E>,
b0_cust: i32, b0_merch: i32, name: &'a str) -> CustomerWallet<E> {
b0_cust: i32, b0_merch: i32, name: &'a str) -> CustomerState<E> {
assert!(b0_cust >= 0);
assert!(b0_merch >= 0);
let cust_name = String::from(name);
return CustomerWallet::<E>::new(csprng, channel_state, channel_token, b0_cust, b0_merch, cust_name);
return CustomerState::<E>::new(csprng, channel_state, channel_token, b0_cust, b0_merch, cust_name);
}
///
@ -213,9 +213,9 @@ pub mod bidirectional {
/// common public bases from merchant. Generates a PoK of the committed values in the
/// new wallet.
///
pub fn establish_customer_generate_proof<R: Rng, E: Engine>(csprng: &mut R, channel_token: &ChannelToken<E>, cust_wallet: &CustomerWallet<E>) -> (Commitment<E>, CommitmentProof<E>) {
let cust_com_proof = cust_wallet.generate_proof(csprng, channel_token);
return (cust_wallet.w_com.clone(), cust_com_proof);
pub fn establish_customer_generate_proof<R: Rng, E: Engine>(csprng: &mut R, channel_token: &ChannelToken<E>, cust_state: &CustomerState<E>) -> (Commitment<E>, CommitmentProof<E>) {
let cust_com_proof = cust_state.generate_proof(csprng, channel_token);
return (cust_state.w_com.clone(), cust_com_proof);
}
///
@ -224,9 +224,9 @@ pub mod bidirectional {
/// signature) over the contents of the customer's wallet.
///
pub fn establish_merchant_issue_close_token<R: Rng, E: Engine>(csprng: &mut R, channel_state: &ChannelState<E>,
com: &Commitment<E>, com_proof: &CommitmentProof<E>, merch_wallet: &MerchantWallet<E>) -> BoltResult<cl::Signature<E>> {
com: &Commitment<E>, com_proof: &CommitmentProof<E>, merch_state: &MerchantState<E>) -> BoltResult<cl::Signature<E>> {
// verifies proof of committed values and derives blind signature on the committed values to the customer's initial wallet
match merch_wallet.verify_proof(csprng, channel_state, com, com_proof) {
match merch_state.verify_proof(csprng, channel_state, com, com_proof) {
Ok(n) => Ok(Some(n.0)), // just close token
Err(err) => Err(String::from(err.to_string()))
}
@ -238,9 +238,9 @@ pub mod bidirectional {
/// signature) over the contents of the customer's wallet.
///
pub fn establish_merchant_issue_pay_token<R: Rng, E: Engine>(csprng: &mut R, channel_state: &ChannelState<E>,
com: &Commitment<E>, merch_wallet: &MerchantWallet<E>) -> cl::Signature<E> {
com: &Commitment<E>, merch_state: &MerchantState<E>) -> cl::Signature<E> {
let cp = channel_state.cp.as_ref().unwrap();
let pay_token = merch_wallet.issue_pay_token(csprng, cp, com, false);
let pay_token = merch_state.issue_pay_token(csprng, cp, com, false);
return pay_token;
}
@ -249,15 +249,15 @@ pub mod bidirectional {
/// customer wallet and pay token (blinded sig) obtained from merchant. Add the returned
/// blinded signature to the wallet.
///
pub fn establish_customer_final<E: Engine>(channel_state: &mut ChannelState<E>, cust_wallet: &mut CustomerWallet<E>, pay_token: &cl::Signature<E>) -> bool {
pub fn establish_customer_final<E: Engine>(channel_state: &mut ChannelState<E>, cust_state: &mut CustomerState<E>, pay_token: &cl::Signature<E>) -> bool {
// verify the pay-token first
if !cust_wallet.verify_pay_token(&channel_state, pay_token) {
if !cust_state.verify_pay_token(&channel_state, pay_token) {
println!("establish_customer_final - Failed to verify the pay-token");
return false;
}
// only if both tokens have been stored
if (cust_wallet.has_tokens()) {
if (cust_state.has_tokens()) {
// must be an old wallet
channel_state.channel_established = true;
}
@ -272,10 +272,10 @@ pub mod bidirectional {
/// PoK of the committed values in new wallet and PoK of old wallet. Return new channel token,
/// new wallet (minus blind signature and refund token) and payment proof.
///
pub fn generate_payment_proof<R: Rng, E: Engine>(csprng: &mut R, channel_state: &ChannelState<E>, cust_wallet: &CustomerWallet<E>, amount: i32) -> (Payment<E>, CustomerWallet<E>) {
let (proof, com, wpk, new_cust_wallet) = cust_wallet.generate_payment(csprng, &channel_state, amount);
pub fn generate_payment_proof<R: Rng, E: Engine>(csprng: &mut R, channel_state: &ChannelState<E>, cust_state: &CustomerState<E>, amount: i32) -> (Payment<E>, CustomerState<E>) {
let (proof, com, wpk, new_cust_state) = cust_state.generate_payment(csprng, &channel_state, amount);
let payment = Payment { proof, com, wpk, amount };
return (payment, new_cust_wallet);
return (payment, new_cust_state);
}
///
@ -284,10 +284,10 @@ pub mod bidirectional {
/// (i.e., partially blind signature on IOU with updated balance)
///
pub fn verify_payment_proof<R: Rng, E: Engine>(csprng: &mut R, channel_state: &ChannelState<E>,
payment: &Payment<E>, merch_wallet: &mut MerchantWallet<E>) -> cl::Signature<E> {
payment: &Payment<E>, merch_state: &mut MerchantState<E>) -> cl::Signature<E> {
// if payment proof verifies, then returns close-token and records wpk => pay-token
// if valid revoke_token is provided later for wpk, then release pay-token
let new_close_token = merch_wallet.verify_payment(csprng, &channel_state,
let new_close_token = merch_state.verify_payment(csprng, &channel_state,
&payment.proof, &payment.com, &payment.wpk, payment.amount).unwrap();
return new_close_token;
}
@ -342,13 +342,13 @@ pub mod bidirectional {
/// a revocation token for the old wallet public key.
///
pub fn generate_revoke_token<E: Engine>(channel_state: &ChannelState<E>,
old_cust_wallet: &mut CustomerWallet<E>,
new_cust_wallet: CustomerWallet<E>,
old_cust_state: &mut CustomerState<E>,
new_cust_state: CustomerState<E>,
new_close_token: &cl::Signature<E>) -> RevokeToken {
// let's update the old wallet
assert!(old_cust_wallet.update(new_cust_wallet));
assert!(old_cust_state.update(new_cust_state));
// generate the token after verifying that the close token is valid
let (message, signature) = old_cust_wallet.generate_revoke_token(channel_state, new_close_token).unwrap();
let (message, signature) = old_cust_state.generate_revoke_token(channel_state, new_close_token).unwrap();
// return the revoke token (msg + sig pair)
return RevokeToken { message, signature };
@ -359,9 +359,9 @@ pub mod bidirectional {
/// merchant wallet, from the customer. If the revocation token is valid,
/// generate a new signature for the new wallet (from the PoK of committed values in new wallet).
///
pub fn verify_revoke_token<E: Engine>(rt: &RevokeToken, merch_wallet: &mut MerchantWallet<E>) -> cl::Signature<E> {
let new_pay_token = merch_wallet.verify_revoke_token(&rt.signature, &rt.message, &rt.message.wpk).unwrap();
update_merchant_state(&mut merch_wallet.keys, &rt.message.wpk, Some(rt.signature.clone()));
pub fn verify_revoke_token<E: Engine>(rt: &RevokeToken, merch_state: &mut MerchantState<E>) -> cl::Signature<E> {
let new_pay_token = merch_state.verify_revoke_token(&rt.signature, &rt.message, &rt.message.wpk).unwrap();
update_merchant_state(&mut merch_state.keys, &rt.message.wpk, Some(rt.signature.clone()));
return new_pay_token;
}
@ -372,13 +372,13 @@ pub mod bidirectional {
/// customer_close - takes as input the channel state, merchant's verification
/// key, and customer wallet. Generates a channel closure message for customer.
///
pub fn customer_close<E: Engine>(channel_state: &ChannelState<E>, cust_wallet: &CustomerWallet<E>) -> ChannelcloseC<E> {
pub fn customer_close<E: Engine>(channel_state: &ChannelState<E>, cust_state: &CustomerState<E>) -> ChannelcloseC<E> {
if !channel_state.channel_established {
panic!("Cannot close a channel that has not been established!");
}
let mut wallet= cust_wallet.get_wallet();
let close_token = cust_wallet.get_close_token();
let mut wallet= cust_state.get_wallet();
let close_token = cust_state.get_close_token();
let cp = channel_state.cp.as_ref().unwrap();
let pk = cp.pub_params.keypair.get_public_key(&cp.pub_params.mpk);
@ -472,7 +472,7 @@ mod tests {
fn setup_new_channel_helper(channel_state: &mut bidirectional::ChannelState<Bls12>,
init_cust_bal: i32, init_merch_bal: i32)
-> (bidirectional::ChannelToken<Bls12>, bidirectional::MerchantWallet<Bls12>, bidirectional::CustomerWallet<Bls12>) {
-> (bidirectional::ChannelToken<Bls12>, bidirectional::MerchantState<Bls12>, bidirectional::CustomerState<Bls12>) {
let mut rng = &mut rand::thread_rng();
let merch_name = "Bob";
@ -484,62 +484,62 @@ mod tests {
// each party executes the init algorithm on the agreed initial challenge balance
// in order to derive the channel tokens
// initialize on the merchant side with balance: b0_merch
let (mut channel_token, mut merch_wallet) = bidirectional::init_merchant(rng, channel_state, merch_name);
merch_wallet.init_balance(b0_merch);
let (mut channel_token, mut merch_state) = bidirectional::init_merchant(rng, channel_state, merch_name);
merch_state.init_balance(b0_merch);
// initialize on the customer side with balance: b0_cust
let cust_wallet = bidirectional::init_customer(rng, channel_state, &mut channel_token, b0_cust, b0_merch, cust_name);
let cust_state = bidirectional::init_customer(rng, channel_state, &mut channel_token, b0_cust, b0_merch, cust_name);
return (channel_token, merch_wallet, cust_wallet);
return (channel_token, merch_state, cust_state);
}
fn execute_establish_protocol_helper(channel_state: &mut bidirectional::ChannelState<Bls12>,
channel_token: &mut bidirectional::ChannelToken<Bls12>,
merch_wallet: &mut bidirectional::MerchantWallet<Bls12>,
cust_wallet: &mut bidirectional::CustomerWallet<Bls12>) {
merch_state: &mut bidirectional::MerchantState<Bls12>,
cust_state: &mut bidirectional::CustomerState<Bls12>) {
let mut rng = &mut rand::thread_rng();
// lets establish the channel
let (com, com_proof) = bidirectional::establish_customer_generate_proof(rng, channel_token, cust_wallet);
let (com, com_proof) = bidirectional::establish_customer_generate_proof(rng, channel_token, cust_state);
// obtain close token for closing out channel
let option = bidirectional::establish_merchant_issue_close_token(rng, &channel_state, &com, &com_proof, &merch_wallet);
let option = bidirectional::establish_merchant_issue_close_token(rng, &channel_state, &com, &com_proof, &merch_state);
let close_token= match option {
Ok(n) => n.unwrap(),
Err(e) => panic!("Failed - bidirectional::establish_merchant_issue_close_token(): {}", e)
};
assert!(cust_wallet.verify_close_token(&channel_state, &close_token));
assert!(cust_state.verify_close_token(&channel_state, &close_token));
// wait for funding tx to be confirmed, etc
// obtain payment token for pay protocol
let pay_token = bidirectional::establish_merchant_issue_pay_token(rng, &channel_state, &com, &merch_wallet);
//assert!(cust_wallet.verify_pay_token(&channel_state, &pay_token));
let pay_token = bidirectional::establish_merchant_issue_pay_token(rng, &channel_state, &com, &merch_state);
//assert!(cust_state.verify_pay_token(&channel_state, &pay_token));
assert!(bidirectional::establish_customer_final(channel_state, cust_wallet, &pay_token));
assert!(bidirectional::establish_customer_final(channel_state, cust_state, &pay_token));
println!("Channel established!");
}
fn execute_payment_protocol_helper(channel_state: &mut bidirectional::ChannelState<Bls12>,
channel_token: &mut bidirectional::ChannelToken<Bls12>,
merch_wallet: &mut bidirectional::MerchantWallet<Bls12>,
cust_wallet: &mut bidirectional::CustomerWallet<Bls12>,
merch_state: &mut bidirectional::MerchantState<Bls12>,
cust_state: &mut bidirectional::CustomerState<Bls12>,
payment_increment: i32) {
let mut rng = &mut rand::thread_rng();
let (payment, new_cust_wallet) = bidirectional::generate_payment_proof(rng, channel_state, &cust_wallet, payment_increment);
let (payment, new_cust_state) = bidirectional::generate_payment_proof(rng, channel_state, &cust_state, payment_increment);
let new_close_token = bidirectional::verify_payment_proof(rng, &channel_state, &payment, merch_wallet);
let new_close_token = bidirectional::verify_payment_proof(rng, &channel_state, &payment, merch_state);
let revoke_token = bidirectional::generate_revoke_token(&channel_state, cust_wallet, new_cust_wallet, &new_close_token);
let revoke_token = bidirectional::generate_revoke_token(&channel_state, cust_state, new_cust_state, &new_close_token);
// send revoke token and get pay-token in response
let new_pay_token = bidirectional::verify_revoke_token(&revoke_token, merch_wallet);
let new_pay_token = bidirectional::verify_revoke_token(&revoke_token, merch_state);
// verify the pay token and update internal state
assert!(cust_wallet.verify_pay_token(&channel_state, &new_pay_token));
assert!(cust_state.verify_pay_token(&channel_state, &new_pay_token));
}
#[test]
@ -555,49 +555,49 @@ mod tests {
let b0_merchant = 20;
let payment_increment = 20;
let (mut channel_token, mut merch_wallet) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant Bob");
// initialize the balance for merch_wallet
merch_wallet.init_balance(b0_merchant);
let (mut channel_token, mut merch_state) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant Bob");
// initialize the balance for merch_state
merch_state.init_balance(b0_merchant);
let mut cust_wallet = bidirectional::init_customer(rng, &mut channel_state, &mut channel_token, b0_customer, b0_merchant, "Alice");
let mut cust_state = bidirectional::init_customer(rng, &mut channel_state, &mut channel_token, b0_customer, b0_merchant, "Alice");
println!("{}", cust_wallet);
println!("{}", cust_state);
// lets establish the channel
let (com, com_proof) = bidirectional::establish_customer_generate_proof(rng, &mut channel_token, &mut cust_wallet);
let (com, com_proof) = bidirectional::establish_customer_generate_proof(rng, &mut channel_token, &mut cust_state);
// obtain close token for closing out channel
let option = bidirectional::establish_merchant_issue_close_token(rng, &channel_state, &com, &com_proof, &merch_wallet);
let option = bidirectional::establish_merchant_issue_close_token(rng, &channel_state, &com, &com_proof, &merch_state);
let close_token= match option {
Ok(n) => n.unwrap(),
Err(e) => panic!("Failed - bidirectional::establish_merchant_issue_close_token(): {}", e)
};
assert!(cust_wallet.verify_close_token(&channel_state, &close_token));
assert!(cust_state.verify_close_token(&channel_state, &close_token));
// wait for funding tx to be confirmed, etc
// obtain payment token for pay protocol
let pay_token = bidirectional::establish_merchant_issue_pay_token(rng, &channel_state, &com, &merch_wallet);
//assert!(cust_wallet.verify_pay_token(&channel_state, &pay_token));
let pay_token = bidirectional::establish_merchant_issue_pay_token(rng, &channel_state, &com, &merch_state);
//assert!(cust_state.verify_pay_token(&channel_state, &pay_token));
assert!(bidirectional::establish_customer_final(&mut channel_state, &mut cust_wallet, &pay_token));
assert!(bidirectional::establish_customer_final(&mut channel_state, &mut cust_state, &pay_token));
println!("Channel established!");
let (payment, new_cust_wallet) = bidirectional::generate_payment_proof(rng, &channel_state, &cust_wallet, 10);
let (payment, new_cust_state) = bidirectional::generate_payment_proof(rng, &channel_state, &cust_state, 10);
let new_close_token = bidirectional::verify_payment_proof(rng, &channel_state, &payment, &mut merch_wallet);
let new_close_token = bidirectional::verify_payment_proof(rng, &channel_state, &payment, &mut merch_state);
let revoke_token = bidirectional::generate_revoke_token(&channel_state, &mut cust_wallet, new_cust_wallet, &new_close_token);
let revoke_token = bidirectional::generate_revoke_token(&channel_state, &mut cust_state, new_cust_state, &new_close_token);
// send revoke token and get pay-token in response
let new_pay_token = bidirectional::verify_revoke_token(&revoke_token, &mut merch_wallet);
let new_pay_token = bidirectional::verify_revoke_token(&revoke_token, &mut merch_state);
// verify the pay token and update internal state
assert!(cust_wallet.verify_pay_token(&channel_state, &new_pay_token));
assert!(cust_state.verify_pay_token(&channel_state, &new_pay_token));
println!("Successful payment!");
let cust_close = bidirectional::customer_close(&channel_state, &cust_wallet);
let cust_close = bidirectional::customer_close(&channel_state, &cust_state);
println!("Obtained the channel close message");
println!("{}", cust_close.message);
println!("{}", cust_close.signature);
@ -616,10 +616,10 @@ mod tests {
channel_state.setup(&mut rng); // or load_setup params
let (mut channel_token, mut merch_wallet, mut cust_wallet) = setup_new_channel_helper( &mut channel_state, b0_customer, b0_merchant);
let (mut channel_token, mut merch_state, mut cust_state) = setup_new_channel_helper( &mut channel_state, b0_customer, b0_merchant);
// run establish protocol for customer and merchant channel
execute_establish_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_wallet, &mut cust_wallet);
execute_establish_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state);
assert!(channel_state.channel_established);
@ -627,17 +627,17 @@ mod tests {
// make multiple payments in a loop
let num_payments = total_owed / payment_increment;
for i in 0 .. num_payments {
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_wallet, &mut cust_wallet, payment_increment);
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, payment_increment);
}
{
// scope localizes the immutable borrow here (for debug purposes only)
println!("Customer balance: {:?}", &cust_wallet.cust_balance);
println!("Merchant balance: {:?}", &cust_wallet.merch_balance);
assert!(cust_wallet.cust_balance == (b0_customer - total_owed) && cust_wallet.merch_balance == total_owed + b0_merchant);
println!("Customer balance: {:?}", &cust_state.cust_balance);
println!("Merchant balance: {:?}", &cust_state.merch_balance);
assert!(cust_state.cust_balance == (b0_customer - total_owed) && cust_state.merch_balance == total_owed + b0_merchant);
}
let cust_close = bidirectional::customer_close(&channel_state, &cust_wallet);
let cust_close = bidirectional::customer_close(&channel_state, &cust_state);
println!("Obtained the channel close message");
println!("{}", cust_close.message);
println!("{}", cust_close.signature);
@ -658,21 +658,21 @@ mod tests {
channel_state.setup(&mut rng); // or load_setup params
let (mut channel_token, mut merch_wallet, mut cust_wallet) = setup_new_channel_helper( &mut channel_state, b0_customer, b0_merchant);
let (mut channel_token, mut merch_state, mut cust_state) = setup_new_channel_helper( &mut channel_state, b0_customer, b0_merchant);
// run establish protocol for customer and merchant channel
execute_establish_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_wallet, &mut cust_wallet);
execute_establish_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state);
assert!(channel_state.channel_established);
{
// make multiple payments in a loop
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_wallet, &mut cust_wallet, payment_increment);
execute_payment_protocol_helper(&mut channel_state, &mut channel_token, &mut merch_state, &mut cust_state, payment_increment);
{
// scope localizes the immutable borrow here (for debug purposes only)
println!("Customer balance: {:?}", &cust_wallet.cust_balance);
println!("Merchant balance: {:?}", &cust_wallet.merch_balance);
assert!(cust_wallet.cust_balance == (b0_customer - total_owed) && cust_wallet.merch_balance == total_owed + b0_merchant);
println!("Customer balance: {:?}", &cust_state.cust_balance);
println!("Merchant balance: {:?}", &cust_state.merch_balance);
assert!(cust_state.cust_balance == (b0_customer - total_owed) && cust_state.merch_balance == total_owed + b0_merchant);
}
}
}
@ -782,11 +782,11 @@ mod tests {
let chan_state: bidirectional::ChannelState<Bls12> = serde_json::from_str(&serialized).unwrap();
let (mut channel_token, mut merch_wallet) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant A");
let (mut channel_token, mut merch_state) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant A");
let b0_cust = 100;
let b0_merch = 10;
let cust_wallet = bidirectional::init_customer(rng, &channel_state, &mut channel_token, b0_cust, b0_merch, "Customer A");
let cust_state = bidirectional::init_customer(rng, &channel_state, &mut channel_token, b0_cust, b0_merch, "Customer A");
let serlalized_ct = serde_json::to_string(&channel_token).unwrap();
@ -796,11 +796,11 @@ mod tests {
//println!("des_ct: {}", &des_ct);
let serlalized_cw = serde_json::to_string(&cust_wallet).unwrap();
let serlalized_cw = serde_json::to_string(&cust_state).unwrap();
println!("serialized cw: {:?}", &serlalized_cw);
let des_cw: bidirectional::CustomerWallet<Bls12> = serde_json::from_str(&serlalized_cw).unwrap();
let des_cw: bidirectional::CustomerState<Bls12> = serde_json::from_str(&serlalized_cw).unwrap();
}
}

2
src/nizk.rs
View File

@ -107,8 +107,6 @@ impl<E: Engine> NIZKPublicParams<E> {
z0.add_assign(&t[0]);
z.push(z0);
let newWalletVec = newWallet.as_fr_vec();
// println!("z.len = {}, wallet len = {}", t.len(), newWalletVec.len());
// println!("max => {}", max);
for i in 1..t.len() {
let mut zi = newWalletVec[i - 1].clone();
zi.mul_assign(&challenge);

12
src/util.rs
View File

@ -116,7 +116,7 @@ pub struct CommitmentProof<E: Engine> {
}
impl<E: Engine> CommitmentProof<E> {
pub fn new<R: Rng>(csprng: &mut R, com_params: &CSMultiParams<E>, com: &E::G1, wallet: &Vec<E::Fr>, r: &E::Fr) -> Self {
pub fn new<R: Rng>(csprng: &mut R, com_params: &CSMultiParams<E>, com: &E::G1, wallet: &Vec<E::Fr>, r: &E::Fr, reveal_index: &Vec<usize>) -> Self {
let mut Tvals = E::G1::zero();
assert!(wallet.len() <= com_params.pub_bases.len());
@ -138,14 +138,24 @@ impl<E: Engine> CommitmentProof<E> {
let mut z0 = r.clone();
z0.mul_assign(&challenge);
z0.add_assign(&t[0]);
// check if we are revealing this index
if (reveal_index.contains(&0)) {
z.push(E::Fr::zero());
} else {
z.push(z0);
}
for i in 1..t.len() {
let mut zi = wallet[i-1].clone();
zi.mul_assign(&challenge);
zi.add_assign(&t[i]);
if (reveal_index.contains(&i)) {
z.push(E::Fr::zero());
} else {
z.push(zi);
}
}
CommitmentProof {
T: Tvals, z: z