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] [package]
name = "bolt" name = "bolt"
version = "0.3.0" 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)" description = "library for Blind Off-chain Lightweight Transactions (BOLT)"
keywords = ["zcash", "payment channels", "bolt"] keywords = ["zcash", "payment channels", "bolt"]
readme = "README.md" 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>::G1: serde::Deserialize<'de>, \
<E as pairing::Engine>::G2: 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 name: String,
pub pk_c: secp256k1::PublicKey, pub pk_c: secp256k1::PublicKey,
sk_c: secp256k1::SecretKey, sk_c: secp256k1::SecretKey,
@ -212,7 +212,7 @@ pub struct CustomerWallet<E: Engine> {
pay_tokens: HashMap<i32, Signature<E>> 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 { 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(); let mut kp = secp256k1::Secp256k1::new();
kp.randomize(csprng); kp.randomize(csprng);
@ -244,7 +244,7 @@ impl<E: Engine> CustomerWallet<E> {
let mut pt_db= HashMap::new(); let mut pt_db= HashMap::new();
println!("Customer wallet formed -> now returning the structure to the caller."); println!("Customer wallet formed -> now returning the structure to the caller.");
return CustomerWallet { return CustomerState {
name: name, name: name,
pk_c: pk_c, pk_c: pk_c,
sk_c: sk_c, sk_c: sk_c,
@ -275,7 +275,7 @@ impl<E: Engine> CustomerWallet<E> {
// generate nizk proof of knowledge of commitment opening // generate nizk proof of knowledge of commitment opening
pub fn generate_proof<R: Rng>(&self, csprng: &mut R, channel_token: &ChannelToken<E>) -> CommitmentProof<E> { 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 { 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 // 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 // 1 - chooose new wpk/wsk pair
let mut kp = secp256k1::Secp256k1::new(); let mut kp = secp256k1::Secp256k1::new();
kp.randomize(csprng); kp.randomize(csprng);
@ -362,7 +362,7 @@ impl<E: Engine> CustomerWallet<E> {
new_wcom.clone(), new_t, &prev_pay_token); new_wcom.clone(), new_t, &prev_pay_token);
// update internal state after proof has been verified by remote // update internal state after proof has been verified by remote
let new_cw = CustomerWallet { let new_cw = CustomerState {
name: self.name.clone(), name: self.name.clone(),
pk_c: self.pk_c.clone(), pk_c: self.pk_c.clone(),
sk_c: self.sk_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 // 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 // update everything except for the wpk/wsk pair
assert!(self.name == new_wallet.name); assert!(self.name == new_wallet.name);
self.cust_balance = new_wallet.cust_balance; 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 { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut content = String::new(); let mut content = String::new();
content = format!("pk = {}\n", &self.pk_c); content = format!("pk = {}\n", &self.pk_c);
content = format!("{}sk = {}\n", content, &self.sk_c); content = format!("{}sk = {}\n", content, &self.sk_c);
content = format!("{}cust-bal = {}\n", content, &self.cust_balance); content = format!("{}cust-bal = {}\n", content, &self.cust_balance);
content = format!("{}merch-bal = {}\n", content, &self.merch_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>::G1: serde::Deserialize<'de>, \
<E as pairing::Engine>::G2: 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>, keypair: cl::BlindKeyPair<E>,
pub balance: i32, pub balance: i32,
pk: secp256k1::PublicKey, // pk_m pk: secp256k1::PublicKey, // pk_m
@ -453,7 +453,7 @@ pub struct MerchantWallet<E: Engine> {
pub pay_tokens: HashMap<String, cl::Signature<E>> 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 { pub fn new<R: Rng>(csprng: &mut R, channel: &mut ChannelState<E>, id: String) -> Self {
// generate keys here // generate keys here
let mut tx_kp = secp256k1::Secp256k1::new(); 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 (wsk, wpk) = tx_kp.generate_keypair(csprng);
let cp = channel.cp.as_ref().unwrap(); // if not set, then panic! let cp = channel.cp.as_ref().unwrap(); // if not set, then panic!
MerchantWallet { MerchantState {
keypair: cp.pub_params.keypair.clone(), keypair: cp.pub_params.keypair.clone(),
balance: 0, balance: 0,
pk: wpk, pk: wpk,
@ -582,57 +582,57 @@ mod tests {
// each party executes the init algorithm on the agreed initial challenge balance // each party executes the init algorithm on the agreed initial challenge balance
// in order to derive the channel tokens // in order to derive the channel tokens
// initialize on the merchant side with balance: b0_merch // 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 // 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) // retrieve commitment setup params (using merchant long lived pk params)
// initialize on the customer side with balance: b0_cust // 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 // 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 // first return the close token, then wait for escrow-tx confirmation
// then send the pay-token after 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 // 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!"); println!("Done!");
// pay protocol tests // pay protocol tests
let amount = 10; 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!("{}", new_com);
// println!("wpk => {}", old_wpk); // println!("wpk => {}", old_wpk);
// println!("{}", new_cw); // println!("{}", new_cw);
// new pay_token is not sent until revoke_token is obtained from the customer // 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); //println!("1 - Updated close Token : {}", new_close_token);
// unblind tokens and verify signatures // unblind tokens and verify signatures
// assuming the pay_proof checks out, can go ahead and update internal state of cust_wallet // assuming the pay_proof checks out, can go ahead and update internal state of cust_state
assert!(cust_wallet.update(new_cw)); assert!(cust_state.update(new_cw));
//println!("2 - updated customer wallet!"); //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!"); //println!("3 - verified the close token!");
// invalidate the previous state only if close token checks out // 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!("4 - Generated revoke token successfully.");
//println!("5 - Revoke token => {}", revoke_token); //println!("5 - Revoke token => {}", revoke_token);
let new_pay_token = merch_wallet.verify_revoke_token(&revoke_sig, &revoke_msg, &old_wpk).unwrap(); let new_pay_token = merch_state.verify_revoke_token(&revoke_sig, &revoke_msg, &old_wpk).unwrap();
assert!(cust_wallet.verify_pay_token(&channel, &new_pay_token)); assert!(cust_state.verify_pay_token(&channel, &new_pay_token));
//println!("Validated revoke 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 mut t = tOptional.unwrap_or(Vec::<E::Fr>::with_capacity(self.public.Y2.len()));
let tt = ttOptional.unwrap_or(E::Fr::rand(rng)); let tt = ttOptional.unwrap_or(E::Fr::rand(rng));
let mut a = E::Fqk::one(); let mut a = E::Fqk::one();
// TODO: consider optimizations to pairing in loop
for j in 0..self.public.Y2.len() { for j in 0..self.public.Y2.len() {
if t.len() == j { if t.len() == j {
t.push(E::Fr::rand(rng)); 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 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 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); let (channel_token, mut merch_state) = bidirectional::init_merchant(rng, &mut channel_state, name);
// initialize the balance for merch_wallet // initialize the balance for merch_state
merch_wallet.init_balance(balance); 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(); let cser = CString::new(ser).unwrap();
cser.into_raw() 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 let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8
// We change the channel state // We change the channel state
let cust_wallet = bidirectional::init_customer(rng, &channel_state, &mut channel_token, balance_customer, balance_merchant, name); let cust_state = 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 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(); let cser = CString::new(ser).unwrap();
cser.into_raw() cser.into_raw()
} }
// ESTABLISH // 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, pub extern fn ffishim_bidirectional_establish_customer_generate_proof(ser_channel_token: *mut c_char,
ser_customer_wallet: *mut c_char) -> *mut c_char { ser_customer_wallet: *mut c_char) -> *mut c_char {
let mut rng = &mut rand::thread_rng(); 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); let mut channel_token: bidirectional::ChannelToken<Bls12> = deserialize_object(ser_channel_token);
// Deserialize the cust wallet // 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(), "\', \'channel_token\':\'", serde_json::to_string(&channel_token).unwrap().as_str(),
"\', \'com\':\'", serde_json::to_string(&com).unwrap().as_str(), "\', \'com\':\'", serde_json::to_string(&com).unwrap().as_str(),
"\', \'com_proof\':\'", serde_json::to_string(&com_proof).unwrap().as_str(), "\', \'com_proof\':\'", serde_json::to_string(&com_proof).unwrap().as_str(),
@ -132,7 +132,7 @@ pub mod ffishim {
} }
#[no_mangle] #[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(); let mut rng = &mut rand::thread_rng();
// Deserialize the channel state // Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_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); let com_proof: bidirectional::CommitmentProof<Bls12> = deserialize_object(ser_com_proof);
// Deserialize the merchant wallet // 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 ser = ["{\'close_token\':\'", serde_json::to_string(&close_token).unwrap().as_str(), "\'}"].concat();
let cser = CString::new(ser).unwrap(); let cser = CString::new(ser).unwrap();
@ -154,7 +154,7 @@ pub mod ffishim {
} }
#[no_mangle] #[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(); let mut rng = &mut rand::thread_rng();
// Deserialize the channel state // Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_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); let com: bidirectional::Commitment<Bls12> = deserialize_object(ser_com);
// Deserialize the merchant wallet // 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 ser = ["{\'pay_token\':\'", serde_json::to_string(&pay_token).unwrap().as_str(), "\'}"].concat();
let cser = CString::new(ser).unwrap(); 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); let mut channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet // 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 // Deserialize the close token
let close_token: bidirectional::Signature<Bls12> = deserialize_object(ser_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(), "\', \'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(); "\', \'channel_state\':\'", serde_json::to_string(&channel_state).unwrap().as_str() ,"\'}"].concat();
let cser = CString::new(ser).unwrap(); 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); let mut channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet // 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 // Deserialize the custdata
let pay_token: bidirectional::Signature<Bls12> = deserialize_object(ser_pay_token); 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(), "\', \'is_established\':\'", serde_json::to_string(&is_channel_established).unwrap().as_str(),
"\', \'channel_state\':\'", serde_json::to_string(&channel_state).unwrap().as_str() ,"\'}"].concat(); "\', \'channel_state\':\'", serde_json::to_string(&channel_state).unwrap().as_str() ,"\'}"].concat();
let cser = CString::new(ser).unwrap(); let cser = CString::new(ser).unwrap();
@ -224,11 +224,11 @@ pub mod ffishim {
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state); let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet // 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(), 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(); let cser = CString::new(ser).unwrap();
cser.into_raw() cser.into_raw()
} }
@ -236,7 +236,7 @@ pub mod ffishim {
#[no_mangle] #[no_mangle]
pub extern fn ffishim_bidirectional_pay_verify_payment_proof(ser_channel_state: *mut c_char, pub extern fn ffishim_bidirectional_pay_verify_payment_proof(ser_channel_state: *mut c_char,
ser_pay_proof: *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(); let mut rng = &mut rand::thread_rng();
// Deserialize the channel state // Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_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); let payment: bidirectional::Payment<Bls12> = deserialize_object(ser_pay_proof);
// Deserialize the merch wallet // 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(), 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(); let cser = CString::new(ser).unwrap();
cser.into_raw() cser.into_raw()
} }
#[no_mangle] #[no_mangle]
pub extern fn ffishim_bidirectional_pay_generate_revoke_token(ser_channel_state: *mut c_char, pub extern fn ffishim_bidirectional_pay_generate_revoke_token(ser_channel_state: *mut c_char,
ser_cust_wallet: *mut c_char, ser_cust_state: *mut c_char,
ser_new_cust_wallet: *mut c_char, ser_new_cust_state: *mut c_char,
ser_close_token: *mut c_char) -> *mut c_char { ser_close_token: *mut c_char) -> *mut c_char {
// Deserialize the channel state // Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state); let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet // 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 // 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 // Deserialize the close token
let close_token: bidirectional::Signature<Bls12> = deserialize_object(ser_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(), 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(); let cser = CString::new(ser).unwrap();
cser.into_raw() cser.into_raw()
} }
#[no_mangle] #[no_mangle]
pub extern fn ffishim_bidirectional_pay_verify_revoke_token(ser_revoke_token: *mut c_char, 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 // Deserialize the revoke token
let revoke_token: bidirectional::RevokeToken = deserialize_object(ser_revoke_token); let revoke_token: bidirectional::RevokeToken = deserialize_object(ser_revoke_token);
// Deserialize the cust wallet // 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 // 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(), 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(); let cser = CString::new(ser).unwrap();
cser.into_raw() cser.into_raw()
} }
#[no_mangle] #[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 // Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state); let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet // 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 // Deserialize the pay token
let pay_token: bidirectional::Signature<Bls12> = deserialize_object(ser_pay_token); let pay_token: bidirectional::Signature<Bls12> = deserialize_object(ser_pay_token);
// verify the pay token and update internal state // verify the pay token and update internal state
let is_pay_valid = cust_wallet.verify_pay_token(&channel_state, &pay_token); let is_pay_valid = cust_state.verify_pay_token(&channel_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_pay_valid\':\'", serde_json::to_string(&is_pay_valid).unwrap().as_str(), "\'}"].concat(); "\', \'is_pay_valid\':\'", serde_json::to_string(&is_pay_valid).unwrap().as_str(), "\'}"].concat();
let cser = CString::new(ser).unwrap(); let cser = CString::new(ser).unwrap();
cser.into_raw() cser.into_raw()
@ -312,13 +312,13 @@ pub mod ffishim {
#[no_mangle] #[no_mangle]
pub extern fn ffishim_bidirectional_customer_close(ser_channel_state: *mut c_char, 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 // Deserialize the channel state
let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state); let channel_state: bidirectional::ChannelState<Bls12> = deserialize_object(ser_channel_state);
// Deserialize the cust wallet // 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 ser = ["{\'cust_close\':\'", serde_json::to_string(&cust_close).unwrap().as_str(), "\'}"].concat();
let cser = CString::new(ser).unwrap(); let cser = CString::new(ser).unwrap();
cser.into_raw() cser.into_raw()

172
src/lib.rs
View File

@ -131,7 +131,7 @@ pub mod bidirectional {
pub use ped92::Commitment; pub use ped92::Commitment;
pub use cl::{PublicKey, Signature}; pub use cl::{PublicKey, Signature};
pub use BoltResult; 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 nizk::Proof;
pub use util::CommitmentProof; pub use util::CommitmentProof;
@ -183,14 +183,14 @@ pub mod bidirectional {
/// init_merchant - takes as input the public params, merchant balance and keypair. /// init_merchant - takes as input the public params, merchant balance and keypair.
/// Generates merchant data which consists of channel token and merchant wallet. /// 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 // create new merchant wallet
let merch_name = String::from(name); 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 // 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>, pub fn init_customer<'a, R: Rng, E: Engine>(csprng: &mut R, channel_state: &ChannelState<E>,
channel_token: &mut ChannelToken<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_cust >= 0);
assert!(b0_merch >= 0); assert!(b0_merch >= 0);
let cust_name = String::from(name); 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 /// common public bases from merchant. Generates a PoK of the committed values in the
/// new wallet. /// 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>) { 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_wallet.generate_proof(csprng, channel_token); let cust_com_proof = cust_state.generate_proof(csprng, channel_token);
return (cust_wallet.w_com.clone(), cust_com_proof); 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. /// 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>, 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 // 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 Ok(n) => Ok(Some(n.0)), // just close token
Err(err) => Err(String::from(err.to_string())) Err(err) => Err(String::from(err.to_string()))
} }
@ -238,9 +238,9 @@ pub mod bidirectional {
/// signature) over the contents of the customer's wallet. /// 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>, 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 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; return pay_token;
} }
@ -249,15 +249,15 @@ pub mod bidirectional {
/// customer wallet and pay token (blinded sig) obtained from merchant. Add the returned /// customer wallet and pay token (blinded sig) obtained from merchant. Add the returned
/// blinded signature to the wallet. /// 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 // 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"); println!("establish_customer_final - Failed to verify the pay-token");
return false; return false;
} }
// only if both tokens have been stored // only if both tokens have been stored
if (cust_wallet.has_tokens()) { if (cust_state.has_tokens()) {
// must be an old wallet // must be an old wallet
channel_state.channel_established = true; 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, /// 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. /// 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>) { 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_wallet) = cust_wallet.generate_payment(csprng, &channel_state, amount); let (proof, com, wpk, new_cust_state) = cust_state.generate_payment(csprng, &channel_state, amount);
let payment = Payment { proof, com, wpk, 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) /// (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>, 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 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 // 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(); &payment.proof, &payment.com, &payment.wpk, payment.amount).unwrap();
return new_close_token; return new_close_token;
} }
@ -342,13 +342,13 @@ pub mod bidirectional {
/// a revocation token for the old wallet public key. /// a revocation token for the old wallet public key.
/// ///
pub fn generate_revoke_token<E: Engine>(channel_state: &ChannelState<E>, pub fn generate_revoke_token<E: Engine>(channel_state: &ChannelState<E>,
old_cust_wallet: &mut CustomerWallet<E>, old_cust_state: &mut CustomerState<E>,
new_cust_wallet: CustomerWallet<E>, new_cust_state: CustomerState<E>,
new_close_token: &cl::Signature<E>) -> RevokeToken { new_close_token: &cl::Signature<E>) -> RevokeToken {
// let's update the old wallet // 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 // 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 the revoke token (msg + sig pair)
return RevokeToken { message, signature }; return RevokeToken { message, signature };
@ -359,9 +359,9 @@ pub mod bidirectional {
/// merchant wallet, from the customer. If the revocation token is valid, /// 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). /// 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> { pub fn verify_revoke_token<E: Engine>(rt: &RevokeToken, merch_state: &mut MerchantState<E>) -> cl::Signature<E> {
let new_pay_token = merch_wallet.verify_revoke_token(&rt.signature, &rt.message, &rt.message.wpk).unwrap(); let new_pay_token = merch_state.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())); update_merchant_state(&mut merch_state.keys, &rt.message.wpk, Some(rt.signature.clone()));
return new_pay_token; return new_pay_token;
} }
@ -372,13 +372,13 @@ pub mod bidirectional {
/// customer_close - takes as input the channel state, merchant's verification /// customer_close - takes as input the channel state, merchant's verification
/// key, and customer wallet. Generates a channel closure message for customer. /// 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 { if !channel_state.channel_established {
panic!("Cannot close a channel that has not been established!"); panic!("Cannot close a channel that has not been established!");
} }
let mut wallet= cust_wallet.get_wallet(); let mut wallet= cust_state.get_wallet();
let close_token = cust_wallet.get_close_token(); let close_token = cust_state.get_close_token();
let cp = channel_state.cp.as_ref().unwrap(); let cp = channel_state.cp.as_ref().unwrap();
let pk = cp.pub_params.keypair.get_public_key(&cp.pub_params.mpk); 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>, fn setup_new_channel_helper(channel_state: &mut bidirectional::ChannelState<Bls12>,
init_cust_bal: i32, init_merch_bal: i32) 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 mut rng = &mut rand::thread_rng();
let merch_name = "Bob"; let merch_name = "Bob";
@ -484,62 +484,62 @@ mod tests {
// each party executes the init algorithm on the agreed initial challenge balance // each party executes the init algorithm on the agreed initial challenge balance
// in order to derive the channel tokens // in order to derive the channel tokens
// initialize on the merchant side with balance: b0_merch // initialize on the merchant side with balance: b0_merch
let (mut channel_token, mut merch_wallet) = bidirectional::init_merchant(rng, channel_state, merch_name); let (mut channel_token, mut merch_state) = bidirectional::init_merchant(rng, channel_state, merch_name);
merch_wallet.init_balance(b0_merch); merch_state.init_balance(b0_merch);
// initialize on the customer side with balance: b0_cust // 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>, fn execute_establish_protocol_helper(channel_state: &mut bidirectional::ChannelState<Bls12>,
channel_token: &mut bidirectional::ChannelToken<Bls12>, channel_token: &mut bidirectional::ChannelToken<Bls12>,
merch_wallet: &mut bidirectional::MerchantWallet<Bls12>, merch_state: &mut bidirectional::MerchantState<Bls12>,
cust_wallet: &mut bidirectional::CustomerWallet<Bls12>) { cust_state: &mut bidirectional::CustomerState<Bls12>) {
let mut rng = &mut rand::thread_rng(); let mut rng = &mut rand::thread_rng();
// lets establish the channel // 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 // 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 { let close_token= match option {
Ok(n) => n.unwrap(), Ok(n) => n.unwrap(),
Err(e) => panic!("Failed - bidirectional::establish_merchant_issue_close_token(): {}", e) 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 // wait for funding tx to be confirmed, etc
// obtain payment token for pay protocol // obtain payment token for pay protocol
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);
//assert!(cust_wallet.verify_pay_token(&channel_state, &pay_token)); //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!"); println!("Channel established!");
} }
fn execute_payment_protocol_helper(channel_state: &mut bidirectional::ChannelState<Bls12>, fn execute_payment_protocol_helper(channel_state: &mut bidirectional::ChannelState<Bls12>,
channel_token: &mut bidirectional::ChannelToken<Bls12>, channel_token: &mut bidirectional::ChannelToken<Bls12>,
merch_wallet: &mut bidirectional::MerchantWallet<Bls12>, merch_state: &mut bidirectional::MerchantState<Bls12>,
cust_wallet: &mut bidirectional::CustomerWallet<Bls12>, cust_state: &mut bidirectional::CustomerState<Bls12>,
payment_increment: i32) { payment_increment: i32) {
let mut rng = &mut rand::thread_rng(); 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 // 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 // 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] #[test]
@ -555,49 +555,49 @@ mod tests {
let b0_merchant = 20; let b0_merchant = 20;
let payment_increment = 20; let payment_increment = 20;
let (mut channel_token, mut merch_wallet) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant Bob"); let (mut channel_token, mut merch_state) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant Bob");
// initialize the balance for merch_wallet // initialize the balance for merch_state
merch_wallet.init_balance(b0_merchant); 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 // 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 // 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 { let close_token= match option {
Ok(n) => n.unwrap(), Ok(n) => n.unwrap(),
Err(e) => panic!("Failed - bidirectional::establish_merchant_issue_close_token(): {}", e) 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 // wait for funding tx to be confirmed, etc
// obtain payment token for pay protocol // obtain payment token for pay protocol
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);
//assert!(cust_wallet.verify_pay_token(&channel_state, &pay_token)); //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!"); 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 // 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 // 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!"); 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!("Obtained the channel close message");
println!("{}", cust_close.message); println!("{}", cust_close.message);
println!("{}", cust_close.signature); println!("{}", cust_close.signature);
@ -616,10 +616,10 @@ mod tests {
channel_state.setup(&mut rng); // or load_setup params 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 // 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); assert!(channel_state.channel_established);
@ -627,17 +627,17 @@ mod tests {
// make multiple payments in a loop // make multiple payments in a loop
let num_payments = total_owed / payment_increment; let num_payments = total_owed / payment_increment;
for i in 0 .. num_payments { 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) // scope localizes the immutable borrow here (for debug purposes only)
println!("Customer balance: {:?}", &cust_wallet.cust_balance); println!("Customer balance: {:?}", &cust_state.cust_balance);
println!("Merchant balance: {:?}", &cust_wallet.merch_balance); println!("Merchant balance: {:?}", &cust_state.merch_balance);
assert!(cust_wallet.cust_balance == (b0_customer - total_owed) && cust_wallet.merch_balance == total_owed + b0_merchant); 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!("Obtained the channel close message");
println!("{}", cust_close.message); println!("{}", cust_close.message);
println!("{}", cust_close.signature); println!("{}", cust_close.signature);
@ -658,21 +658,21 @@ mod tests {
channel_state.setup(&mut rng); // or load_setup params 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 // 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); assert!(channel_state.channel_established);
{ {
// make multiple payments in a loop // 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) // scope localizes the immutable borrow here (for debug purposes only)
println!("Customer balance: {:?}", &cust_wallet.cust_balance); println!("Customer balance: {:?}", &cust_state.cust_balance);
println!("Merchant balance: {:?}", &cust_wallet.merch_balance); println!("Merchant balance: {:?}", &cust_state.merch_balance);
assert!(cust_wallet.cust_balance == (b0_customer - total_owed) && cust_wallet.merch_balance == total_owed + b0_merchant); 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 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_cust = 100;
let b0_merch = 10; 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(); let serlalized_ct = serde_json::to_string(&channel_token).unwrap();
@ -796,11 +796,11 @@ mod tests {
//println!("des_ct: {}", &des_ct); //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); 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]); z0.add_assign(&t[0]);
z.push(z0); z.push(z0);
let newWalletVec = newWallet.as_fr_vec(); let newWalletVec = newWallet.as_fr_vec();
// println!("z.len = {}, wallet len = {}", t.len(), newWalletVec.len());
// println!("max => {}", max);
for i in 1..t.len() { for i in 1..t.len() {
let mut zi = newWalletVec[i - 1].clone(); let mut zi = newWalletVec[i - 1].clone();
zi.mul_assign(&challenge); zi.mul_assign(&challenge);

16
src/util.rs
View File

@ -116,7 +116,7 @@ pub struct CommitmentProof<E: Engine> {
} }
impl<E: Engine> CommitmentProof<E> { 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(); let mut Tvals = E::G1::zero();
assert!(wallet.len() <= com_params.pub_bases.len()); assert!(wallet.len() <= com_params.pub_bases.len());
@ -138,13 +138,23 @@ impl<E: Engine> CommitmentProof<E> {
let mut z0 = r.clone(); let mut z0 = r.clone();
z0.mul_assign(&challenge); z0.mul_assign(&challenge);
z0.add_assign(&t[0]); z0.add_assign(&t[0]);
z.push(z0); // 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() { for i in 1..t.len() {
let mut zi = wallet[i-1].clone(); let mut zi = wallet[i-1].clone();
zi.mul_assign(&challenge); zi.mul_assign(&challenge);
zi.add_assign(&t[i]); zi.add_assign(&t[i]);
z.push(zi); if (reveal_index.contains(&i)) {
z.push(E::Fr::zero());
} else {
z.push(zi);
}
} }
CommitmentProof { CommitmentProof {