diff --git a/Cargo.toml b/Cargo.toml
index 3a81f80..7af67d7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -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"
diff --git a/src/channels.rs b/src/channels.rs
index 634c131..cfe4dd4 100644
--- a/src/channels.rs
+++ b/src/channels.rs
@@ -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!");
     }
diff --git a/src/cl.rs b/src/cl.rs
index 1a0b62a..149620d 100644
--- a/src/cl.rs
+++ b/src/cl.rs
@@ -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));
diff --git a/src/ffishim.rs b/src/ffishim.rs
index efeba2e..2a2dc82 100644
--- a/src/ffishim.rs
+++ b/src/ffishim.rs
@@ -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()
diff --git a/src/lib.rs b/src/lib.rs
index a1646e6..aaf91e4 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -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();
     }
 
 }
diff --git a/src/nizk.rs b/src/nizk.rs
index 5a1ba9b..f46dfd4 100644
--- a/src/nizk.rs
+++ b/src/nizk.rs
@@ -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);
diff --git a/src/util.rs b/src/util.rs
index 2ae30ab..8418f99 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -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,13 +138,23 @@ impl<E: Engine> CommitmentProof<E> {
         let mut z0 = r.clone();
         z0.mul_assign(&challenge);
         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() {
             let mut zi = wallet[i-1].clone();
             zi.mul_assign(&challenge);
             zi.add_assign(&t[i]);
-            z.push(zi);
+            if (reveal_index.contains(&i)) {
+                z.push(E::Fr::zero());
+            } else {
+                z.push(zi);
+            }
         }
 
         CommitmentProof {