diff --git a/examples/bolt_test.rs b/examples/bolt_test.rs index 2349bf4..9c3b557 100644 --- a/examples/bolt_test.rs +++ b/examples/bolt_test.rs @@ -58,7 +58,7 @@ fn main() { let (mut channel_token, mut merch_state, mut channel_state) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant Bob"); - let mut cust_state = bidirectional::init_customer(rng, &mut channel_state, &mut channel_token, b0_customer, b0_merchant, "Alice"); + let mut cust_state = bidirectional::init_customer(rng, &mut channel_token, b0_customer, b0_merchant, "Alice"); println!("{}", cust_state); diff --git a/go/libbolt.go b/go/libbolt.go index 64c794b..c9ff0e6 100644 --- a/go/libbolt.go +++ b/go/libbolt.go @@ -163,12 +163,12 @@ func BidirectionalChannelSetup(name string, channelSupport bool) (ChannelState, return channelState, err } -func BidirectionalInitMerchant(channelState ChannelState, balanceMerchant int, nameMerchant string) (ChannelToken, MerchState, ChannelState, error) { +func BidirectionalInitMerchant(channelState ChannelState, nameMerchant string) (ChannelToken, MerchState, ChannelState, error) { serChannelState, err := json.Marshal(channelState) if err != nil { return ChannelToken{}, MerchState{}, ChannelState{}, err } - resp := C.GoString(C.ffishim_bidirectional_init_merchant(C.CString(string(serChannelState)), C.int(balanceMerchant), C.CString(nameMerchant))) + resp := C.GoString(C.ffishim_bidirectional_init_merchant(C.CString(string(serChannelState)), C.CString(nameMerchant))) r, err := processCResponse(resp) if err != nil { return ChannelToken{}, MerchState{}, ChannelState{}, err @@ -187,16 +187,12 @@ func BidirectionalInitMerchant(channelState ChannelState, balanceMerchant int, n return channelToken, merchState, channelState, err } -func BidirectionalInitCustomer(channelState ChannelState, channelToken ChannelToken, balanceCustomer int, balanceMerchant int, nameCustomer string) (ChannelToken, CustState, error) { - serChannelState, err := json.Marshal(channelState) - if err != nil { - return ChannelToken{}, CustState{}, err - } +func BidirectionalInitCustomer(channelToken ChannelToken, balanceCustomer int, balanceMerchant int, nameCustomer string) (ChannelToken, CustState, error) { serChannelToken, err := json.Marshal(channelToken) if err != nil { return ChannelToken{}, CustState{}, err } - resp := C.GoString(C.ffishim_bidirectional_init_customer(C.CString(string(serChannelState)), C.CString(string(serChannelToken)), C.int(balanceCustomer), C.int(balanceMerchant), C.CString(nameCustomer))) + resp := C.GoString(C.ffishim_bidirectional_init_customer(C.CString(string(serChannelToken)), C.int(balanceCustomer), C.int(balanceMerchant), C.CString(nameCustomer))) r, err := processCResponse(resp) if err != nil { return ChannelToken{}, CustState{}, err diff --git a/go/libbolt_test.go b/go/libbolt_test.go index 86dc35d..6196a4d 100644 --- a/go/libbolt_test.go +++ b/go/libbolt_test.go @@ -19,11 +19,11 @@ func setup(b0Cust int, b0Merch int) (ChannelState, ChannelToken, MerchState, Cus if err != nil { return ChannelState{}, ChannelToken{}, MerchState{}, CustState{}, err } - channelToken, merchState, channelState, err := BidirectionalInitMerchant(channelState, b0Merch, "Bob") + channelToken, merchState, channelState, err := BidirectionalInitMerchant(channelState, "Bob") if err != nil { return ChannelState{}, ChannelToken{}, MerchState{}, CustState{}, err } - channelToken, custState, err := BidirectionalInitCustomer(channelState, channelToken, b0Cust, b0Merch, "Alice") + channelToken, custState, err := BidirectionalInitCustomer(channelToken, b0Cust, b0Merch, "Alice") return channelState, channelToken, merchState, custState, err } diff --git a/include/libbolt.h b/include/libbolt.h index 306634b..ccf6316 100644 --- a/include/libbolt.h +++ b/include/libbolt.h @@ -17,8 +17,8 @@ extern "C" { // channel init char* ffishim_bidirectional_channel_setup(const char *channel_name, unsigned int third_party_support); -char* ffishim_bidirectional_init_merchant(const char *ser_channel_state, int balance, const char *name_ptr); -char* ffishim_bidirectional_init_customer(const char *ser_channel_state, const char *ser_channel_token, int balance_customer, int balance_merchant, const char *name_ptr); +char* ffishim_bidirectional_init_merchant(const char *ser_channel_state, const char *name_ptr); +char* ffishim_bidirectional_init_customer(const char *ser_channel_token, int balance_customer, int balance_merchant, const char *name_ptr); // channel establish protocol routines char* ffishim_bidirectional_establish_customer_generate_proof(const char *ser_channel_token, const char *ser_customer_wallet); diff --git a/py/libbolt.py b/py/libbolt.py index 8c24e47..39c744e 100644 --- a/py/libbolt.py +++ b/py/libbolt.py @@ -8,7 +8,7 @@ import ast import json class Libbolt(object): - """docstring for Libbolt C API""" + """Libbolt Py/C low-level API""" def __init__(self, path): self.lib = cdll.LoadLibrary(path) @@ -20,10 +20,10 @@ class Libbolt(object): # ESTABLISH PROTOCOL - self.lib.ffishim_bidirectional_init_merchant.argtypes = (c_void_p, ctypes.c_int32, c_void_p) + self.lib.ffishim_bidirectional_init_merchant.argtypes = (c_void_p, c_void_p) self.lib.ffishim_bidirectional_init_merchant.restype = c_void_p - self.lib.ffishim_bidirectional_init_customer.argtypes = (c_void_p, c_void_p, ctypes.c_int32, ctypes.c_int32, c_void_p) + self.lib.ffishim_bidirectional_init_customer.argtypes = (c_void_p, ctypes.c_int32, ctypes.c_int32, c_void_p) self.lib.ffishim_bidirectional_init_customer.restype = c_void_p self.lib.ffishim_bidirectional_establish_customer_generate_proof.argtypes = (c_void_p, c_void_p) @@ -83,13 +83,13 @@ class Libbolt(object): # INIT PROTOCOL - def bidirectional_init_merchant(self, channel_state, b0_merch, name): - output_string = self.lib.ffishim_bidirectional_init_merchant(channel_state.encode(), b0_merch, name.encode()) + def bidirectional_init_merchant(self, channel_state, name): + output_string = self.lib.ffishim_bidirectional_init_merchant(channel_state.encode(), name.encode()) 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('merch_state'), output_dictionary.get('channel_state') - def bidirectional_init_customer(self, channel_state, channel_token, b0_cust, b0_merch, name): - output_string = self.lib.ffishim_bidirectional_init_customer(channel_state.encode(), channel_token.encode(), b0_cust, b0_merch, name.encode()) + def bidirectional_init_customer(self, channel_token, b0_cust, b0_merch, name): + output_string = self.lib.ffishim_bidirectional_init_customer(channel_token.encode(), b0_cust, b0_merch, name.encode()) 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')) @@ -229,12 +229,12 @@ def run_unit_test(): print("channel state new: ", len(channel_state)) - (channel_token, merch_state, channel_state) = libbolt.bidirectional_init_merchant(channel_state, b0_merch, "Bob") + (channel_token, merch_state, channel_state) = libbolt.bidirectional_init_merchant(channel_state, "Bob") print("merch_state: ", len(merch_state)) #print("channel_token: ", type(_channel_token)) - (channel_token, cust_state) = libbolt.bidirectional_init_customer(channel_state, channel_token, b0_cust, b0_merch, "Alice") + (channel_token, cust_state) = libbolt.bidirectional_init_customer(channel_token, b0_cust, b0_merch, "Alice") print("cust_state: ", len(cust_state)) (channel_token, cust_state, com, com_proof) = libbolt.bidirectional_establish_customer_generate_proof(channel_token, cust_state) diff --git a/py/libbolt_tests.py b/py/libbolt_tests.py index a61f4c1..73bab5e 100644 --- a/py/libbolt_tests.py +++ b/py/libbolt_tests.py @@ -28,14 +28,12 @@ class BoltEstablishTests(unittest.TestCase): self.channel_state = self.bolt.channel_setup("Test Channel") self.b0_cust = 1000 self.b0_merch = 100 - (self.channel_token, self.merch_state, self.channel_state) = self.bolt.bidirectional_init_merchant(self.channel_state, self.b0_merch, "Bob") - (channel_token, self.cust_state) = self.bolt.bidirectional_init_customer(self.channel_state, self.channel_token, - self.b0_cust, self.b0_merch, "Alice") + (self.channel_token, self.merch_state, self.channel_state) = self.bolt.bidirectional_init_merchant(self.channel_state, "Bob") + (channel_token, self.cust_state) = self.bolt.bidirectional_init_customer(self.channel_token, self.b0_cust, self.b0_merch, "Alice") # generate some bad stuff here larger_b0_cust = 2000 - (channel_token_bad, self.cust_state_bad) = self.bolt.bidirectional_init_customer(self.channel_state, self.channel_token, - larger_b0_cust, self.b0_merch, "Alice") + (channel_token_bad, self.cust_state_bad) = self.bolt.bidirectional_init_customer(self.channel_token, larger_b0_cust, self.b0_merch, "Alice") # set them self.channel_token = channel_token @@ -152,9 +150,8 @@ class BoltPayTests(unittest.TestCase): self.channel_state = self.bolt.channel_setup("Test Channel") self.b0_cust = 500 self.b0_merch = 10 - (self.channel_token, self.merch_state, self.channel_state) = self.bolt.bidirectional_init_merchant(self.channel_state, self.b0_merch, "Bob") - (self.channel_token, self.cust_state) = self.bolt.bidirectional_init_customer(self.channel_state, self.channel_token, - self.b0_cust, self.b0_merch, "Alice") + (self.channel_token, self.merch_state, self.channel_state) = self.bolt.bidirectional_init_merchant(self.channel_state, "Bob") + (self.channel_token, self.cust_state) = self.bolt.bidirectional_init_customer(self.channel_token, self.b0_cust, self.b0_merch, "Alice") (self.channel_token, self.cust_state, com, com_proof) = self.bolt.bidirectional_establish_customer_generate_proof(self.channel_token, self.cust_state) @@ -259,13 +256,11 @@ class BoltMultiChannelTests(unittest.TestCase): self.channel_state = self.bolt.channel_setup("Test Channel") self.b0_alice = self.b0_charlie = 150 self.b0_merch = 5 - (self.channel_token, self.merch_state, self.channel_state) = self.bolt.bidirectional_init_merchant(self.channel_state, self.b0_merch, "Bob") + (self.channel_token, self.merch_state, self.channel_state) = self.bolt.bidirectional_init_merchant(self.channel_state, "Bob") - (self.channel_token_a, self.alice_state) = self.bolt.bidirectional_init_customer(self.channel_state, self.channel_token, - self.b0_alice, self.b0_merch, "Alice") + (self.channel_token_a, self.alice_state) = self.bolt.bidirectional_init_customer(self.channel_token, self.b0_alice, self.b0_merch, "Alice") - (self.channel_token_c, self.charlie_state) = self.bolt.bidirectional_init_customer(self.channel_state, self.channel_token, - self.b0_charlie, self.b0_merch, "Charlie") + (self.channel_token_c, self.charlie_state) = self.bolt.bidirectional_init_customer(self.channel_token, self.b0_charlie, self.b0_merch, "Charlie") def _establish_channel(self, channel_token, channel_state, cust_state, pkc, b0_cust, b0_merch): (channel_token, cust_state, com, com_proof) = self.bolt.bidirectional_establish_customer_generate_proof(channel_token, cust_state) diff --git a/src/channels.rs b/src/channels.rs index d6fa16d..505dc6f 100644 --- a/src/channels.rs +++ b/src/channels.rs @@ -142,6 +142,7 @@ impl ChannelToken { input.extend_from_slice(&ser_pk_m); input.extend(&ser_cl_pk_m); input.extend(&ser_mpk); + input.extend(&ser_comParams); return hash_to_slice(&input); } @@ -199,7 +200,7 @@ struct WalletKeyPair { } /// -/// Customer wallet consists of a keypair (NEW) +/// Customer state /// #[derive(Clone, Serialize, Deserialize)] #[serde(bound(serialize = "::Fr: serde::Serialize, \ @@ -234,7 +235,7 @@ pub struct CustomerState { } impl CustomerState { - pub fn new(csprng: &mut R, channel: &ChannelState, channel_token: &mut ChannelToken, cust_bal: i32, merch_bal: i32, name: String) -> Self { + pub fn new(csprng: &mut R, channel_token: &mut ChannelToken, cust_bal: i32, merch_bal: i32, name: String) -> Self { let mut kp = secp256k1::Secp256k1::new(); kp.randomize(csprng); @@ -436,7 +437,7 @@ impl CustomerState { impl fmt::Display for CustomerState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let mut content = String::new(); - content = format!("name = {}\n", &self.name); + content = format!("id = {}\n", &self.name); content = format!("{}pk = {}\n", content, &self.pk_c); content = format!("{}sk = {}\n", content, &self.sk_c); content = format!("{}cust-bal = {}\n", content, &self.cust_balance); @@ -469,7 +470,7 @@ pub struct ChannelcloseM { } /// -/// Merchant wallet (NEW) +/// Merchant State /// #[derive(Clone, Serialize, Deserialize)] #[serde(bound(serialize = "::Fr: serde::Serialize, \ @@ -481,6 +482,7 @@ pub struct ChannelcloseM { ::G2: serde::Deserialize<'de>" ))] pub struct MerchantState { + id: String, keypair: cl::BlindKeyPair, nizkParams: NIZKSecretParams, pk: secp256k1::PublicKey, @@ -504,6 +506,7 @@ impl MerchantState { ch.cp = Some(ChannelParams:: { pub_params: nizkParams.pubParams.clone(), l, extra_verify: true }); (MerchantState { + id: id.clone(), keypair: nizkParams.keypair.clone(), nizkParams: nizkParams.clone(), pk: wpk, diff --git a/src/cl.rs b/src/cl.rs index 6ce5e94..7e8a37a 100644 --- a/src/cl.rs +++ b/src/cl.rs @@ -4,7 +4,7 @@ extern crate pairing; extern crate rand; use super::*; -use pairing::{CurveAffine, CurveProjective, Engine}; +use pairing::{CurveProjective, Engine}; use ff::{PrimeField, ScalarEngine}; use rand::Rng; use ped92::{Commitment, CSMultiParams}; @@ -174,7 +174,7 @@ pub struct SignatureProof { impl SecretKey { pub fn generate(csprng: &mut R, l: usize) -> Self { let mut y: Vec = Vec::new(); - for i in 0..l { + for _i in 0..l { let _y = E::Fr::rand(csprng); y.push(_y); } diff --git a/src/ffishim.rs b/src/ffishim.rs index c0f18bf..53144e0 100644 --- a/src/ffishim.rs +++ b/src/ffishim.rs @@ -4,7 +4,7 @@ pub mod ffishim { use bidirectional; use ff::Rand; - use pairing::bls12_381::{Bls12, Fr}; + use pairing::bls12_381::{Bls12}; use serde::Deserialize; @@ -12,7 +12,6 @@ pub mod ffishim { use std::ffi::{CStr, CString}; use std::str; use channels::{ChannelcloseM, ResultBoltType, BoltError}; - use std::alloc::handle_alloc_error; use util::hash_pubkey_to_fr; use std::str::FromStr; @@ -76,7 +75,7 @@ pub mod ffishim { #[no_mangle] pub extern fn ffishim_bidirectional_wtp_check_wpk(ser_wpk: *mut c_char) -> *mut c_char { let wpk_result: ResultSerdeType = deserialize_result_object(ser_wpk); - let wpk = handle_errors!(wpk_result); + let _wpk = handle_errors!(wpk_result); let res = true; let ser = ["{\'result\':\'", serde_json::to_string(&res).unwrap().as_str(), "\'}"].concat(); @@ -94,8 +93,7 @@ pub mod ffishim { if third_party_support > 1 { tps = true; } - let mut channel_state = bidirectional::ChannelState::::new(name.to_string(), tps); - let mut rng = &mut rand::thread_rng(); + let channel_state = bidirectional::ChannelState::::new(name.to_string(), tps); let ser = ["{\'channel_state\':\'", serde_json::to_string(&channel_state).unwrap().as_str(), "\'}"].concat(); let cser = CString::new(ser).unwrap(); @@ -105,7 +103,7 @@ pub mod ffishim { // INIT #[no_mangle] - pub extern fn ffishim_bidirectional_init_merchant(ser_channel_state: *mut c_char, balance: i32, name_ptr: *const c_char) -> *mut c_char { + pub extern fn ffishim_bidirectional_init_merchant(ser_channel_state: *mut c_char, name_ptr: *const c_char) -> *mut c_char { let rng = &mut rand::thread_rng(); let channel_state_result: ResultSerdeType> = deserialize_result_object(ser_channel_state); let mut channel_state = handle_errors!(channel_state_result); @@ -113,7 +111,7 @@ pub mod ffishim { let bytes = unsafe { CStr::from_ptr(name_ptr).to_bytes() }; let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8 - let (channel_token, mut merch_state, mut channel_state) = bidirectional::init_merchant(rng, &mut channel_state, name); + let (channel_token, merch_state, channel_state) = bidirectional::init_merchant(rng, &mut channel_state, name); let ser = ["{\'channel_token\':\'", serde_json::to_string(&channel_token).unwrap().as_str(), "\', \'merch_state\':\'", serde_json::to_string(&merch_state).unwrap().as_str() ,"\', \'channel_state\':\'", serde_json::to_string(&channel_state).unwrap().as_str() ,"\'}"].concat(); @@ -122,12 +120,8 @@ pub mod ffishim { } #[no_mangle] - pub extern fn ffishim_bidirectional_init_customer(ser_channel_state: *mut c_char, ser_channel_token: *mut c_char, balance_customer: i32, balance_merchant: i32, name_ptr: *const c_char) -> *mut c_char { + pub extern fn ffishim_bidirectional_init_customer(ser_channel_token: *mut c_char, balance_customer: i32, balance_merchant: i32, name_ptr: *const 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); - let channel_state = handle_errors!(channel_state_result); - // Deserialize the channel token let channel_token_result: ResultSerdeType> = deserialize_result_object(ser_channel_token); let mut channel_token = handle_errors!(channel_token_result); @@ -137,7 +131,7 @@ pub mod ffishim { let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8 // We change the channel state - let cust_state = bidirectional::init_customer(rng, &channel_state, &mut channel_token, balance_customer, balance_merchant, name); + let cust_state = bidirectional::init_customer(rng, &mut channel_token, balance_customer, balance_merchant, name); let ser = ["{\'cust_state\':\'", serde_json::to_string(&cust_state).unwrap().as_str(), "\', \'channel_token\':\'", serde_json::to_string(&channel_token).unwrap().as_str() ,"\'}"].concat(); let cser = CString::new(ser).unwrap(); cser.into_raw() diff --git a/src/lib.rs b/src/lib.rs index a8c9028..059dab6 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -116,7 +116,6 @@ pub mod bidirectional { use util; use wallet; use pairing::Engine; - use pairing::bls12_381::Bls12; use sodiumoxide; use cl; // for blind signature @@ -127,7 +126,6 @@ pub mod bidirectional { use sha2::Sha512; use serde::{Serialize, Deserialize}; - use std::sync::mpsc::channel; use util::{RevokedMessage, hash_to_slice}; pub use ped92::Commitment; pub use cl::{PublicKey, Signature}; @@ -197,14 +195,13 @@ pub mod bidirectional { /// and initial balance for customer and merchant. Generate initial customer channel token, /// and wallet commitment. /// - pub fn init_customer<'a, R: Rng, E: Engine>(csprng: &mut R, channel_state: &ChannelState, - channel_token: &mut ChannelToken, + pub fn init_customer<'a, R: Rng, E: Engine>(csprng: &mut R, channel_token: &mut ChannelToken, b0_cust: i32, b0_merch: i32, name: &'a str) -> CustomerState { assert!(b0_cust >= 0); assert!(b0_merch >= 0); let cust_name = String::from(name); - return CustomerState::::new(csprng, channel_state, channel_token, b0_cust, b0_merch, cust_name); + return CustomerState::::new(csprng, channel_token, b0_cust, b0_merch, cust_name); } /// @@ -546,7 +543,7 @@ mod tests { let (mut channel_token, mut merch_state, mut channel_state) = bidirectional::init_merchant(rng, channel_state, merch_name); // initialize on the customer side with balance: b0_cust - let cust_state = bidirectional::init_customer(rng, &channel_state, &mut channel_token, b0_cust, b0_merch, cust_name); + let cust_state = bidirectional::init_customer(rng, &mut channel_token, b0_cust, b0_merch, cust_name); return (channel_token, merch_state, cust_state, channel_state); } @@ -615,7 +612,7 @@ mod tests { let (mut channel_token, mut merch_state, mut channel_state) = bidirectional::init_merchant(rng, &mut channel_state, "Merchant Bob"); - let mut cust_state = bidirectional::init_customer(rng, &mut channel_state, &mut channel_token, b0_customer, b0_merchant, "Alice"); + let mut cust_state = bidirectional::init_customer(rng, &mut channel_token, b0_customer, b0_merchant, "Alice"); println!("{}", cust_state); @@ -926,7 +923,7 @@ mod tests { let b0_cust = 100; let b0_merch = 10; - let cust_state = bidirectional::init_customer(rng, &channel_state, &mut channel_token, b0_cust, b0_merch, "Customer A"); + let cust_state = bidirectional::init_customer(rng, &mut channel_token, b0_cust, b0_merch, "Customer A"); let serlalized_ct = serde_json::to_string(&channel_token).unwrap(); diff --git a/src/util.rs b/src/util.rs index d7a9d3b..e9d3fc9 100644 --- a/src/util.rs +++ b/src/util.rs @@ -3,9 +3,7 @@ use sodiumoxide::crypto::hash::sha512; use pairing::Engine; use ff::{PrimeField}; use rand::Rng; -use ped92::CSMultiParams; use secp256k1::{Signature, PublicKey}; -use cl::Signature as clSignature; pub fn is_vec_fr_equal(a: &Vec, b: &Vec) -> bool { (a.len() == b.len()) &&