diff --git a/Cargo.toml b/Cargo.toml index c782fce..971faf7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,7 +15,6 @@ rand_core = "0.4.0" rand_xorshift = "0.1" ff = { git = "https://github.com/boltlabs-inc/ff", branch = "master" } pairing = { git = "https://github.com/boltlabs-inc/pairing", branch = "master", features = ["serde"] } -bincode = "0.6.1" libc = "*" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" @@ -25,11 +24,6 @@ time = "*" secp256k1 = { version = "0.15.0", features = ["rand", "serde"] } sha2 = { version = "0.8", default-features = false } -[dev-dependencies.bincode] -version = "~0.6.0" -default-features = false -features = ["rustc-serialize"] - [lib] crate-type = ["lib", "cdylib"] diff --git a/go/libbolt.go b/go/libbolt.go index f2ab52b..498c361 100644 --- a/go/libbolt.go +++ b/go/libbolt.go @@ -120,11 +120,11 @@ type Commitment struct { } type Wallet struct { - Pkc []string `json:"pkc"` - Wpk []string `json:"wpk"` - Bc int64 `json:"bc"` - Bm int64 `json:"bm"` - Close []string `json:"close"` + ChannelId []string `json:"channelId"` + Wpk []string `json:"wpk"` + Bc int64 `json:"bc"` + Bm int64 `json:"bm"` + Close []string `json:"close"` } type KeyPair struct { @@ -311,7 +311,7 @@ func BidirectionalEstablishCustomerGenerateProof(channelToken ChannelToken, cust return channelToken, custState, com, comProof, err } -func BidirectionalEstablishMerchantIssueCloseToken(channelState ChannelState, com Commitment, comProof CommitmentProof, pkc string, initCustBal int, initMerchBal int, merchState MerchState) (Signature, error) { +func BidirectionalEstablishMerchantIssueCloseToken(channelState ChannelState, com Commitment, comProof CommitmentProof, channelId string, initCustBal int, initMerchBal int, merchState MerchState) (Signature, error) { serChannelState, err := json.Marshal(channelState) if err != nil { return Signature{}, err @@ -328,7 +328,7 @@ func BidirectionalEstablishMerchantIssueCloseToken(channelState ChannelState, co if err != nil { return Signature{}, err } - resp := C.GoString(C.ffishim_bidirectional_establish_merchant_issue_close_token(C.CString(string(serChannelState)), C.CString(string(serCom)), C.CString(string(serComProof)), C.CString(pkc), C.longlong(initCustBal), C.longlong(initMerchBal), C.CString(string(serMerchState)))) + resp := C.GoString(C.ffishim_bidirectional_establish_merchant_issue_close_token(C.CString(string(serChannelState)), C.CString(string(serCom)), C.CString(string(serComProof)), C.CString(channelId), C.longlong(initCustBal), C.longlong(initMerchBal), C.CString(string(serMerchState)))) r, err := processCResponse(resp) if err != nil { return Signature{}, err diff --git a/go/libbolt_test.go b/go/libbolt_test.go index d3e5885..fdd85be 100644 --- a/go/libbolt_test.go +++ b/go/libbolt_test.go @@ -36,7 +36,7 @@ func Test_Establish(t *testing.T) { channelToken, custState, com, comProof, err := BidirectionalEstablishCustomerGenerateProof(channelToken, custState) assert.Nil(t, err) - closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, custState.PkC, b0Cust, b0Merch, merchState) + closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, custState.Wallet.ChannelId[0], b0Cust, b0Merch, merchState) assert.Nil(t, err) assert.NotNil(t, closeToken) @@ -61,7 +61,7 @@ func Test_Pay(t *testing.T) { assert.Nil(t, err) channelToken, custState, com, comProof, err := BidirectionalEstablishCustomerGenerateProof(channelToken, custState) assert.Nil(t, err) - closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, custState.PkC, b0Cust, b0Merch, merchState) + closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, custState.Wallet.ChannelId[0], b0Cust, b0Merch, merchState) assert.Nil(t, err) _, channelState, custState, err = BidirectionalVerifyCloseToken(channelState, custState, closeToken) assert.Nil(t, err) @@ -95,7 +95,7 @@ func Test_IntermediaryPay(t *testing.T) { assert.Nil(t, err) channelToken, custStateAlice, com, comProof, err := BidirectionalEstablishCustomerGenerateProof(channelToken, custStateAlice) assert.Nil(t, err) - closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, custStateAlice.PkC, b0Alice, b0Intermediary, merchState) + closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, custStateAlice.Wallet.ChannelId[0], b0Alice, b0Intermediary, merchState) assert.Nil(t, err) _, channelState, custStateAlice, err = BidirectionalVerifyCloseToken(channelState, custStateAlice, closeToken) assert.Nil(t, err) @@ -107,7 +107,7 @@ func Test_IntermediaryPay(t *testing.T) { assert.Nil(t, err) channelToken, custStateBob, com, comProof, err = BidirectionalEstablishCustomerGenerateProof(channelToken, custStateBob) assert.Nil(t, err) - closeToken, err = BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, custStateBob.PkC, b0Bob, b0Intermediary, merchState) + closeToken, err = BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, custStateBob.Wallet.ChannelId[0], b0Bob, b0Intermediary, merchState) assert.Nil(t, err) _, channelState, custStateBob, err = BidirectionalVerifyCloseToken(channelState, custStateBob, closeToken) assert.Nil(t, err) @@ -143,7 +143,7 @@ func Test_Close(t *testing.T) { assert.Nil(t, err) channelToken, custState, com, comProof, err := BidirectionalEstablishCustomerGenerateProof(channelToken, custState) assert.Nil(t, err) - closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, custState.PkC, b0Cust, b0Merch, merchState) + closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, custState.Wallet.ChannelId[0], b0Cust, b0Merch, merchState) assert.Nil(t, err) _, channelState, custState, err = BidirectionalVerifyCloseToken(channelState, custState, closeToken) assert.Nil(t, err) diff --git a/py/libbolt.py b/py/libbolt.py index d9a7f68..2ca121f 100644 --- a/py/libbolt.py +++ b/py/libbolt.py @@ -106,8 +106,8 @@ class Libbolt(object): output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8')) return output_dictionary.get('channel_token'), output_dictionary.get('cust_state'), output_dictionary.get('com'), output_dictionary.get('com_proof') - def bidirectional_establish_merchant_issue_close_token(self, channel_state, com, com_proof, pkc, init_cust, init_merch, merch_state): - output_string = self.lib.ffishim_bidirectional_establish_merchant_issue_close_token(channel_state.encode(), com.encode(), com_proof.encode(), pkc.encode(), init_cust, init_merch, merch_state.encode()) + def bidirectional_establish_merchant_issue_close_token(self, channel_state, com, com_proof, channel_id, init_cust, init_merch, merch_state): + output_string = self.lib.ffishim_bidirectional_establish_merchant_issue_close_token(channel_state.encode(), com.encode(), com_proof.encode(), channel_id.encode(), init_cust, init_merch, merch_state.encode()) output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8')) return output_dictionary.get('close_token') @@ -259,7 +259,7 @@ def run_unit_test(): print("com: ", com) cust_state_dict = json.loads(cust_state) - close_token = libbolt.bidirectional_establish_merchant_issue_close_token(channel_state, com, com_proof, cust_state_dict["pk_c"], b0_cust, b0_merch, merch_state) + close_token = libbolt.bidirectional_establish_merchant_issue_close_token(channel_state, com, com_proof, cust_state_dict["wallet"]["channelId"], b0_cust, b0_merch, merch_state) print("close token: ", close_token) (is_token_valid, channel_state, cust_state) = libbolt.bidirectional_establish_customer_verify_close_token(channel_state, cust_state, close_token) diff --git a/src/channels.rs b/src/channels.rs index 5f4d252..7e42b2a 100644 --- a/src/channels.rs +++ b/src/channels.rs @@ -124,25 +124,16 @@ impl ChannelToken { } pub fn compute_channel_id(&self) -> E::Fr - where ::G1: serde::Serialize, - ::G2: serde::Serialize, - ::Fr: serde::Serialize +// where ::G1: serde::Serialize, +// ::G2: serde::Serialize, +// ::Fr: serde::Serialize { - let mut input = Vec::new(); - - if !self.pk_c.is_none() { - let ser_pkc = self.pk_c.unwrap().serialize_uncompressed(); - input.extend_from_slice(&ser_pkc); + if self.pk_c.is_none() { + panic!("pk_c is not initialized yet"); } - let ser_pk_m = self.pk_m.serialize_uncompressed(); - let ser_cl_pk_m = serde_json::to_vec(&self.cl_pk_m).unwrap(); - let ser_mpk = serde_json::to_vec(&self.mpk).unwrap(); - let ser_comParams = serde_json::to_vec(&self.comParams).unwrap(); - - input.extend_from_slice(&ser_pk_m); - input.extend(&ser_cl_pk_m); - input.extend(&ser_mpk); - input.extend(&ser_comParams); + //let input = serde_json::to_vec(&self).unwrap(); + let mut input = Vec::new(); + input.extend_from_slice(&self.pk_m.serialize_uncompressed()); return hash_to_fr::(input); } @@ -243,17 +234,16 @@ impl CustomerState { let (wsk, wpk) = kp.generate_keypair(csprng); // hash the wallet pub key let wpk_h = hash_pubkey_to_fr::(&wpk); - // hash the channel pub key - let pk_h = hash_pubkey_to_fr::(&pk_c); + channel_token.set_customer_pk(&pk_c); + // compute the channel ID + let channelId = channel_token.compute_channel_id(); // randomness for commitment let t = E::Fr::rand(csprng); // initialize wallet vector - let wallet = Wallet { pkc: pk_h, wpk: wpk_h, bc: cust_bal, bm: merch_bal, close: None }; + let wallet = Wallet { channelId: channelId, wpk: wpk_h, bc: cust_bal, bm: merch_bal, close: None }; let w_com = channel_token.comParams.commit(&wallet.as_fr_vec(), &t); - channel_token.set_customer_pk(&pk_c); - assert!(channel_token.is_init()); let ct_db = HashMap::new(); @@ -296,7 +286,7 @@ impl CustomerState { // generate nizk proof of knowledge of commitment opening pub fn generate_proof(&self, csprng: &mut R, channel_token: &ChannelToken) -> CommitmentProof { - // generate proof and do a partial reveal of pkc and bc/bm (init balances) + // generate proof and do a partial reveal of channelId and bc/bm (init balances) return CommitmentProof::::new(csprng, &channel_token.comParams, &self.w_com.c, &self.wallet.as_fr_vec(), &self.t, &vec![1, 3, 4]); } @@ -369,8 +359,8 @@ impl CustomerState { let new_t = E::Fr::rand(csprng); let cp = channel.cp.as_ref().unwrap(); - let old_wallet = Wallet { pkc: self.wallet.pkc.clone(), wpk: self.wallet.wpk.clone(), bc: self.cust_balance, bm: self.merch_balance, close: None }; - let new_wallet = Wallet { pkc: self.wallet.pkc.clone(), wpk: wpk_h, bc: new_cust_bal, bm: new_merch_bal, close: Some(self.wallet.close.unwrap()) }; + let old_wallet = Wallet { channelId: self.wallet.channelId.clone(), wpk: self.wallet.wpk.clone(), bc: self.cust_balance, bm: self.merch_balance, close: None }; + let new_wallet = Wallet { channelId: self.wallet.channelId.clone(), wpk: wpk_h, bc: new_cust_bal, bm: new_merch_bal, close: Some(self.wallet.close.unwrap()) }; let new_wcom = cp.pub_params.comParams.commit(&new_wallet.as_fr_vec(), &new_t); // 3 - generate new blinded and randomized pay token @@ -557,8 +547,8 @@ impl MerchantState { return self.keypair.sign_blind(csprng, &cp.pub_params.mpk, pay_com); } - pub fn verify_proof(&self, csprng: &mut R, channel: &ChannelState, com: &Commitment, com_proof: &CommitmentProof, pkc: &E::Fr, cust_balance: i64, merch_balance: i64) -> ResultBoltType<(Signature, Signature)> { - let is_valid = nizk::verify_opening(&self.comParams, &com.c, &com_proof, &pkc, cust_balance, merch_balance); + pub fn verify_proof(&self, csprng: &mut R, channel: &ChannelState, com: &Commitment, com_proof: &CommitmentProof, channelId: &E::Fr, cust_balance: i64, merch_balance: i64) -> ResultBoltType<(Signature, Signature)> { + let is_valid = nizk::verify_opening(&self.comParams, &com.c, &com_proof, &channelId, cust_balance, merch_balance); let cp = channel.cp.as_ref().unwrap(); if is_valid { let close_token = self.issue_close_token(csprng, cp, com, true); @@ -653,8 +643,9 @@ mod tests { // first return the close token, then wait for escrow-tx confirmation // then send the pay-token after confirmation - let pk_h = hash_pubkey_to_fr::(&cust_state.pk_c.clone()); - let (close_token, pay_token) = merch_state.verify_proof(rng, &channel, &cust_state.w_com, &cust_com_proof, &pk_h, b0_cust, b0_merch).unwrap(); + let channelId = channel_token.compute_channel_id(); + assert_eq!(channelId, cust_state.get_wallet().channelId); + let (close_token, pay_token) = merch_state.verify_proof(rng, &channel, &cust_state.w_com, &cust_com_proof, &channelId, b0_cust, b0_merch).unwrap(); // unblind tokens and verify signatures assert!(cust_state.verify_close_token(&channel, &close_token)); @@ -690,4 +681,23 @@ mod tests { //println!("Validated revoke token!"); } + + #[test] + #[should_panic(expected = "pk_c is not initialized yet")] + fn compute_channel_id_panics() { + let mut channel = ChannelState::::new(String::from("Channel A <-> B"), false); + let mut rng = &mut rand::thread_rng(); + + let b0_cust = 100; + let b0_merch = 20; + // 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_state, mut channel) = MerchantState::::new(rng, &mut channel, String::from("Merchant B")); + + // initialize the merchant wallet with the balance + let mut channel_token = merch_state.init(rng, &mut channel); + + let channelId = channel_token.compute_channel_id(); + } } diff --git a/src/cl.rs b/src/cl.rs index 7e8a37a..49a5a34 100644 --- a/src/cl.rs +++ b/src/cl.rs @@ -13,7 +13,6 @@ use serde::{Serialize, Deserialize}; use serde::ser::{Serializer, SerializeStruct, SerializeSeq}; use util; use ccs08; -use bincode::serde::serialize; #[derive(Clone, Serialize, Deserialize, Debug)] pub struct PublicParams { diff --git a/src/ffishim.rs b/src/ffishim.rs index 1516f4b..b5e11b2 100644 --- a/src/ffishim.rs +++ b/src/ffishim.rs @@ -161,7 +161,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_pk_c: *mut c_char, init_cust_bal: i64, init_merch_bal: i64, ser_merch_state: *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_channel_id: *mut c_char, init_cust_bal: i64, init_merch_bal: i64, ser_merch_state: *mut c_char) -> *mut c_char { let rng = &mut rand::thread_rng(); // Deserialize the channel state let channel_state_result: ResultSerdeType> = deserialize_result_object(ser_channel_state); @@ -180,7 +180,7 @@ pub mod ffishim { let merch_state = handle_errors!(merch_state_result); // Deserialize the pk_c - let bytes = unsafe { CStr::from_ptr(ser_pk_c).to_bytes() }; + let bytes = unsafe { CStr::from_ptr(ser_channel_id).to_bytes() }; let string: &str = str::from_utf8(bytes).unwrap(); let pk_c_result = secp256k1::PublicKey::from_str(string); let pk_c = handle_errors!(pk_c_result); diff --git a/src/lib.rs b/src/lib.rs index c073e2b..5fe2420 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -24,7 +24,6 @@ extern crate pairing; extern crate rand; extern crate rand_core; -extern crate bincode; //extern crate sodiumoxide; extern crate secp256k1; extern crate time; @@ -51,8 +50,6 @@ pub mod ffishim; use std::fmt; use std::str; -use bincode::SizeLimit::Infinite; -use bincode::rustc_serialize::{encode, decode}; //use sodiumoxide::randombytes; //use sodiumoxide::crypto::hash::sha512; //use sha2::Sha512; @@ -221,10 +218,10 @@ pub mod bidirectional { /// pub fn establish_merchant_issue_close_token(csprng: &mut R, channel_state: &ChannelState, com: &Commitment, com_proof: &CommitmentProof, - pkc: &E::Fr, init_cust_balance: i64, init_merch_balance: i64, + channel_id: &E::Fr, init_cust_balance: i64, init_merch_balance: i64, merch_state: &MerchantState) -> BoltResult> { // verifies proof of committed values and derives blind signature on the committed values to the customer's initial wallet - match merch_state.verify_proof(csprng, channel_state, com, com_proof, pkc, init_cust_balance, init_merch_balance) { + match merch_state.verify_proof(csprng, channel_state, com, com_proof, channel_id, init_cust_balance, init_merch_balance) { Ok(n) => Ok(Some(n.0)), // just close token Err(err) => Err(String::from(err.to_string())) } @@ -481,7 +478,7 @@ pub mod bidirectional { let chan_token_pk_c = util::hash_pubkey_to_fr::(&pk_c); let chan_token_wpk = util::hash_pubkey_to_fr::(&wpk); - let pkc_thesame = (close_msg.pkc == chan_token_pk_c); + let pkc_thesame = (close_msg.channelId == chan_token_pk_c); // (2) check that wpk matches what's in the close msg let wpk_thesame = (close_msg.wpk == chan_token_wpk); return pkc_thesame && wpk_thesame && channel_token.cl_pk_m.verify(&channel_token.mpk, &close_msg.as_fr_vec(), &close_token); @@ -570,8 +567,7 @@ mod tests { // obtain close token for closing out channel //let pk_h = hash_pubkey_to_fr::(&cust_state.pk_c.clone()); - let pk_c = cust_state.get_public_key(); - let option = bidirectional::establish_merchant_issue_close_token(rng, &channel_state, &com, &com_proof, &pk_c, + let option = bidirectional::establish_merchant_issue_close_token(rng, &channel_state, &com, &com_proof, &cust_state.get_wallet().channelId, cust_balance, merch_balance, &merch_state); let close_token = match option { Ok(n) => n.unwrap(), @@ -631,8 +627,7 @@ mod tests { let (com, com_proof) = bidirectional::establish_customer_generate_proof(rng, &mut channel_token, &mut cust_state); // obtain close token for closing out channel - let pk_h = hash_pubkey_to_fr::(&cust_state.pk_c.clone()); - let option = bidirectional::establish_merchant_issue_close_token(rng, &channel_state, &com, &com_proof, &pk_h, + let option = bidirectional::establish_merchant_issue_close_token(rng, &channel_state, &com, &com_proof, &cust_state.get_wallet().channelId, b0_customer, b0_merchant, &merch_state); let close_token = match option { Ok(n) => n.unwrap(), diff --git a/src/nizk.rs b/src/nizk.rs index 87689cf..5cadab1 100644 --- a/src/nizk.rs +++ b/src/nizk.rs @@ -203,12 +203,12 @@ impl NIZKPublicParams { /// /// Verify PoK for the opening of a commitment during the establishment protocol /// -pub fn verify_opening(com_params: &CSMultiParams, com: &E::G1, proof: &CommitmentProof, pkc: &E::Fr, init_cust: i64, init_merch: i64) -> bool { +pub fn verify_opening(com_params: &CSMultiParams, com: &E::G1, proof: &CommitmentProof, channelId: &E::Fr, init_cust: i64, init_merch: i64) -> bool { let xvec: Vec = vec![proof.T.clone(), com.clone()]; let challenge = util::hash_g1_to_fr::(&xvec); // compute the - let com_equal = proof.verify_proof(com_params, com, &challenge, Some(vec!{None, Some(pkc.clone()), None, Some(util::convert_int_to_fr::(init_cust as i64)), Some(util::convert_int_to_fr::(init_merch as i64))})); + let com_equal = proof.verify_proof(com_params, com, &challenge, Some(vec!{None, Some(channelId.clone()), None, Some(util::convert_int_to_fr::(init_cust as i64)), Some(util::convert_int_to_fr::(init_merch as i64))})); return com_equal; } @@ -225,7 +225,7 @@ mod tests { #[test] fn nizk_proof_works() { let rng = &mut rand::thread_rng(); - let pkc = Fr::rand(rng); + let channelId = Fr::rand(rng); let wpk = Fr::rand(rng); let wpkprime = Fr::rand(rng); let bc = rng.gen_range(100, 1000); @@ -239,9 +239,9 @@ mod tests { let rprime = Fr::rand(rng); let secParams = NIZKSecretParams::::setup(rng, 4); - let wallet1 = Wallet { pkc, wpk, bc, bm, close: None }; + let wallet1 = Wallet { channelId: channelId, wpk, bc, bm, close: None }; let commitment1 = secParams.pubParams.comParams.commit(&wallet1.as_fr_vec(), &r); - let wallet2 = Wallet { pkc, wpk: wpkprime, bc: bc2, bm: bm2, close: None }; + let wallet2 = Wallet { channelId: channelId, wpk: wpkprime, bc: bc2, bm: bm2, close: None }; let commitment2 = secParams.pubParams.comParams.commit(&wallet2.as_fr_vec(), &rprime); let blindPaymentToken = secParams.keypair.sign_blind(rng, &secParams.pubParams.mpk, commitment1.clone()); let paymentToken = secParams.keypair.unblind(&r, &blindPaymentToken); @@ -255,7 +255,7 @@ mod tests { #[test] fn nizk_proof_negative_value_works() { let rng = &mut rand::thread_rng(); - let pkc = Fr::rand(rng); + let channelId = Fr::rand(rng); let wpk = Fr::rand(rng); let wpkprime = Fr::rand(rng); let bc = rng.gen_range(100, 1000); @@ -269,9 +269,9 @@ mod tests { let rprime = Fr::rand(rng); let secParams = NIZKSecretParams::::setup(rng, 4); - let wallet1 = Wallet { pkc, wpk, bc, bm, close: None }; + let wallet1 = Wallet { channelId: channelId, wpk, bc, bm, close: None }; let commitment1 = secParams.pubParams.comParams.commit(&wallet1.as_fr_vec(), &r); - let wallet2 = Wallet { pkc, wpk: wpkprime, bc: bc2, bm: bm2, close: None }; + let wallet2 = Wallet { channelId: channelId, wpk: wpkprime, bc: bc2, bm: bm2, close: None }; let commitment2 = secParams.pubParams.comParams.commit(&wallet2.as_fr_vec(), &rprime); let blindPaymentToken = secParams.keypair.sign_blind(rng, &secParams.pubParams.mpk, commitment1.clone()); let paymentToken = secParams.keypair.unblind(&r, &blindPaymentToken); @@ -285,7 +285,7 @@ mod tests { #[test] fn nizk_proof_close_works() { let rng = &mut rand::thread_rng(); - let pkc = Fr::rand(rng); + let channelId = Fr::rand(rng); let wpk = Fr::rand(rng); let wpkprime = Fr::rand(rng); let bc = rng.gen_range(100, 1000); @@ -300,9 +300,9 @@ mod tests { let _closeToken = Fr::rand(rng); let secParams = NIZKSecretParams::::setup(rng, 5); - let wallet1 = Wallet { pkc, wpk, bc, bm, close: None }; + let wallet1 = Wallet { channelId: channelId, wpk, bc, bm, close: None }; let commitment1 = secParams.pubParams.comParams.commit(&wallet1.as_fr_vec(), &r); - let wallet2 = Wallet { pkc, wpk: wpkprime, bc: bc2, bm: bm2, close: Some(_closeToken) }; + let wallet2 = Wallet { channelId: channelId, wpk: wpkprime, bc: bc2, bm: bm2, close: Some(_closeToken) }; let commitment2 = secParams.pubParams.comParams.commit(&wallet2.as_fr_vec(), &rprime); let blindPaymentToken = secParams.keypair.sign_blind(rng, &secParams.pubParams.mpk, commitment1.clone()); let paymentToken = secParams.keypair.unblind(&r, &blindPaymentToken); @@ -326,7 +326,7 @@ mod tests { #[test] fn nizk_proof_false_statements() { let rng = &mut rand::thread_rng(); - let pkc = Fr::rand(rng); + let channelId = Fr::rand(rng); let wpk = Fr::rand(rng); let wpkprime = Fr::rand(rng); let bc = rng.gen_range(100, 1000); @@ -340,10 +340,10 @@ mod tests { let rprime = Fr::rand(rng); let secParams = NIZKSecretParams::::setup(rng, 4); - let wallet1 = Wallet { pkc, wpk, bc, bm, close: None }; + let wallet1 = Wallet { channelId: channelId, wpk, bc, bm, close: None }; let bc2Prime = bc.clone(); - let wallet3 = Wallet { pkc, wpk: wpkprime, bc: bc2Prime, bm: bm2, close: None }; + let wallet3 = Wallet { channelId: channelId, wpk: wpkprime, bc: bc2Prime, bm: bm2, close: None }; let commitment1 = secParams.pubParams.comParams.commit(&wallet1.as_fr_vec().clone(), &r); let commitment2 = secParams.pubParams.comParams.commit(&wallet3.as_fr_vec(), &rprime); let blindPaymentToken = secParams.keypair.sign_blind(rng, &secParams.pubParams.mpk, commitment1.clone()); @@ -352,12 +352,12 @@ mod tests { assert_eq!(secParams.verify(proof, Fr::from_str(&epsilon.to_string()).unwrap(), &commitment2, wpk), false); let bm2Prime = bm.clone(); - let wallet4 = Wallet { pkc, wpk: wpkprime, bc: bc2, bm: bm2Prime, close: None }; + let wallet4 = Wallet { channelId: channelId, wpk: wpkprime, bc: bc2, bm: bm2Prime, close: None }; let commitment2 = secParams.pubParams.comParams.commit(&wallet4.as_fr_vec(), &rprime); let proof = secParams.pubParams.prove(rng, wallet1.clone(), wallet4, commitment2.clone(), rprime, &paymentToken); assert_eq!(secParams.verify(proof, Fr::from_str(&epsilon.to_string()).unwrap(), &commitment2, wpk), false); - let wallet5 = Wallet { pkc: Fr::rand(rng), wpk: wpkprime, bc: bc2, bm: bm2, close: None }; + let wallet5 = Wallet { channelId: Fr::rand(rng), wpk: wpkprime, bc: bc2, bm: bm2, close: None }; let commitment2 = secParams.pubParams.comParams.commit(&wallet5.as_fr_vec(), &rprime); let proof = secParams.pubParams.prove(rng, wallet1.clone(), wallet5, commitment2.clone(), rprime, &paymentToken); assert_eq!(secParams.verify(proof, Fr::from_str(&epsilon.to_string()).unwrap(), &commitment2, wpk), false); @@ -366,13 +366,13 @@ mod tests { #[test] fn nizk_proof_commitment_opening_works() { let rng = &mut rand::thread_rng(); - let pkc = Fr::rand(rng); + let channelId = Fr::rand(rng); let wpk = Fr::rand(rng); let t = Fr::rand(rng); let bc = rng.gen_range(100, 1000); let bm = rng.gen_range(100, 1000); - let wallet = Wallet:: { pkc: pkc, wpk: wpk, bc: bc, bm: bm, close: None }; + let wallet = Wallet:: { channelId: channelId, wpk: wpk, bc: bc, bm: bm, close: None }; let secParams = NIZKSecretParams::::setup(rng, 4); let com = secParams.pubParams.comParams.commit(&wallet.as_fr_vec().clone(), &t); @@ -380,21 +380,21 @@ mod tests { let com_proof = CommitmentProof::::new(rng, &secParams.pubParams.comParams, &com.c, &wallet.as_fr_vec(), &t, &vec![1, 3, 4]); - assert!(verify_opening(&secParams.pubParams.comParams, &com.c, &com_proof, &pkc.clone(), bc, bm)); + assert!(verify_opening(&secParams.pubParams.comParams, &com.c, &com_proof, &channelId.clone(), bc, bm)); } #[test] fn nizk_proof_false_commitment() { let rng = &mut rand::thread_rng(); - let pkc = Fr::rand(rng); + let channelId = Fr::rand(rng); let wpk = Fr::rand(rng); let t = Fr::rand(rng); let bc = rng.gen_range(100, 1000); let bc2 = rng.gen_range(100, 1000); let bm = rng.gen_range(100, 1000); - let wallet1 = Wallet:: { pkc: pkc, wpk: wpk, bc: bc, bm: bm, close: None }; - let wallet2 = Wallet:: { pkc: pkc, wpk: wpk, bc: bc2, bm: bm, close: None }; + let wallet1 = Wallet:: { channelId: channelId, wpk: wpk, bc: bc, bm: bm, close: None }; + let wallet2 = Wallet:: { channelId: channelId, wpk: wpk, bc: bc2, bm: bm, close: None }; let secParams = NIZKSecretParams::::setup(rng, 4); let com1 = secParams.pubParams.comParams.commit(&wallet1.as_fr_vec().clone(), &t); @@ -403,8 +403,8 @@ mod tests { let com1_proof = CommitmentProof::::new(rng, &secParams.pubParams.comParams, &com1.c, &wallet1.as_fr_vec(), &t, &vec![1, 3, 4]); - assert!(verify_opening(&secParams.pubParams.comParams, &com1.c, &com1_proof, &pkc.clone(), bc, bm)); - assert!(!verify_opening(&secParams.pubParams.comParams, &com2.c, &com1_proof, &pkc.clone(), bc2, bm)); + assert!(verify_opening(&secParams.pubParams.comParams, &com1.c, &com1_proof, &channelId.clone(), bc, bm)); + assert!(!verify_opening(&secParams.pubParams.comParams, &com2.c, &com1_proof, &channelId.clone(), bc2, bm)); } diff --git a/src/ped92.rs b/src/ped92.rs index 1b7e825..d419280 100644 --- a/src/ped92.rs +++ b/src/ped92.rs @@ -352,13 +352,13 @@ mod tests { #[test] fn test_proof_commitment() { let rng = &mut rand::thread_rng(); - let pkc = Fr::rand(rng); + let channelId = Fr::rand(rng); let wpk = Fr::rand(rng); let t = Fr::rand(rng); let bc = rng.gen_range(100, 1000); let bm = rng.gen_range(100, 1000); - let wallet = Wallet:: { pkc: pkc, wpk: wpk, bc: bc, bm: bm, close: None }; + let wallet = Wallet:: { channelId: channelId, wpk: wpk, bc: bc, bm: bm, close: None }; let comParams = CSMultiParams::setup_gen_params(rng, 4); let com = comParams.commit(&wallet.as_fr_vec().clone(), &t); diff --git a/src/serialization_wrappers.rs b/src/serialization_wrappers.rs deleted file mode 100644 index d5ed9ea..0000000 --- a/src/serialization_wrappers.rs +++ /dev/null @@ -1,564 +0,0 @@ -use bincode::SizeLimit::Infinite; -use bincode::rustc_serialize::{encode,decode}; -use bn::{Group, Fr, G1, G2, Gt}; -use bulletproofs::{BulletproofGens, PedersenGens, RangeProof}; -use secp256k1; -use std::fmt; -use curve25519_dalek::ristretto::RistrettoPoint; -use commit_scheme; -// use serde-rustc-serialize-interop; - -use serde::{Serialize, Serializer, ser::SerializeSeq, ser::SerializeStruct, Deserialize, Deserializer, de::Visitor, de::Error, de::SeqAccess}; - -pub fn serialize_generic_encodable(object: &T, serializer: S) -> Result -where - T: rustc_serialize::Encodable, - S: Serializer, -{ - let v = encode(&object, Infinite).unwrap(); - serializer.serialize_bytes(&v) -} - - -pub fn serialize_generic_encodable_option(optional_object: &Option, serializer: S) -> Result -where - T: rustc_serialize::Encodable, - S: Serializer, -{ - if let Some(object) = optional_object { - let v = encode(&object, Infinite).unwrap(); - return serializer.serialize_bytes(&v); - } - serializer.serialize_none() -} - -pub fn serialize_fixed_byte_array_option(optional_object: &Option<[u8; 64]>, serializer: S) -> Result -where - S: Serializer, -{ - if let Some(object) = optional_object { - return serializer.serialize_bytes(&object[..]); - } - serializer.serialize_none() -} - - -struct GOneVisitor; - -impl<'de> Visitor<'de> for GOneVisitor { - type Value = G1; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of bytes representing an element of G1") - } - - fn visit_seq>(self, mut seq: A) -> Result - { - let mut bytes = Vec::new(); - - loop { - let tmp = seq.next_element::(); - if let Ok(Some(b)) = tmp { - bytes.push(b) - } else { - break; - } - } - - Ok(decode(&bytes[..]).unwrap()) - } -} - -struct GTwoVisitor; - -impl<'de> Visitor<'de> for GTwoVisitor { - type Value = G2; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of bytes representing an element of G2") - } - - fn visit_seq>(self, mut seq: A) -> Result - { - let mut bytes = Vec::new(); - - loop { - let tmp = seq.next_element::(); - if let Ok(Some(b)) = tmp { - bytes.push(b) - } else { - break; - } - } - - Ok(decode(&bytes[..]).unwrap()) - } -} - -struct GTargetVisitor; - -impl<'de> Visitor<'de> for GTargetVisitor { - type Value = Gt; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of bytes representing an element of Gt") - } - - fn visit_seq>(self, mut seq: A) -> Result - { - let mut bytes = Vec::new(); - - loop { - let tmp = seq.next_element::(); - if let Ok(Some(b)) = tmp { - bytes.push(b) - } else { - break; - } - } - - Ok(decode(&bytes[..]).unwrap()) - } -} - -struct FieldVisitor; - -impl<'de> Visitor<'de> for FieldVisitor { - type Value = Fr; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of bytes representing an element of Fr") - } - - fn visit_seq>(self, mut seq: A) -> Result - { - let mut bytes = Vec::new(); - - loop { - let tmp = seq.next_element::(); - if let Ok(Some(b)) = tmp { - bytes.push(b) - } else { - break; - } - } - - Ok(decode(&bytes[..]).unwrap()) - } -} - -struct OptionalFieldVisitor; - -impl<'de> Visitor<'de> for OptionalFieldVisitor { - type Value = Option; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of bytes representing an optional Fr") - } - - fn visit_seq>(self, mut seq: A) -> Result - { - let mut bytes = Vec::new(); - - loop { - let tmp = seq.next_element::(); - if let Ok(Some(b)) = tmp { - bytes.push(b) - } else { - break; - } - } - - Ok(Some(decode(&bytes[..]).unwrap())) - } - - fn visit_none(self) -> Result - where - E: Error, - { - Ok(None) - } -} - -struct OptionalByteArrayVisitor; - -impl<'de> Visitor<'de> for OptionalByteArrayVisitor { - type Value = Option<[u8; 64]>; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of bytes or nothing") - } - - fn visit_seq>(self, mut seq: A) -> Result - { - let mut array: [u8; 64] = [00; 64]; - - for i in 0..64 { - let tmp = seq.next_element::(); - } - - Ok(Some(array)) - } - - fn visit_none(self) -> Result - where - E: Error, - { - Ok(None) - } -} - -pub fn deserialize_g_one<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(GOneVisitor); - - Ok(a.unwrap()) -} - -pub fn deserialize_g_two<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(GTwoVisitor); - - Ok(a.unwrap()) -} - -pub fn deserialize_g_t<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(GTargetVisitor); - - Ok(a.unwrap()) -} - -pub fn deserialize_fr<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(FieldVisitor); - - Ok(a.unwrap()) -} - -pub fn deserialize_optional_fr<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_option(OptionalFieldVisitor); - - Ok(a.unwrap()) -} - -pub fn deserialize_optional_fixed_64_byte_array<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_option(OptionalByteArrayVisitor); - - Ok(a.unwrap()) -} - -pub fn serialize_generic_encodable_vec(object: &Vec, serializer: S) -> Result -where - S: Serializer, - T: rustc_serialize::Encodable, -{ - let mut seq = serializer.serialize_seq(Some(object.len()))?; - for e in object { - - let v = encode(&e, Infinite).unwrap(); - seq.serialize_element(&v); - // for i in v { - // seq.serialize_element(&i)?; - // } - } - seq.end() -} - -struct G1VecVisitor; - -impl<'de> Visitor<'de> for G1VecVisitor { - type Value = Vec; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of byte encodings of G1") - } - - fn visit_seq>(self, mut seq: A) -> Result { - - let mut vec = Vec::new(); - - loop { - let tmp = seq.next_element::>(); - if let Ok(Some(b)) = tmp { - vec.push(decode(&b[..]).unwrap()); - } else { - break; - } - } - - Ok(vec) - } -} - -struct G2VecVisitor; - -impl<'de> Visitor<'de> for G2VecVisitor { - type Value = Vec; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of byte encodings of Vec G2") - } - - fn visit_seq>(self, mut seq: A) -> Result { - - let mut vec = Vec::new(); - - loop { - let tmp = seq.next_element::>(); - if let Ok(Some(b)) = tmp { - vec.push(decode(&b[..]).unwrap()); - } else { - break; - } - } - - Ok(vec) - } -} - -struct GTargetVecVisitor; - -impl<'de> Visitor<'de> for GTargetVecVisitor { - type Value = Vec; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of byte encodings of Vec Gt") - } - - fn visit_seq>(self, mut seq: A) -> Result { - - - let mut vec = Vec::new(); - - loop { - let tmp = seq.next_element::>(); - if let Ok(Some(b)) = tmp { - vec.push(decode(&b[..]).unwrap()); - } else { - break; - } - } - - Ok(vec) - } -} - -struct FrVecVisitor; - -impl<'de> Visitor<'de> for FrVecVisitor { - type Value = Vec; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of byte encodings of Fr") - } - - fn visit_seq>(self, mut seq: A) -> Result { - - let mut vec = Vec::new(); - - loop { - let tmp = seq.next_element::>(); - - if let Ok(Some(b)) = tmp { - vec.push(decode(&b[..]).unwrap()); - } else { - break; - } - } - - Ok(vec) - } -} - -pub fn deserialize_g_one_vec<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(G1VecVisitor); - - Ok(a.unwrap()) -} - -pub fn deserialize_g_two_vec<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(G2VecVisitor); - Ok(a.unwrap()) -} - -pub fn deserialize_g_t_vec<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(GTargetVecVisitor); - - Ok(a.unwrap()) -} - -pub fn deserialize_fr_vec<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(FrVecVisitor); - - Ok(a.unwrap()) -} - -// Wrapper class for Fr -#[derive(Serialize, Deserialize)] -pub struct FrWrapper( #[serde(serialize_with = "serialize_generic_encodable", deserialize_with = "deserialize_fr")] pub Fr); - -// Wrapper class for Vec -#[derive(Serialize, Deserialize)] -pub struct VecFrWrapper( #[serde(serialize_with = "serialize_generic_encodable_vec", deserialize_with = "deserialize_fr_vec")] pub Vec); - -// Wrapper class for Vec -#[derive(Serialize, Deserialize)] -pub struct VecG2Wrapper( #[serde(serialize_with = "serialize_generic_encodable_vec", deserialize_with = "deserialize_g_two_vec")] pub Vec); - - -// Wrapper class for commitment and the CSParams -#[derive(Serialize, Deserialize)] -pub struct WalletCommitmentAndParamsWrapper { - pub com: commit_scheme::Commitment, - pub params: commit_scheme::CSParams, -} - -pub fn serialize_bullet_proof(bp_gens: &bulletproofs::BulletproofGens, serializer: S) -> Result -where - S: Serializer, -{ - let mut state = serializer.serialize_seq(Some(2))?; - state.serialize_element(&bp_gens.gens_capacity)?; - state.serialize_element(&bp_gens.party_capacity)?; - state.end() -} - -struct BulletProofVisitor; - -impl<'de> Visitor<'de> for BulletProofVisitor { - type Value = BulletproofGens; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of usize for a BulletproofGens") - } - - fn visit_seq>(self, mut seq: A) -> Result { - - let mut g_capacity: usize = 0; - let mut p_capacity: usize = 0; - - let tmp = seq.next_element::(); - if let Ok(Some(b)) = tmp { - g_capacity = b; - } - - let tmp = seq.next_element::(); - if let Ok(Some(b)) = tmp { - p_capacity = b; - } - - - Ok(BulletproofGens::new(g_capacity, p_capacity)) - } -} - -pub fn deserialize_bullet_proof<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(BulletProofVisitor); - - Ok(a.unwrap()) -} - - -// -------------- -// Fix for the tuple thing. Not sure why its bugging, but it sure as hell is. - -struct RangeProofVisitor; - -impl<'de> Visitor<'de> for RangeProofVisitor { - type Value = (bulletproofs::RangeProof, curve25519_dalek::ristretto::CompressedRistretto); - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of bytes representing a tuple, one range proof and one risteretto point") - } - - fn visit_seq>(self, mut seq: A) -> Result { - - // the bytes representing the rangeproof - let tmp = seq.next_element::>(); - let range_bytes = tmp.unwrap().unwrap(); - let range_proof = bulletproofs::RangeProof::from_bytes(&range_bytes[..]).unwrap(); - - // the bytes representing the point - let tmp2 = seq.next_element::>(); - let point_bytes = tmp2.unwrap().unwrap(); - let point = curve25519_dalek::ristretto::CompressedRistretto::from_slice(&point_bytes[..]); - - Ok((range_proof, point)) - } -} - -pub fn deserialize_range_proof<'de, D>(deserializer: D) -> Result<(bulletproofs::RangeProof, curve25519_dalek::ristretto::CompressedRistretto), D::Error> -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(RangeProofVisitor); - - Ok(a.unwrap()) -} - -struct RPointVisitor; - -impl<'de> Visitor<'de> for RPointVisitor { - type Value = curve25519_dalek::ristretto::RistrettoPoint; - - fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { - formatter.write_str("Sequence of bytes representing a tuple, one range proof and one risteretto point") - } - - fn visit_seq>(self, mut seq: A) -> Result { - - - let mut point_bytes = Vec::new(); - loop { - let tmp = seq.next_element::(); - if let Ok(Some(b)) = tmp { - point_bytes.push(b) - } else { - break; - } - } - - let point = curve25519_dalek::ristretto::CompressedRistretto::from_slice(&point_bytes[..]); - - Ok(point.decompress().unwrap()) - } -} - -pub fn deserialize_r_point<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de> -{ - let a = deserializer.deserialize_seq(RPointVisitor); - - Ok(a.unwrap()) -} diff --git a/src/wallet.rs b/src/wallet.rs index 98e6b61..67228b4 100644 --- a/src/wallet.rs +++ b/src/wallet.rs @@ -10,7 +10,7 @@ use std::fmt; #[serde(bound(serialize = "::Fr: serde::Serialize"))] #[serde(bound(deserialize = "::Fr: serde::Deserialize<'de>"))] pub struct Wallet { - pub pkc: E::Fr, + pub channelId: E::Fr, pub wpk: E::Fr, pub bc: i64, pub bm: i64, @@ -20,14 +20,14 @@ pub struct Wallet { impl Wallet { pub fn as_fr_vec(&self) -> Vec { if self.close.is_some() { - vec!(self.pkc, self.wpk, E::Fr::from_str(&self.bc.to_string()).unwrap(), E::Fr::from_str(&self.bm.to_string()).unwrap(), self.close.unwrap()) + vec!(self.channelId, self.wpk, E::Fr::from_str(&self.bc.to_string()).unwrap(), E::Fr::from_str(&self.bm.to_string()).unwrap(), self.close.unwrap()) } else { - vec!(self.pkc, self.wpk, E::Fr::from_str(&self.bc.to_string()).unwrap(), E::Fr::from_str(&self.bm.to_string()).unwrap()) + vec!(self.channelId, self.wpk, E::Fr::from_str(&self.bc.to_string()).unwrap(), E::Fr::from_str(&self.bm.to_string()).unwrap()) } } pub fn without_close(&self) -> Vec { - vec!(self.pkc, self.wpk, E::Fr::from_str(&self.bc.to_string()).unwrap(), E::Fr::from_str(&self.bm.to_string()).unwrap()) + vec!(self.channelId, self.wpk, E::Fr::from_str(&self.bc.to_string()).unwrap(), E::Fr::from_str(&self.bm.to_string()).unwrap()) } pub fn with_close(&mut self, msg: String) -> Vec { @@ -41,9 +41,9 @@ impl fmt::Display for Wallet { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.close.is_some() { let close_str = self.close.unwrap(); - write!(f, "Wallet : (\npkc={}\nwpk={}\nbc={}\nbm={}\nclose={}\n)", &self.pkc, &self.wpk, &self.bc, &self.bm, close_str) + write!(f, "Wallet : (\nchannelId={}\nwpk={}\nbc={}\nbm={}\nclose={}\n)", &self.channelId, &self.wpk, &self.bc, &self.bm, close_str) } else { - write!(f, "Wallet : (\npkc={}\nwpk={}\nbc={}\nbm={}\nclose=None\n)", &self.pkc, &self.wpk, &self.bc, &self.bm) + write!(f, "Wallet : (\nchannelId={}\nwpk={}\nbc={}\nbm={}\nclose=None\n)", &self.channelId, &self.wpk, &self.bc, &self.bm) } } }