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

Cleaning up warnings in addition to establish interface and c/py/go bindings

This commit is contained in:
J. Ayo Akinyele 2019-09-16 11:58:10 -04:00
parent 55ae89ccda
commit 8672fdb40b
11 changed files with 47 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/bolt_test.rs
View File

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

12
go/libbolt.go
View File

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

4
go/libbolt_test.go
View File

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

4
include/libbolt.h
View File

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

18
py/libbolt.py
View File

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

21
py/libbolt_tests.py
View File

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

11
src/channels.rs
View File

@ -142,6 +142,7 @@ impl<E: Engine> ChannelToken<E> {
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 = "<E as ff::ScalarEngine>::Fr: serde::Serialize, \
@ -234,7 +235,7 @@ pub struct CustomerState<E: Engine> {
}
impl<E: Engine> CustomerState<E> {
pub fn new<R: Rng>(csprng: &mut R, channel: &ChannelState<E>, channel_token: &mut ChannelToken<E>, cust_bal: i32, merch_bal: i32, name: String) -> Self {
pub fn new<R: Rng>(csprng: &mut R, channel_token: &mut ChannelToken<E>, cust_bal: i32, merch_bal: i32, name: String) -> Self {
let mut kp = secp256k1::Secp256k1::new();
kp.randomize(csprng);
@ -436,7 +437,7 @@ impl<E: Engine> CustomerState<E> {
impl<E: Engine> fmt::Display for CustomerState<E> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut content = String::new();
content = format!("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 = "<E as ff::ScalarEngine>::Fr: serde::Serialize, \
@ -481,6 +482,7 @@ pub struct ChannelcloseM {
<E as pairing::Engine>::G2: serde::Deserialize<'de>"
))]
pub struct MerchantState<E: Engine> {
id: String,
keypair: cl::BlindKeyPair<E>,
nizkParams: NIZKSecretParams<E>,
pk: secp256k1::PublicKey,
@ -504,6 +506,7 @@ impl<E: Engine> MerchantState<E> {
ch.cp = Some(ChannelParams::<E> { pub_params: nizkParams.pubParams.clone(), l, extra_verify: true });
(MerchantState {
id: id.clone(),
keypair: nizkParams.keypair.clone(),
nizkParams: nizkParams.clone(),
pk: wpk,

4
src/cl.rs
View File

@ -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<E: Engine> {
impl<E: Engine> SecretKey<E> {
pub fn generate<R: Rng>(csprng: &mut R, l: usize) -> Self {
let mut y: Vec<E::Fr> = Vec::new();
for i in 0..l {
for _i in 0..l {
let _y = E::Fr::rand(csprng);
y.push(_y);
}

20
src/ffishim.rs
View File

@ -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<secp256k1::PublicKey> = 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::<Bls12>::new(name.to_string(), tps);
let mut rng = &mut rand::thread_rng();
let channel_state = bidirectional::ChannelState::<Bls12>::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<bidirectional::ChannelState<Bls12>> = 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<bidirectional::ChannelState<Bls12>> = deserialize_result_object(ser_channel_state);
let channel_state = handle_errors!(channel_state_result);
// Deserialize the channel token
let channel_token_result: ResultSerdeType<bidirectional::ChannelToken<Bls12>> = 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()

13
src/lib.rs
View File

@ -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<E>,
channel_token: &mut ChannelToken<E>,
pub fn init_customer<'a, R: Rng, E: Engine>(csprng: &mut R, channel_token: &mut ChannelToken<E>,
b0_cust: i32, b0_merch: i32, name: &'a str) -> CustomerState<E> {
assert!(b0_cust >= 0);
assert!(b0_merch >= 0);
let cust_name = String::from(name);
return CustomerState::<E>::new(csprng, channel_state, channel_token, b0_cust, b0_merch, cust_name);
return CustomerState::<E>::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();

2
src/util.rs
View File

@ -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<E: Engine>(a: &Vec<E::Fr>, b: &Vec<E::Fr>) -> bool {
(a.len() == b.len()) &&