channelid: clean up serialization libraries
This commit is contained in:
parent
8804884979
commit
8b6a520c99
|
@ -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"]
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
|
@ -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> {
|
||||
|
|
|
@ -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
15
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<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
48
src/nizk.rs
|
@ -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));
|
||||
}
|
||||
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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())
|
||||
}
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue