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

adding a bunch more ffishim functions. Functionality is incomplete, but everything is properly serializing. Lots of TODOs left

This commit is contained in:
Gabe Kaptchuk 2019-02-26 14:52:47 -05:00
parent 4ff930fdf8
commit b816027e64
4 changed files with 490 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.toml
View File

@ -34,6 +34,5 @@ default-features = false
features = ["rustc-serialize"]
[lib]
name = "libboltlib"
crate-type = ["lib", "cdylib"]

359
src/lib.rs
View File

@ -308,11 +308,12 @@ fn convert_int_to_fr(value: i32) -> Fr {
}
// refund message
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct RefundMessage {
pub msgtype: String, // purpose type of message
pub wpk: secp256k1::PublicKey,
pub balance: usize, // the balance
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable_option", deserialize_with = "serialization_wrappers::deserialize_optional_fr")]
pub r: Option<Fr>, // randomness from customer wallet
pub rt: Option<clsigs::SignatureD> // refund token
}
@ -356,10 +357,11 @@ impl RefundMessage {
}
}
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct RevokedMessage {
pub msgtype: String,
pub wpk: secp256k1::PublicKey,
#[serde(serialize_with = "serialization_wrappers::serialize_fixed_byte_array_option", deserialize_with = "serialization_wrappers::deserialize_optional_fixed_64_byte_array")]
pub sig: Option<[u8; 64]> // represents revocation token serialized compact bytes
}
@ -619,6 +621,7 @@ pub mod bidirectional {
}
}
// TODO DELETE THHIS TEST STRUCT
#[derive(Serialize, Deserialize)]
pub struct TestPublicParams {
pub cl_mpk: clsigs::PublicParams,
@ -748,48 +751,52 @@ pub mod bidirectional {
}
}
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct ChannelclosureC {
pub message: RefundMessage,
signature: clsigs::SignatureD
}
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct ChannelclosureM {
message: RevokedMessage,
signature: clsigs::SignatureD
}
// proof of valid balance
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct ProofVB {
range_proof: (bulletproofs::RangeProof, curve25519_dalek::ristretto::CompressedRistretto),
value_commitment: RistrettoPoint
}
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct BalanceProof {
third_party: bool,
balance_increment: i32,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_two")]
w_com_pr_pr: G2,
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_two")]
old_bal_com: G2,
vcom: Option<commit_scheme::Commitment>,
proof_vcom: Option<clproto::ProofCV>,
proof_vrange: Option<ProofVB>
}
#[derive(Clone)]
#[derive(Clone, Serialize, Deserialize)]
pub struct PaymentProof {
proof2a: clproto::ProofCV, // PoK of committed values in new wallet
//proof2b: clproto::ProofCV, // PoK of committed values in old wallet (minus wpk)
proof2c: clproto::ProofVS, // PoK of old wallet signature (that includes wpk)
proof3: ProofVB, // range proof that balance - balance_inc is between (0, val_max)
#[serde(serialize_with = "serialization_wrappers::serialize_generic_encodable", deserialize_with = "serialization_wrappers::deserialize_g_two")]
old_com_base: G2,
wpk: secp256k1::PublicKey, // verification key for old wallet
wallet_sig: clsigs::SignatureD, // blinded signature for old wallet
pub bal_proof: BalanceProof
}
#[derive(Serialize, Deserialize)]
pub struct RevokeToken {
message: RevokedMessage,
pub signature: secp256k1::Signature
@ -1501,6 +1508,14 @@ pub mod ffishim {
use std::str;
use std::mem;
#[no_mangle]
pub extern fn ffishim_free_string(pointer: *mut c_char) {
unsafe{
if pointer.is_null() { return }
CString::from_raw(pointer)
};
}
#[no_mangle]
pub extern fn ffishim_bidirectional_setup(extra_verify: u32) -> *mut c_char {
let mut ev = false;
@ -1509,7 +1524,6 @@ pub mod ffishim {
}
let pp = bidirectional::setup(ev);
let ser = serde_json::to_string(&pp).unwrap();
// println!("ser = {:?}", ser);
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
@ -1519,18 +1533,19 @@ pub mod ffishim {
let bytes = unsafe { CStr::from_ptr(channel_name).to_bytes() };
let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8
println!("channel_name = {:?}", name);
let mut tps = false;
if third_party_support > 1 {
tps = true;
}
let channel = bidirectional::ChannelState::new(name.to_string(), tps);
let ser = serde_json::to_string(&channel).unwrap();
println!("ser = {:?}", ser);
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
// TODO GET RID OF THESE TEST THINGS
#[no_mangle]
pub extern fn ffishim_bidirectional_teststruct() -> *mut c_char {
@ -1542,17 +1557,26 @@ pub mod ffishim {
};
let ser = serde_json::to_string(&test).unwrap();
// println!("ser = {:?}", ser);
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_teststruct_in(serialized_pp: *mut c_char) -> *mut c_char {
pub extern fn ffishim_bidirectional_teststruct_in(mut serialized_pp: *mut c_char) -> usize {
let bytes = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8
let object: bidirectional::TestPublicParams = serde_json::from_str(&name).unwrap();
serialized_pp
let mut object: bidirectional::TestPublicParams = serde_json::from_str(&name).unwrap();
let test = bidirectional::TestPublicParams {
cl_mpk: clsigs::setup_d(),
range_proof_bits: 3
};
let ser = serde_json::to_string(&test).unwrap();
let cser = CString::new(ser).unwrap();
unsafe { serialized_pp = cser.into_raw(); }
5
}
#[no_mangle]
@ -1560,15 +1584,12 @@ pub mod ffishim {
let bytes = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name: &str = str::from_utf8(bytes).unwrap(); // make sure the bytes are UTF-8
// println!("ser_in = {:?}", &name);
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name).unwrap();
let keypair = bidirectional::keygen(&deserialized_pp);
let ser = serde_json::to_string(&keypair).unwrap();
// println!("ser = {:?}", &ser);
let cser = CString::new(ser).unwrap();
// println!("ser = {:?}", &cser);
cser.into_raw()
}
@ -1611,14 +1632,14 @@ pub mod ffishim {
}
#[no_mangle]
pub extern fn ffishim_bidirectional_init_customer(serialized_pp: *mut c_char, serializd_channel: *mut c_char, balance_customer: i32, balance_merchant: i32, serialized_commitment_setup: *mut c_char, serialized_customer_keypair: *mut c_char) -> *mut c_char {
pub extern fn ffishim_bidirectional_init_customer(serialized_pp: *mut c_char, serialized_channel: *mut c_char, balance_customer: i32, balance_merchant: i32, serialized_commitment_setup: *mut c_char, serialized_customer_keypair: *mut c_char) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the channel token
let bytes_channel = unsafe { CStr::from_ptr(serializd_channel).to_bytes() };
// Deserialize the channel state
let bytes_channel = unsafe { CStr::from_ptr(serialized_channel).to_bytes() };
let name_channel: &str = str::from_utf8(bytes_channel).unwrap(); // make sure the bytes are UTF-8
let mut deserialized_channel_state: bidirectional::ChannelState = serde_json::from_str(&name_channel).unwrap();
@ -1663,14 +1684,14 @@ pub mod ffishim {
}
#[no_mangle]
pub extern fn ffishim_bidirectional_establish_merchant_phase2(serialized_pp: *mut c_char, serializd_channel: *mut c_char, serialized_merchant_data: *mut c_char, serialized_proof1: *mut c_char) -> *mut c_char {
pub extern fn ffishim_bidirectional_establish_merchant_phase2(serialized_pp: *mut c_char, serialized_channel: *mut c_char, serialized_merchant_data: *mut c_char, serialized_proof1: *mut c_char) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the channel token
let bytes_channel = unsafe { CStr::from_ptr(serializd_channel).to_bytes() };
// Deserialize the channel state
let bytes_channel = unsafe { CStr::from_ptr(serialized_channel).to_bytes() };
let name_channel: &str = str::from_utf8(bytes_channel).unwrap(); // make sure the bytes are UTF-8
let mut deserialized_channel_state: bidirectional::ChannelState = serde_json::from_str(&name_channel).unwrap();
@ -1714,6 +1735,298 @@ pub mod ffishim {
bidirectional::establish_customer_final(&deserialized_pp, &deserialized_merchant_keypair.pk, &mut deserialized_customer_data.csk, deserialized_wallet_sig)
}
#[no_mangle]
pub extern fn ffishim_bidirectional_pay_by_customer_phase1_precompute(serialized_pp: *mut c_char, serialized_customer_data: /* Needs to be mut */ *mut c_char, serialized_merchant_keypair: *mut c_char) -> bool {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the custdata
let bytes_customer_data = unsafe { CStr::from_ptr(serialized_customer_data).to_bytes() };
let name_customer_data: &str = str::from_utf8(bytes_customer_data).unwrap(); // make sure the bytes are UTF-8
let mut deserialized_customer_data: bidirectional::InitCustomerData = serde_json::from_str(&name_customer_data).unwrap();
// Deserialize the merchant keypair
let bytes_kp = unsafe { CStr::from_ptr(serialized_merchant_keypair).to_bytes() };
let name_kp: &str = str::from_utf8(bytes_kp).unwrap(); // make sure the bytes are UTF-8
let deserialized_merchant_keypair: clsigs::KeyPairD = serde_json::from_str(&name_kp).unwrap();
// TODO this is going to do literally nothing...
bidirectional::pay_by_customer_phase1_precompute(&deserialized_pp, &deserialized_customer_data.channel_token, &deserialized_merchant_keypair.pk, &mut deserialized_customer_data.csk);
true
}
//TODO Two return values
#[no_mangle]
pub extern fn ffishim_bidirectional_pay_by_customer_phase1(serialized_pp: *mut c_char, serialized_channel: *mut c_char, serialized_customer_data: *mut c_char, serialized_merchant_keypair: *mut c_char, balance_increment: i32) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the channel state
let bytes_channel = unsafe { CStr::from_ptr(serialized_channel).to_bytes() };
let name_channel: &str = str::from_utf8(bytes_channel).unwrap(); // make sure the bytes are UTF-8
let deserialized_channel_state: bidirectional::ChannelState = serde_json::from_str(&name_channel).unwrap();
// Deserialize the custdata
let bytes_customer_data = unsafe { CStr::from_ptr(serialized_customer_data).to_bytes() };
let name_customer_data: &str = str::from_utf8(bytes_customer_data).unwrap(); // make sure the bytes are UTF-8
let deserialized_customer_data: bidirectional::InitCustomerData = serde_json::from_str(&name_customer_data).unwrap();
// Deserialize the merchant keypair
let bytes_kp = unsafe { CStr::from_ptr(serialized_merchant_keypair).to_bytes() };
let name_kp: &str = str::from_utf8(bytes_kp).unwrap(); // make sure the bytes are UTF-8
let deserialized_merchant_keypair: clsigs::KeyPairD = serde_json::from_str(&name_kp).unwrap();
// TODO: Dictionary these bad boys: ChannelToken, CustomerWallet, PaymentProof
let (t_c, new_wallet, pay_proof) = bidirectional::pay_by_customer_phase1(&deserialized_pp, &deserialized_channel_state, &deserialized_customer_data.channel_token, &deserialized_merchant_keypair.pk, &deserialized_customer_data.csk, balance_increment);
let ser = serde_json::to_string(&pay_proof).unwrap();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_pay_by_merchant_phase1(serialized_pp: *mut c_char, serialized_channel: /*make mut*/ *mut c_char, serialized_pay_proof: *mut c_char, serialized_merchant_data: *mut c_char) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the channel state
let bytes_channel = unsafe { CStr::from_ptr(serialized_channel).to_bytes() };
let name_channel: &str = str::from_utf8(bytes_channel).unwrap(); // make sure the bytes are UTF-8
let mut deserialized_channel_state: bidirectional::ChannelState = serde_json::from_str(&name_channel).unwrap();
// Deserialize the pay proof
let bytes_pay_proof = unsafe { CStr::from_ptr(serialized_pay_proof).to_bytes() };
let name_pay_proof: &str = str::from_utf8(bytes_pay_proof).unwrap(); // make sure the bytes are UTF-8
let deserialized_pay_proof: bidirectional::PaymentProof = serde_json::from_str(&name_pay_proof).unwrap();
// Deserialize the merchant data
let bytes_merchant_data = unsafe { CStr::from_ptr(serialized_merchant_data).to_bytes() };
let name_merchant_data: &str = str::from_utf8(bytes_merchant_data).unwrap(); // make sure the bytes are UTF-8
let deserialized_merchant_data: bidirectional::InitMerchantData = serde_json::from_str(&name_merchant_data).unwrap();
let rt_w = bidirectional::pay_by_merchant_phase1(&deserialized_pp, &mut deserialized_channel_state, &deserialized_pay_proof, &deserialized_merchant_data);
let ser = serde_json::to_string(&rt_w).unwrap();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_pay_by_customer_phase2(serialized_pp: *mut c_char, serialized_customer_data: *mut c_char, serialized_new_wallet: *mut c_char, serialized_merchant_keypair: *mut c_char, serialized_rt_w: *mut c_char) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the custdata
let bytes_customer_data = unsafe { CStr::from_ptr(serialized_customer_data).to_bytes() };
let name_customer_data: &str = str::from_utf8(bytes_customer_data).unwrap(); // make sure the bytes are UTF-8
let deserialized_customer_data: bidirectional::InitCustomerData = serde_json::from_str(&name_customer_data).unwrap();
// Deserialize the new wallet
let bytes_new_wallet = unsafe { CStr::from_ptr(serialized_new_wallet).to_bytes() };
let name_new_wallet: &str = str::from_utf8(bytes_new_wallet).unwrap(); // make sure the bytes are UTF-8
let deserialized_new_wallet: bidirectional::CustomerWallet = serde_json::from_str(&name_new_wallet).unwrap();
// Deserialize the merchant keypair
let bytes_kp = unsafe { CStr::from_ptr(serialized_merchant_keypair).to_bytes() };
let name_kp: &str = str::from_utf8(bytes_kp).unwrap(); // make sure the bytes are UTF-8
let deserialized_merchant_keypair: clsigs::KeyPairD = serde_json::from_str(&name_kp).unwrap();
// Deserialize the rt_w
let bytes_rt_w = unsafe { CStr::from_ptr(serialized_rt_w).to_bytes() };
let name_rt_w: &str = str::from_utf8(bytes_rt_w).unwrap(); // make sure the bytes are UTF-8
let deserialized_rt_w: clsigs::SignatureD = serde_json::from_str(&name_rt_w).unwrap();
// RevokeToken
let rv_w = bidirectional::pay_by_customer_phase2(&deserialized_pp, &deserialized_customer_data.csk, &deserialized_new_wallet, &deserialized_merchant_keypair.pk, &deserialized_rt_w);
let ser = serde_json::to_string(&rv_w).unwrap();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_pay_by_merchant_phase2(serialized_pp: *mut c_char, serialized_channel: /*make mut*/ *mut c_char, serialized_pay_proof: *mut c_char, serialized_merchant_data: /*make mut*/ *mut c_char, serialized_revoke_token: *mut c_char ) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the channel state
let bytes_channel = unsafe { CStr::from_ptr(serialized_channel).to_bytes() };
let name_channel: &str = str::from_utf8(bytes_channel).unwrap(); // make sure the bytes are UTF-8
let mut deserialized_channel_state: bidirectional::ChannelState = serde_json::from_str(&name_channel).unwrap();
// Deserialize the pay proof
let bytes_pay_proof = unsafe { CStr::from_ptr(serialized_pay_proof).to_bytes() };
let name_pay_proof: &str = str::from_utf8(bytes_pay_proof).unwrap(); // make sure the bytes are UTF-8
let deserialized_pay_proof: bidirectional::PaymentProof = serde_json::from_str(&name_pay_proof).unwrap();
// Deserialize the merchant data
let bytes_merchant_data = unsafe { CStr::from_ptr(serialized_merchant_data).to_bytes() };
let name_merchant_data: &str = str::from_utf8(bytes_merchant_data).unwrap(); // make sure the bytes are UTF-8
let mut deserialized_merchant_data: bidirectional::InitMerchantData = serde_json::from_str(&name_merchant_data).unwrap();
// Deserialize the merchant revoke token
let bytes_revoke_token = unsafe { CStr::from_ptr(serialized_revoke_token).to_bytes() };
let name_revoke_token: &str = str::from_utf8(bytes_revoke_token).unwrap(); // make sure the bytes are UTF-8
let deserialized_revoke_token: bidirectional::RevokeToken = serde_json::from_str(&name_revoke_token).unwrap();
let new_wallet_sig = bidirectional::pay_by_merchant_phase2(&deserialized_pp, &mut deserialized_channel_state, &deserialized_pay_proof, &mut deserialized_merchant_data, &deserialized_revoke_token);
let ser = serde_json::to_string(&new_wallet_sig).unwrap();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_pay_by_customer_final(serialized_pp: *mut c_char, serialized_merchant_keypair: *mut c_char, serialized_customer_data: /* make mut */ *mut c_char, serialized_channel_token: *mut c_char, serialized_new_wallet: *mut c_char, serialized_new_wallet_sig: *mut c_char) -> bool {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the merchant keypair
let bytes_kp = unsafe { CStr::from_ptr(serialized_merchant_keypair).to_bytes() };
let name_kp: &str = str::from_utf8(bytes_kp).unwrap(); // make sure the bytes are UTF-8
let deserialized_merchant_keypair: clsigs::KeyPairD = serde_json::from_str(&name_kp).unwrap();
// Deserialize the custdata
let bytes_customer_data = unsafe { CStr::from_ptr(serialized_customer_data).to_bytes() };
let name_customer_data: &str = str::from_utf8(bytes_customer_data).unwrap(); // make sure the bytes are UTF-8
let mut deserialized_customer_data: bidirectional::InitCustomerData = serde_json::from_str(&name_customer_data).unwrap();
// Deserialize the channel token
let bytes_channel_token = unsafe { CStr::from_ptr(serialized_channel_token).to_bytes() };
let name_channel_token: &str = str::from_utf8(bytes_channel_token).unwrap(); // make sure the bytes are UTF-8
let deserialized_channel_token: bidirectional::ChannelToken = serde_json::from_str(&name_channel_token).unwrap();
// Deserialize the new wallet
let bytes_new_wallet = unsafe { CStr::from_ptr(serialized_new_wallet).to_bytes() };
let name_new_wallet: &str = str::from_utf8(bytes_new_wallet).unwrap(); // make sure the bytes are UTF-8
let deserialized_new_wallet: bidirectional::CustomerWallet = serde_json::from_str(&name_new_wallet).unwrap();
// Deserialize the new wallet sig
let bytes_new_wallet_sig = unsafe { CStr::from_ptr(serialized_new_wallet_sig).to_bytes() };
let name_new_wallet_sig: &str = str::from_utf8(bytes_new_wallet_sig).unwrap(); // make sure the bytes are UTF-8
let deserialized_new_wallet_sig: clsigs::SignatureD = serde_json::from_str(&name_new_wallet_sig).unwrap();
bidirectional::pay_by_customer_final(&deserialized_pp, &deserialized_merchant_keypair.pk, &mut deserialized_customer_data, deserialized_channel_token, deserialized_new_wallet, deserialized_new_wallet_sig);
true
}
#[no_mangle]
pub extern fn ffishim_bidirectional_customer_refund(serialized_pp: *mut c_char, serialized_channel: *mut c_char, serialized_merchant_keypair: *mut c_char, serialized_wallet: *mut c_char) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the channel state
let bytes_channel = unsafe { CStr::from_ptr(serialized_channel).to_bytes() };
let name_channel: &str = str::from_utf8(bytes_channel).unwrap(); // make sure the bytes are UTF-8
let deserialized_channel_state: bidirectional::ChannelState = serde_json::from_str(&name_channel).unwrap();
// Deserialize the merchant keypair
let bytes_kp = unsafe { CStr::from_ptr(serialized_merchant_keypair).to_bytes() };
let name_kp: &str = str::from_utf8(bytes_kp).unwrap(); // make sure the bytes are UTF-8
let deserialized_merchant_keypair: clsigs::KeyPairD = serde_json::from_str(&name_kp).unwrap();
// Deserialize the new wallet
let bytes_wallet = unsafe { CStr::from_ptr(serialized_wallet).to_bytes() };
let name_wallet: &str = str::from_utf8(bytes_wallet).unwrap(); // make sure the bytes are UTF-8
let deserialized_wallet: bidirectional::CustomerWallet = serde_json::from_str(&name_wallet).unwrap();
let rc_c = bidirectional::customer_refund(&deserialized_pp, &deserialized_channel_state, &deserialized_merchant_keypair.pk, &deserialized_wallet);
let ser = serde_json::to_string(&rc_c).unwrap();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_merchant_refund(serialized_pp: *mut c_char, serialized_channel: *mut c_char, serialized_channel_token: *mut c_char, serialized_merchant_data: *mut c_char, serialized_channel_closure: *mut c_char, serialized_revoke_token: *mut c_char) -> *mut c_char {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the channel state
let bytes_channel = unsafe { CStr::from_ptr(serialized_channel).to_bytes() };
let name_channel: &str = str::from_utf8(bytes_channel).unwrap(); // make sure the bytes are UTF-8
let mut deserialized_channel_state: bidirectional::ChannelState = serde_json::from_str(&name_channel).unwrap();
// Deserialize the channel token
let bytes_channel_token = unsafe { CStr::from_ptr(serialized_channel_token).to_bytes() };
let name_channel_token: &str = str::from_utf8(bytes_channel_token).unwrap(); // make sure the bytes are UTF-8
let deserialized_channel_token: bidirectional::ChannelToken = serde_json::from_str(&name_channel_token).unwrap();
// Deserialize the merchant data
let bytes_merchant_data = unsafe { CStr::from_ptr(serialized_merchant_data).to_bytes() };
let name_merchant_data: &str = str::from_utf8(bytes_merchant_data).unwrap(); // make sure the bytes are UTF-8
let deserialized_merchant_data: bidirectional::InitMerchantData = serde_json::from_str(&name_merchant_data).unwrap();
// Deserialize the closure
let bytes_channel_closure = unsafe { CStr::from_ptr(serialized_channel_closure).to_bytes() };
let name_channel_closure: &str = str::from_utf8(bytes_channel_closure).unwrap(); // make sure the bytes are UTF-8
let deserialized_channel_closure: bidirectional::ChannelclosureC = serde_json::from_str(&name_channel_closure).unwrap();
// Deserialize the revoke_token
let bytes_revoke_token = unsafe { CStr::from_ptr(serialized_revoke_token).to_bytes() };
let name_revoke_token: &str = str::from_utf8(bytes_revoke_token).unwrap(); // make sure the bytes are UTF-8
let deserialized_revoke_token: secp256k1::Signature = serde_json::from_str(&name_revoke_token).unwrap();
let rc_m = bidirectional::merchant_refute(&deserialized_pp, &mut deserialized_channel_state, &deserialized_channel_token, &deserialized_merchant_data, &deserialized_channel_closure, &deserialized_revoke_token);
let ser = serde_json::to_string(&rc_m).unwrap();
let cser = CString::new(ser).unwrap();
cser.into_raw()
}
#[no_mangle]
pub extern fn ffishim_bidirectional_resolve(serialized_pp: *mut c_char, serialized_customer_data: *mut c_char, serialized_merchant_data: *mut c_char, serialized_closure_customer: *mut c_char, serialized_closure_merchant: *mut c_char, serialized_revoke_token: *mut c_char) -> i32 {
// Deserialize the pp
let bytes_pp = unsafe { CStr::from_ptr(serialized_pp).to_bytes() };
let name_pp: &str = str::from_utf8(bytes_pp).unwrap(); // make sure the bytes are UTF-8
let deserialized_pp: bidirectional::PublicParams = serde_json::from_str(&name_pp).unwrap();
// Deserialize the custdata
let bytes_customer_data = unsafe { CStr::from_ptr(serialized_customer_data).to_bytes() };
let name_customer_data: &str = str::from_utf8(bytes_customer_data).unwrap(); // make sure the bytes are UTF-8
let deserialized_customer_data: bidirectional::InitCustomerData = serde_json::from_str(&name_customer_data).unwrap();
// Deserialize the merchant data
let bytes_merchant_data = unsafe { CStr::from_ptr(serialized_merchant_data).to_bytes() };
let name_merchant_data: &str = str::from_utf8(bytes_merchant_data).unwrap(); // make sure the bytes are UTF-8
let deserialized_merchant_data: bidirectional::InitMerchantData = serde_json::from_str(&name_merchant_data).unwrap();
//TODO handle none()
// Deserialize the client closure
let bytes_closure_customer = unsafe { CStr::from_ptr(serialized_closure_customer).to_bytes() };
let name_closure_customer: &str = str::from_utf8(bytes_closure_customer).unwrap(); // make sure the bytes are UTF-8
let deserialized_closure_customer: bidirectional::ChannelclosureC = serde_json::from_str(&name_closure_customer).unwrap();
// Deserialize the merchant closure
let bytes_closure_merchant = unsafe { CStr::from_ptr(serialized_closure_merchant).to_bytes() };
let name_closure_merchant: &str = str::from_utf8(bytes_closure_merchant).unwrap(); // make sure the bytes are UTF-8
let deserialized_closure_merchant: bidirectional::ChannelclosureM = serde_json::from_str(&name_closure_merchant).unwrap();
// Deserialize the revoke_token
let bytes_revoke_token = unsafe { CStr::from_ptr(serialized_revoke_token).to_bytes() };
let name_revoke_token: &str = str::from_utf8(bytes_revoke_token).unwrap(); // make sure the bytes are UTF-8
let deserialized_revoke_token: clsigs::SignatureD = serde_json::from_str(&name_revoke_token).unwrap();
// TODO multiple returns
let (new_b0_cust, new_b0_merch) = bidirectional::resolve(&deserialized_pp, &deserialized_customer_data, &deserialized_merchant_data, Some(deserialized_closure_customer), Some(deserialized_closure_merchant), Some(deserialized_revoke_token));
new_b0_cust
}
}
#[cfg(all(test, feature = "unstable"))]

77
src/main.py
View File

@ -15,7 +15,7 @@ else:
ext = 'so'
libbolt = cdll.LoadLibrary('target/debug/{}libboltlib.{}'.format(prefix, ext))
libbolt = cdll.LoadLibrary('target/debug/{}bolt.{}'.format(prefix, ext))
libbolt.ffishim_bidirectional_setup.argtypes = (c_uint8, )
libbolt.ffishim_bidirectional_setup.restype = c_void_p
@ -55,32 +55,55 @@ bidirectional_establish_customer_phase1 = libbolt.ffishim_bidirectional_establ
bidirectional_establish_merchant_phase2 = libbolt.ffishim_bidirectional_establish_merchant_phase2
bidirectional_establish_customer_final = libbolt.ffishim_bidirectional_establish_customer_final
b0_cust = 50;
b0_merch = 50;
pp = bidirectional_setup(0)
# # libbolt.ffishim_bidirectional_teststruct.argtypes = (c_uint8, )
libbolt.ffishim_bidirectional_teststruct.restype = c_void_p
merch_keys = bidirectional_keygen(pp)
print(" After merch_keys")
cust_keys = bidirectional_keygen(pp)
print(" After cust_keys")
channel = bidirectional_channelstate_new("My New Channel A", 0)
print(" After channel")
merch_data = bidirectional_init_merchant(pp, b0_cust, merch_keys)
print(" After merch_data")
cm_csp = bidirectional_generate_commit_setup(pp, merch_keys)
print(" After cm_csp")
cust_data = bidirectional_init_customer(pp, channel, b0_cust, b0_merch, cm_csp, cust_keys)
print(" After cust_data")
proof1 = bidirectional_establish_customer_phase1(pp, cust_data, merch_data)
print(" After proof1")
wallet_sig = bidirectional_establish_merchant_phase2(pp, channel, merch_data, proof1)
print(" After wallet_sig")
setup = bidirectional_establish_customer_final(pp, merch_keys, cust_data, wallet_sig)
print(" After setup")
libbolt.ffishim_bidirectional_teststruct_in.argtypes = (c_void_p, )
libbolt.ffishim_bidirectional_teststruct_in.restype = c_uint8
print(setup)
print(ctypes.cast(pp, ctypes.c_char_p).value.decode('utf-8'))
print(ctypes.cast(keys, ctypes.c_char_p).value.decode('utf-8'))
print(ctypes.cast(channel_token, ctypes.c_char_p).value.decode('utf-8'))
print(ctypes.cast(commit_setup, ctypes.c_char_p).value.decode('utf-8'))
bidirectional_teststruct = libbolt.ffishim_bidirectional_teststruct
bidirectional_teststruct_in = libbolt.ffishim_bidirectional_teststruct_in
a = bidirectional_teststruct()
print(a)
b = bidirectional_teststruct_in(a)
print(a)
print(b)
print(ctypes.cast(a, ctypes.c_char_p).value.decode('utf-8'))
print(ctypes.cast(b, ctypes.c_char_p).value.decode('utf-8'))
# b0_cust = 50;
# b0_merch = 50;
# pp = bidirectional_setup(0)
# merch_keys = bidirectional_keygen(pp)
# print(" After merch_keys")
# cust_keys = bidirectional_keygen(pp)
# print(" After cust_keys")
# channel = bidirectional_channelstate_new("My New Channel A", 0)
# print(" After channel")
# merch_data = bidirectional_init_merchant(pp, b0_cust, merch_keys)
# print(" After merch_data")
# cm_csp = bidirectional_generate_commit_setup(pp, merch_keys)
# print(" After cm_csp")
# cust_data = bidirectional_init_customer(pp, channel, b0_cust, b0_merch, cm_csp, cust_keys)
# print(" After cust_data")
# proof1 = bidirectional_establish_customer_phase1(pp, cust_data, merch_data)
# print(" After proof1")
# wallet_sig = bidirectional_establish_merchant_phase2(pp, channel, merch_data, proof1)
# print(" After wallet_sig")
# setup = bidirectional_establish_customer_final(pp, merch_keys, cust_data, wallet_sig)
# print(" After setup")
# print(setup)
# print(ctypes.cast(pp, ctypes.c_char_p).value.decode('utf-8'))
# print(ctypes.cast(keys, ctypes.c_char_p).value.decode('utf-8'))
# print(ctypes.cast(channel_token, ctypes.c_char_p).value.decode('utf-8'))
# print(ctypes.cast(commit_setup, ctypes.c_char_p).value.decode('utf-8'))

104
src/serialization_wrappers.rs
View File

@ -17,6 +17,30 @@ where
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 {
@ -125,6 +149,68 @@ impl<'de> Visitor<'de> for FieldVisitor {
}
}
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 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 {
// println!("Byte = {:?}", b);
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>
@ -161,6 +247,24 @@ where
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_any(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_any(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,