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

channelid: clean up serialization libraries

This commit is contained in:
Gijs Van Laer 2019-10-17 18:01:41 -04:00
parent 8804884979
commit 8b6a520c99
12 changed files with 93 additions and 659 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Cargo.toml
View File

@ -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"]

14
go/libbolt.go
View File

@ -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

10
go/libbolt_test.go
View File

@ -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)

6
py/libbolt.py
View File

@ -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)

68
src/channels.rs
View File

@ -124,25 +124,16 @@ impl<E: Engine> ChannelToken<E> {
}
pub fn compute_channel_id(&self) -> E::Fr
where <E as pairing::Engine>::G1: serde::Serialize,
<E as pairing::Engine>::G2: serde::Serialize,
<E as ff::ScalarEngine>::Fr: serde::Serialize
// where <E as pairing::Engine>::G1: serde::Serialize,
// <E as pairing::Engine>::G2: serde::Serialize,
// <E as ff::ScalarEngine>::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::<E>(input);
}
@ -243,17 +234,16 @@ impl<E: Engine> CustomerState<E> {
let (wsk, wpk) = kp.generate_keypair(csprng);
// hash the wallet pub key
let wpk_h = hash_pubkey_to_fr::<E>(&wpk);
// hash the channel pub key
let pk_h = hash_pubkey_to_fr::<E>(&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<E: Engine> CustomerState<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> {
// 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::<E>::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<E: Engine> CustomerState<E> {
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<E: Engine> MerchantState<E> {
return self.keypair.sign_blind(csprng, &cp.pub_params.mpk, pay_com);
}
pub fn verify_proof<R: Rng>(&self, csprng: &mut R, channel: &ChannelState<E>, com: &Commitment<E>, com_proof: &CommitmentProof<E>, pkc: &E::Fr, cust_balance: i64, merch_balance: i64) -> ResultBoltType<(Signature<E>, Signature<E>)> {
let is_valid = nizk::verify_opening(&self.comParams, &com.c, &com_proof, &pkc, cust_balance, merch_balance);
pub fn verify_proof<R: Rng>(&self, csprng: &mut R, channel: &ChannelState<E>, com: &Commitment<E>, com_proof: &CommitmentProof<E>, channelId: &E::Fr, cust_balance: i64, merch_balance: i64) -> ResultBoltType<(Signature<E>, Signature<E>)> {
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::<Bls12>(&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::<Bls12>::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::<Bls12>::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();
}
}

1
src/cl.rs
View File

@ -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<E: Engine> {

4
src/ffishim.rs
View File

@ -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<bidirectional::ChannelState<Bls12>> = 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);

15
src/lib.rs
View File

@ -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<R: Rng, E: Engine>(csprng: &mut R, channel_state: &ChannelState<E>,
com: &Commitment<E>, com_proof: &CommitmentProof<E>,
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<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_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::<E>(&pk_c);
let chan_token_wpk = util::hash_pubkey_to_fr::<E>(&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::<Bls12>(&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::<Bls12>(&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(),

48
src/nizk.rs
View File

@ -203,12 +203,12 @@ impl<E: Engine> NIZKPublicParams<E> {
///
/// Verify PoK for the opening of a commitment during the establishment protocol
///
pub fn verify_opening<E: Engine>(com_params: &CSMultiParams<E>, com: &E::G1, proof: &CommitmentProof<E>, pkc: &E::Fr, init_cust: i64, init_merch: i64) -> bool {
pub fn verify_opening<E: Engine>(com_params: &CSMultiParams<E>, com: &E::G1, proof: &CommitmentProof<E>, channelId: &E::Fr, init_cust: i64, init_merch: i64) -> bool {
let xvec: Vec<E::G1> = vec![proof.T.clone(), com.clone()];
let challenge = util::hash_g1_to_fr::<E>(&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::<E>(init_cust as i64)), Some(util::convert_int_to_fr::<E>(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::<E>(init_cust as i64)), Some(util::convert_int_to_fr::<E>(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::<Bls12>::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::<Bls12>::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::<Bls12>::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::<Bls12>::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::<Bls12> { pkc: pkc, wpk: wpk, bc: bc, bm: bm, close: None };
let wallet = Wallet::<Bls12> { channelId: channelId, wpk: wpk, bc: bc, bm: bm, close: None };
let secParams = NIZKSecretParams::<Bls12>::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::<Bls12>::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::<Bls12> { pkc: pkc, wpk: wpk, bc: bc, bm: bm, close: None };
let wallet2 = Wallet::<Bls12> { pkc: pkc, wpk: wpk, bc: bc2, bm: bm, close: None };
let wallet1 = Wallet::<Bls12> { channelId: channelId, wpk: wpk, bc: bc, bm: bm, close: None };
let wallet2 = Wallet::<Bls12> { channelId: channelId, wpk: wpk, bc: bc2, bm: bm, close: None };
let secParams = NIZKSecretParams::<Bls12>::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::<Bls12>::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));
}

4
src/ped92.rs
View File

@ -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::<Bls12> { pkc: pkc, wpk: wpk, bc: bc, bm: bm, close: None };
let wallet = Wallet::<Bls12> { 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);

564
src/serialization_wrappers.rs
View File

@ -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<T, S>(object: &T, serializer: S) -> Result<S::Ok, S::Error>
where
T: rustc_serialize::Encodable,
S: Serializer,
{
let v = encode(&object, Infinite).unwrap();
serializer.serialize_bytes(&v)
}
pub fn serialize_generic_encodable_option<T, S>(optional_object: &Option<T>, serializer: S) -> Result<S::Ok, S::Error>
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<S>(optional_object: &Option<[u8; 64]>, serializer: S) -> Result<S::Ok, S::Error>
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<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>
{
let mut bytes = Vec::new();
loop {
let tmp = seq.next_element::<u8>();
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<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>
{
let mut bytes = Vec::new();
loop {
let tmp = seq.next_element::<u8>();
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<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>
{
let mut bytes = Vec::new();
loop {
let tmp = seq.next_element::<u8>();
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<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>
{
let mut bytes = Vec::new();
loop {
let tmp = seq.next_element::<u8>();
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<Fr>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of bytes representing an optional Fr")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>
{
let mut bytes = Vec::new();
loop {
let tmp = seq.next_element::<u8>();
if let Ok(Some(b)) = tmp {
bytes.push(b)
} else {
break;
}
}
Ok(Some(decode(&bytes[..]).unwrap()))
}
fn visit_none<E>(self) -> Result<Self::Value, E>
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<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error>
{
let mut array: [u8; 64] = [00; 64];
for i in 0..64 {
let tmp = seq.next_element::<u8>();
}
Ok(Some(array))
}
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: Error,
{
Ok(None)
}
}
pub fn deserialize_g_one<'de, D>(deserializer: D) -> Result<G1, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(GOneVisitor);
Ok(a.unwrap())
}
pub fn deserialize_g_two<'de, D>(deserializer: D) -> Result<G2, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(GTwoVisitor);
Ok(a.unwrap())
}
pub fn deserialize_g_t<'de, D>(deserializer: D) -> Result<Gt, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(GTargetVisitor);
Ok(a.unwrap())
}
pub fn deserialize_fr<'de, D>(deserializer: D) -> Result<Fr, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(FieldVisitor);
Ok(a.unwrap())
}
pub fn deserialize_optional_fr<'de, D>(deserializer: D) -> Result<Option<Fr>, 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<Option<[u8; 64]>, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_option(OptionalByteArrayVisitor);
Ok(a.unwrap())
}
pub fn serialize_generic_encodable_vec<T, S>(object: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error>
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<G1>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of byte encodings of G1")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
let mut vec = Vec::new();
loop {
let tmp = seq.next_element::<Vec<u8>>();
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<G2>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of byte encodings of Vec G2")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
let mut vec = Vec::new();
loop {
let tmp = seq.next_element::<Vec<u8>>();
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<Gt>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of byte encodings of Vec Gt")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
let mut vec = Vec::new();
loop {
let tmp = seq.next_element::<Vec<u8>>();
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<Fr>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("Sequence of byte encodings of Fr")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
let mut vec = Vec::new();
loop {
let tmp = seq.next_element::<Vec<u8>>();
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<Vec<G1>, 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<Vec<G2>, 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<Vec<Gt>, 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<Vec<Fr>, 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<Fr>
#[derive(Serialize, Deserialize)]
pub struct VecFrWrapper( #[serde(serialize_with = "serialize_generic_encodable_vec", deserialize_with = "deserialize_fr_vec")] pub Vec<Fr>);
// Wrapper class for Vec<G2>
#[derive(Serialize, Deserialize)]
pub struct VecG2Wrapper( #[serde(serialize_with = "serialize_generic_encodable_vec", deserialize_with = "deserialize_g_two_vec")] pub Vec<G2>);
// 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<S>(bp_gens: &bulletproofs::BulletproofGens, serializer: S) -> Result<S::Ok, S::Error>
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<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
let mut g_capacity: usize = 0;
let mut p_capacity: usize = 0;
let tmp = seq.next_element::<usize>();
if let Ok(Some(b)) = tmp {
g_capacity = b;
}
let tmp = seq.next_element::<usize>();
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<bulletproofs::BulletproofGens, D::Error>
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<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
// the bytes representing the rangeproof
let tmp = seq.next_element::<Vec<u8>>();
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::<Vec<u8>>();
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<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
let mut point_bytes = Vec::new();
loop {
let tmp = seq.next_element::<u8>();
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<curve25519_dalek::ristretto::RistrettoPoint, D::Error>
where
D: Deserializer<'de>
{
let a = deserializer.deserialize_seq(RPointVisitor);
Ok(a.unwrap())
}

12
src/wallet.rs
View File

@ -10,7 +10,7 @@ use std::fmt;
#[serde(bound(serialize = "<E as ff::ScalarEngine>::Fr: serde::Serialize"))]
#[serde(bound(deserialize = "<E as ff::ScalarEngine>::Fr: serde::Deserialize<'de>"))]
pub struct Wallet<E: Engine> {
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<E: Engine> {
impl<E: Engine> Wallet<E> {
pub fn as_fr_vec(&self) -> Vec<E::Fr> {
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<E::Fr> {
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<E::Fr> {
@ -41,9 +41,9 @@ impl<E: Engine> fmt::Display for Wallet<E> {
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)
}
}
}