rest of the functions
This commit is contained in:
Gabe Kaptchuk
parent
bc47543314
commit
711fa83400
|
|
@ -23,7 +23,7 @@ time = "*"
|
|||
rustc-serialize = "0.3"
|
||||
# secp256k1 = { git = "https://github.com/ZcashFoundation/rust-secp256k1", branch = "master", features = ["rand"] }
|
||||
secp256k1 = { git = "https://github.com/ZcashFoundation/rust-secp256k1", branch = "master", features = ["rand", "serde"] }
|
||||
curve25519-dalek = "1.0.0-pre.0"
|
||||
curve25519-dalek = { version = "1", features = ["serde"] }
|
||||
merlin = "1.0.0"
|
||||
bulletproofs = { git = "https://github.com/dalek-cryptography/bulletproofs", branch = "main" }
|
||||
sha2 = { version = "0.8", default-features = false }
|
||||
|
|
|
|||
115
src/lib.rs
115
src/lib.rs
|
|
@ -318,6 +318,7 @@ fn convert_int_to_fr(value: i32) -> Fr {
|
|||
#[derive(Clone, Serialize, Deserialize)]
|
||||
pub struct RefundMessage {
|
||||
pub msgtype: String, // purpose type of message
|
||||
#[serde(deserialize_with = "serialization_wrappers::deserialize_public_key")]
|
||||
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")]
|
||||
|
|
@ -367,6 +368,7 @@ impl RefundMessage {
|
|||
#[derive(Clone, Serialize, Deserialize)]
|
||||
pub struct RevokedMessage {
|
||||
pub msgtype: String,
|
||||
#[serde(deserialize_with = "serialization_wrappers::deserialize_public_key")]
|
||||
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
|
||||
|
|
@ -627,13 +629,6 @@ pub mod bidirectional {
|
|||
}
|
||||
}
|
||||
|
||||
// TODO DELETE THHIS TEST STRUCT
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub struct TestPublicParams {
|
||||
pub cl_mpk: clsigs::PublicParams,
|
||||
pub range_proof_bits: usize
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub struct PublicParams {
|
||||
cl_mpk: clsigs::PublicParams,
|
||||
|
|
@ -664,7 +659,6 @@ pub mod bidirectional {
|
|||
common_params: clproto::CommonParams, // common params for NIZK
|
||||
}
|
||||
|
||||
// TODO This is broken
|
||||
#[derive(Clone, Serialize, Deserialize)]
|
||||
pub struct CustomerWallet {
|
||||
sk: clsigs::SecretKeyD, // the secret key for the signature scheme (Is it possible to make this a generic field?)
|
||||
|
|
@ -711,6 +705,7 @@ pub mod bidirectional {
|
|||
// part of channel state
|
||||
#[derive(Clone, Serialize, Deserialize)]
|
||||
pub struct PubKeyMap {
|
||||
#[serde(deserialize_with = "serialization_wrappers::deserialize_public_key")]
|
||||
wpk: secp256k1::PublicKey,
|
||||
revoke_token: Option<secp256k1::Signature>
|
||||
}
|
||||
|
|
@ -775,7 +770,9 @@ pub mod bidirectional {
|
|||
// proof of valid balance
|
||||
#[derive(Clone, Serialize, Deserialize)]
|
||||
pub struct ProofVB {
|
||||
#[serde(deserialize_with = "serialization_wrappers::deserialize_range_proof")]
|
||||
range_proof: (bulletproofs::RangeProof, curve25519_dalek::ristretto::CompressedRistretto),
|
||||
#[serde(deserialize_with = "serialization_wrappers::deserialize_r_point")]
|
||||
value_commitment: RistrettoPoint
|
||||
}
|
||||
|
||||
|
|
@ -800,6 +797,7 @@ pub mod bidirectional {
|
|||
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,
|
||||
#[serde(deserialize_with = "serialization_wrappers::deserialize_public_key")]
|
||||
wpk: secp256k1::PublicKey, // verification key for old wallet
|
||||
wallet_sig: clsigs::SignatureD, // blinded signature for old wallet
|
||||
pub bal_proof: BalanceProof
|
||||
|
|
@ -808,6 +806,7 @@ pub mod bidirectional {
|
|||
#[derive(Serialize, Deserialize)]
|
||||
pub struct RevokeToken {
|
||||
message: RevokedMessage,
|
||||
#[serde(deserialize_with = "serialization_wrappers::deserialize_secp_signature")]
|
||||
pub signature: secp256k1::Signature
|
||||
}
|
||||
|
||||
|
|
@ -1554,49 +1553,6 @@ pub mod ffishim {
|
|||
cser.into_raw()
|
||||
}
|
||||
|
||||
// TODO GET RID OF THESE TEST THINGS
|
||||
|
||||
#[no_mangle]
|
||||
pub extern fn ffishim_bidirectional_teststruct() -> *mut c_char {
|
||||
|
||||
let cl_mpk_instance = clsigs::setup_d();
|
||||
|
||||
let test = bidirectional::TestPublicParams {
|
||||
cl_mpk: cl_mpk_instance,
|
||||
range_proof_bits: 52
|
||||
};
|
||||
|
||||
let cl_mpk_instance_two = clsigs::setup_d();
|
||||
|
||||
let test_two = bidirectional::TestPublicParams {
|
||||
cl_mpk: cl_mpk_instance_two,
|
||||
range_proof_bits: 21
|
||||
};
|
||||
|
||||
// let ser = ["{\'a\' : \'" , "serde_jsonto_string(test).unwrap().as_str()", "\' ,\'b\' : \'", "serde_jsonto_string(test_two).unwrap().as_str()", "\'}"].concat();
|
||||
let ser = ["{\'a\' : \'" , serde_json::to_string(&test).unwrap().as_str(), "\' ,\'b\' : \'", serde_json::to_string(&test_two).unwrap().as_str(), "\'}"].concat();
|
||||
let cser = CString::new(ser).unwrap();
|
||||
|
||||
cser.into_raw()
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
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 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(); }
|
||||
object.range_proof_bits
|
||||
}
|
||||
|
||||
#[no_mangle]
|
||||
pub extern fn ffishim_bidirectional_keygen(serialized_pp: *mut c_char) -> *mut c_char {
|
||||
|
||||
|
|
@ -1751,7 +1707,6 @@ pub mod ffishim {
|
|||
let name_wallet_sig: &str = str::from_utf8(bytes_wallet_sig).unwrap(); // make sure the bytes are UTF-8
|
||||
let deserialized_wallet_sig: clsigs::SignatureD = serde_json::from_str(&name_wallet_sig).unwrap();
|
||||
|
||||
// TODO make this return the csk
|
||||
bidirectional::establish_customer_final(&deserialized_pp, &deserialized_merchant_publickey, &mut deserialized_customer_data.csk, deserialized_wallet_sig);
|
||||
let ser = ["{\'customer_data\':\'", serde_json::to_string(&deserialized_customer_data).unwrap().as_str(), "\'}"].concat();
|
||||
let cser = CString::new(ser).unwrap();
|
||||
|
|
@ -1760,7 +1715,6 @@ pub mod ffishim {
|
|||
|
||||
#[no_mangle]
|
||||
pub extern fn ffishim_bidirectional_pay_by_customer_phase1_precompute(serialized_pp: *mut c_char, serialized_customer_data: *mut c_char, serialized_merchant_public_key: *mut c_char) -> *mut c_char {
|
||||
println!("Inside Precompute");
|
||||
// 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
|
||||
|
|
@ -1810,8 +1764,6 @@ pub mod ffishim {
|
|||
cser.into_raw()
|
||||
}
|
||||
|
||||
// Everythnig above is done
|
||||
|
||||
#[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
|
||||
|
|
@ -1835,13 +1787,13 @@ pub mod ffishim {
|
|||
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 ser = ["{\'rt_w\':\'", serde_json::to_string(&rt_w).unwrap().as_str(), "\', \'state\':\'", serde_json::to_string(&deserialized_channel_state).unwrap().as_str() ,"\'}"].concat();
|
||||
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 {
|
||||
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_public_key: *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
|
||||
|
|
@ -1857,10 +1809,10 @@ pub mod ffishim {
|
|||
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 merchant public key
|
||||
let bytes_pk = unsafe { CStr::from_ptr(serialized_merchant_public_key).to_bytes() };
|
||||
let name_pk: &str = str::from_utf8(bytes_pk).unwrap(); // make sure the bytes are UTF-8
|
||||
let deserialized_merchant_publickey: clsigs::PublicKeyD = serde_json::from_str(&name_pk).unwrap();
|
||||
|
||||
// Deserialize the rt_w
|
||||
let bytes_rt_w = unsafe { CStr::from_ptr(serialized_rt_w).to_bytes() };
|
||||
|
|
@ -1868,8 +1820,8 @@ pub mod ffishim {
|
|||
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 rv_w = bidirectional::pay_by_customer_phase2(&deserialized_pp, &deserialized_customer_data.csk, &deserialized_new_wallet, &deserialized_merchant_publickey, &deserialized_rt_w);
|
||||
let ser = ["{\'rv_w\':\'", serde_json::to_string(&rv_w).unwrap().as_str(), "\'}"].concat();
|
||||
let cser = CString::new(ser).unwrap();
|
||||
cser.into_raw()
|
||||
}
|
||||
|
|
@ -1902,22 +1854,22 @@ pub mod ffishim {
|
|||
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 ser = ["{\'new_wallet_sig\':\'", serde_json::to_string(&new_wallet_sig).unwrap().as_str(), "\', \'state\':\'", serde_json::to_string(&deserialized_channel_state).unwrap().as_str() , "\', \'merch_data\':\'", serde_json::to_string(&deserialized_merchant_data).unwrap().as_str(), "\'}"].concat();
|
||||
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 {
|
||||
pub extern fn ffishim_bidirectional_pay_by_customer_final(serialized_pp: *mut c_char, serialized_merchant_public_key: *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) -> *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 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();
|
||||
let bytes_pk = unsafe { CStr::from_ptr(serialized_merchant_public_key).to_bytes() };
|
||||
let name_pk: &str = str::from_utf8(bytes_pk).unwrap(); // make sure the bytes are UTF-8
|
||||
let deserialized_merchant_public_key: clsigs::PublicKeyD = serde_json::from_str(&name_pk).unwrap();
|
||||
|
||||
// Deserialize the custdata
|
||||
let bytes_customer_data = unsafe { CStr::from_ptr(serialized_customer_data).to_bytes() };
|
||||
|
|
@ -1939,12 +1891,14 @@ pub mod ffishim {
|
|||
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
|
||||
bidirectional::pay_by_customer_final(&deserialized_pp, &deserialized_merchant_public_key, &mut deserialized_customer_data, deserialized_channel_token, deserialized_new_wallet, deserialized_new_wallet_sig);
|
||||
let ser = ["{\'customer_data\':\'", serde_json::to_string(&deserialized_customer_data).unwrap().as_str(), "\'}"].concat();
|
||||
let cser = CString::new(ser).unwrap();
|
||||
cser.into_raw()
|
||||
}
|
||||
|
||||
#[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 {
|
||||
pub extern fn ffishim_bidirectional_customer_refund(serialized_pp: *mut c_char, serialized_channel: *mut c_char, serialized_merchant_public_key: *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
|
||||
|
|
@ -1956,17 +1910,17 @@ pub mod ffishim {
|
|||
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();
|
||||
let bytes_pk = unsafe { CStr::from_ptr(serialized_merchant_public_key).to_bytes() };
|
||||
let name_pk: &str = str::from_utf8(bytes_pk).unwrap(); // make sure the bytes are UTF-8
|
||||
let deserialized_merchant_public_key: clsigs::PublicKeyD = serde_json::from_str(&name_pk).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 rc_c = bidirectional::customer_refund(&deserialized_pp, &deserialized_channel_state, &deserialized_merchant_public_key, &deserialized_wallet);
|
||||
let ser = ["{\'rc_c\':\'", serde_json::to_string(&rc_c).unwrap().as_str(), "\'}"].concat();
|
||||
let cser = CString::new(ser).unwrap();
|
||||
cser.into_raw()
|
||||
}
|
||||
|
|
@ -2005,13 +1959,13 @@ pub mod ffishim {
|
|||
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 ser = ["{\'rc_m\':\'", serde_json::to_string(&rc_m).unwrap().as_str(), "\', \'state\':\'", serde_json::to_string(&deserialized_channel_state).unwrap().as_str(), "\'}"].concat();
|
||||
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 {
|
||||
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) -> *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
|
||||
|
|
@ -2044,9 +1998,10 @@ pub mod ffishim {
|
|||
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
|
||||
let ser = ["{\'new_b0_cust\':\'", new_b0_cust.to_string().as_str(), "\', \'new_b0_merch\':\'", new_b0_merch.to_string().as_str(), "\'}"].concat();
|
||||
let cser = CString::new(ser).unwrap();
|
||||
cser.into_raw()
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
137
src/main.py
137
src/main.py
|
|
@ -8,18 +8,8 @@ import ast
|
|||
import json
|
||||
|
||||
class Libbolt(object):
|
||||
|
||||
# bidirectional_setup = libbolt.ffishim_bidirectional_setup
|
||||
# bidirectional_channelstate_new = libbolt.ffishim_bidirectional_channelstate_new
|
||||
# bidirectional_keygen = libbolt.ffishim_bidirectional_keygen
|
||||
# bidirectional_init_merchant = libbolt.ffishim_bidirectional_init_merchant
|
||||
# bidirectional_generate_commit_setup = libbolt.ffishim_bidirectional_generate_commit_setup
|
||||
# bidirectional_init_customer = libbolt.ffishim_bidirectional_init_customer
|
||||
# bidirectional_establish_customer_phase1 = libbolt.ffishim_bidirectional_establish_customer_phase1
|
||||
# bidirectional_establish_merchant_phase2 = libbolt.ffishim_bidirectional_establish_merchant_phase2
|
||||
# bidirectional_establish_customer_final = libbolt.ffishim_bidirectional_establish_customer_final
|
||||
|
||||
"""docstring for Libbolt"""
|
||||
|
||||
def __init__(self, path):
|
||||
self.lib = cdll.LoadLibrary(path)
|
||||
self.load_library_params()
|
||||
|
|
@ -58,29 +48,29 @@ class Libbolt(object):
|
|||
self.lib.ffishim_bidirectional_pay_by_customer_phase1.argtypes = (c_void_p, c_void_p, c_void_p, c_void_p, ctypes.c_int32)
|
||||
self.lib.ffishim_bidirectional_pay_by_customer_phase1.restype = c_void_p
|
||||
|
||||
self.lib.ffishim_bidirectional_pay_by_merchant_phase1.argtypes = (c_void_p, c_void_p, c_void_p, c_void_p)
|
||||
self.lib.ffishim_bidirectional_pay_by_merchant_phase1.restype = c_void_p
|
||||
|
||||
# For Test Structures ONLY
|
||||
self.lib.ffishim_bidirectional_pay_by_customer_phase2.argtypes = (c_void_p, c_void_p, c_void_p, c_void_p, c_void_p)
|
||||
self.lib.ffishim_bidirectional_pay_by_customer_phase2.restype = c_void_p
|
||||
|
||||
# libbolt.ffishim_bidirectional_teststruct.argtypes = (c_uint8, )
|
||||
self.lib.ffishim_bidirectional_teststruct.restype = c_void_p
|
||||
self.lib.ffishim_bidirectional_pay_by_merchant_phase2.argtypes = (c_void_p, c_void_p, c_void_p, c_void_p, c_void_p)
|
||||
self.lib.ffishim_bidirectional_pay_by_merchant_phase2.restype = c_void_p
|
||||
|
||||
self.lib.ffishim_bidirectional_teststruct_in.argtypes = (c_void_p, )
|
||||
self.lib.ffishim_bidirectional_teststruct_in.restype = c_uint8
|
||||
self.lib.ffishim_bidirectional_pay_by_customer_final.argtypes = (c_void_p, c_void_p, c_void_p, c_void_p, c_void_p, c_void_p)
|
||||
self.lib.ffishim_bidirectional_pay_by_customer_final.restype = c_void_p
|
||||
|
||||
self.lib.ffishim_bidirectional_customer_refund.argtypes = (c_void_p, c_void_p, c_void_p, c_void_p)
|
||||
self.lib.ffishim_bidirectional_customer_refund.restype = c_void_p
|
||||
|
||||
self.lib.ffishim_bidirectional_merchant_refund.argtypes = (c_void_p, c_void_p, c_void_p, c_void_p, c_void_p, c_void_p)
|
||||
self.lib.ffishim_bidirectional_merchant_refund.restype = c_void_p
|
||||
|
||||
self.lib.ffishim_bidirectional_resolve.argtypes = (c_void_p, c_void_p, c_void_p, c_void_p, c_void_p, c_void_p)
|
||||
self.lib.ffishim_bidirectional_resolve.restype = c_void_p
|
||||
|
||||
self.lib.ffishim_free_string.argtypes = (c_void_p, )
|
||||
|
||||
# bidirectional_teststruct = libbolt.ffishim_bidirectional_teststruct
|
||||
# bidirectional_teststruct_in = libbolt.ffishim_bidirectional_teststruct_in
|
||||
|
||||
# TODO set all the dictionary keys iin one place instead of hard coding them
|
||||
|
||||
def bidirectional_teststruct(self):
|
||||
output_string = ast.literal_eval(ctypes.cast(self.lib.ffishim_bidirectional_teststruct(), ctypes.c_char_p).value.decode('utf-8'))
|
||||
print(output_string)
|
||||
return output_string['a']
|
||||
|
||||
def bidirectional_teststruct_in(self, input_struct):
|
||||
return self.lib.ffishim_bidirectional_teststruct_in(input_struct)
|
||||
|
||||
def bidirectional_setup(self, extra_verify):
|
||||
inputs = 0
|
||||
|
|
@ -132,7 +122,6 @@ class Libbolt(object):
|
|||
output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8'))
|
||||
return output_dictionary['customer_data']
|
||||
|
||||
|
||||
def bidirectional_pay_by_customer_phase1_precompute(self, pp, cust_data, merch_pubkey):
|
||||
output_string = self.lib.ffishim_bidirectional_pay_by_customer_phase1_precompute(pp, cust_data, merch_pubkey)
|
||||
output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8'))
|
||||
|
|
@ -143,6 +132,40 @@ class Libbolt(object):
|
|||
output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8'))
|
||||
return (output_dictionary['channel_token'],output_dictionary['new_wallet'],output_dictionary['pay_proof'] )
|
||||
|
||||
def bidirectional_pay_by_merchant_phase1(self, pp, channel, pay_proof, merch_data):
|
||||
output_string = self.lib.ffishim_bidirectional_pay_by_merchant_phase1(pp, channel, pay_proof, merch_data)
|
||||
output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8'))
|
||||
return (output_dictionary['rt_w'],output_dictionary['state'])
|
||||
|
||||
def bidirectional_pay_by_customer_phase2(self, pp, cust_data, new_wallet, merch_public_key, rt_w):
|
||||
output_string = self.lib.ffishim_bidirectional_pay_by_customer_phase2(pp, cust_data, new_wallet, merch_public_key, rt_w)
|
||||
output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8'))
|
||||
return output_dictionary['rv_w']
|
||||
|
||||
def bidirectional_pay_by_merchant_phase2(self, pp, channel, pay_proof, merch_data, revoke_token):
|
||||
output_string = self.lib.ffishim_bidirectional_pay_by_merchant_phase2( pp, channel, pay_proof, merch_data, revoke_token)
|
||||
output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8'))
|
||||
return (output_dictionary['new_wallet_sig'],output_dictionary['state'], output_dictionary['merch_data'])
|
||||
|
||||
def bidirectional_pay_by_customer_final(self, pp, merch_public_key, cust_data, channel_token, new_wallet, new_wallet_sig):
|
||||
output_string = self.lib.ffishim_bidirectional_pay_by_customer_final(pp, merch_public_key, cust_data, channel_token, new_wallet, new_wallet_sig)
|
||||
output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8'))
|
||||
return output_dictionary['customer_data']
|
||||
|
||||
def bidirectional_customer_refund(self, pp, channel, merch_public_key, wallet):
|
||||
output_string = self.lib.ffishim_bidirectional_customer_refund(pp, channel, merch_public_key, wallet)
|
||||
output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8'))
|
||||
return output_dictionary['rc_c']
|
||||
|
||||
def bidirectional_merchant_refund(self, pp, channel, channel_token, merch_data, channel_closure, revoke_token):
|
||||
output_string = self.lib.ffishim_bidirectional_merchant_refund(pp, channel, channel_token, merch_data, channel_closure, revoke_token)
|
||||
output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8'))
|
||||
return (output_dictionary['rc_m'], output_dictionary['state'])
|
||||
|
||||
def bidirectional_resolve(self, pp, cust_data, merch_data, cust_closure, merch_closure, revoke_token):
|
||||
output_string = self.lib.ffishim_bidirectional_resolve( pp, cust_data, merch_data, cust_closure, merch_closure, revoke_token)
|
||||
output_dictionary = ast.literal_eval(ctypes.cast(output_string, ctypes.c_char_p).value.decode('utf-8'))
|
||||
return (int(output_dictionary['new_b0_cust']), int(output_dictionary['new_b0_merch']))
|
||||
|
||||
# --------------------------------------------
|
||||
|
||||
|
|
@ -165,53 +188,45 @@ else:
|
|||
libbolt = Libbolt('target/debug/{}bolt.{}'.format(prefix, ext))
|
||||
|
||||
|
||||
# print(a)
|
||||
|
||||
# b = libbolt.bidirectional_teststruct_in(a)
|
||||
|
||||
# print(b)
|
||||
# print(second_thing['range_proof_bits'])
|
||||
|
||||
# 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 = libbolt.bidirectional_setup(False)
|
||||
# print(pp)
|
||||
|
||||
merch_keys = libbolt.bidirectional_keygen(pp)
|
||||
# print merch_keys
|
||||
|
||||
cust_keys = libbolt.bidirectional_keygen(pp)
|
||||
# print(cust_keys)
|
||||
|
||||
channel_state = libbolt.bidirectional_channelstate_new("My New Channel A", 0)
|
||||
# print(channel)
|
||||
# print(" After channel")
|
||||
|
||||
merch_data = libbolt.bidirectional_init_merchant(pp, b0_cust, merch_keys)
|
||||
# print(merch_data)
|
||||
# print(" After merch_data")
|
||||
|
||||
cm_csp = libbolt.bidirectional_generate_commit_setup(pp, libbolt.util_extract_public_key_from_keypair(merch_keys))
|
||||
# print(" After cm_csp")
|
||||
|
||||
cust_data, channel_state = libbolt.bidirectional_init_customer(pp, channel_state, b0_cust, b0_merch, cm_csp, cust_keys)
|
||||
# print channel_state
|
||||
# print(cust_data)
|
||||
|
||||
proof1 = libbolt.bidirectional_establish_customer_phase1(pp, cust_data, merch_data)
|
||||
print(" After proof1")
|
||||
|
||||
wallet_sig, channel_state = libbolt.bidirectional_establish_merchant_phase2(pp, channel_state, merch_data, proof1)
|
||||
print(" After wallet_sig")
|
||||
|
||||
cust_data = libbolt.bidirectional_establish_customer_final(pp, libbolt.util_extract_public_key_from_keypair(merch_keys), cust_data, wallet_sig)
|
||||
print(" After final")
|
||||
cust_data = libbolt.bidirectional_pay_by_customer_phase1_precompute(pp, cust_data, libbolt.util_extract_public_key_from_keypair(merch_keys) )
|
||||
print(" After Precompute")
|
||||
|
||||
(t_c, new_wallet, pay_proof) = libbolt.bidirectional_pay_by_customer_phase1(pp, channel_state, cust_data, libbolt.util_extract_public_key_from_keypair(merch_keys), 5)
|
||||
print(" after pay phase 1")
|
||||
cust_data = libbolt.bidirectional_pay_by_customer_phase1_precompute(pp, cust_data, libbolt.util_extract_public_key_from_keypair(merch_keys))
|
||||
|
||||
(channel_token, new_wallet, pay_proof) = libbolt.bidirectional_pay_by_customer_phase1(pp, channel_state, cust_data, libbolt.util_extract_public_key_from_keypair(merch_keys), 5)
|
||||
|
||||
(rt_w, channel_state) = libbolt.bidirectional_pay_by_merchant_phase1(pp, channel_state, pay_proof, merch_data)
|
||||
|
||||
rv_w = libbolt.bidirectional_pay_by_customer_phase2(pp, cust_data, new_wallet, libbolt.util_extract_public_key_from_keypair(merch_keys), rt_w)
|
||||
|
||||
(new_wallet_sig, state, merch_data) = libbolt.bidirectional_pay_by_merchant_phase2(pp, channel_state, pay_proof, merch_data, rv_w)
|
||||
|
||||
cust_data = libbolt.bidirectional_pay_by_customer_final(pp, libbolt.util_extract_public_key_from_keypair(merch_keys), cust_data, channel_token, new_wallet, new_wallet_sig)
|
||||
|
||||
print("--------------------")
|
||||
|
||||
cust_data = libbolt.bidirectional_pay_by_customer_phase1_precompute(pp, cust_data, libbolt.util_extract_public_key_from_keypair(merch_keys))
|
||||
|
||||
(channel_token, new_wallet, pay_proof) = libbolt.bidirectional_pay_by_customer_phase1(pp, channel_state, cust_data, libbolt.util_extract_public_key_from_keypair(merch_keys), -10)
|
||||
|
||||
# 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'))
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ use bn::{Group, Fr, G1, G2, Gt};
|
|||
use bulletproofs::{BulletproofGens, PedersenGens, RangeProof};
|
||||
use secp256k1;
|
||||
use std::fmt;
|
||||
use curve25519_dalek::ristretto::RistrettoPoint;
|
||||
// use serde-rustc-serialize-interop;
|
||||
|
||||
use serde::{Serialize, Serializer, ser::SerializeSeq, ser::SerializeStruct, Deserialize, Deserializer, de::Visitor, de::Error, de::SeqAccess};
|
||||
|
|
@ -255,7 +256,7 @@ pub fn deserialize_optional_fixed_64_byte_array<'de, D>(deserializer: D) -> Resu
|
|||
where
|
||||
D: Deserializer<'de>
|
||||
{
|
||||
let a = deserializer.deserialize_any(OptionalByteArrayVisitor);
|
||||
let a = deserializer.deserialize_option(OptionalByteArrayVisitor);
|
||||
|
||||
Ok(a.unwrap())
|
||||
}
|
||||
|
|
@ -467,12 +468,119 @@ where
|
|||
}
|
||||
|
||||
|
||||
// --------------
|
||||
// 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())
|
||||
}
|
||||
|
||||
// -------------
|
||||
// These are hot fixes because secp256k1's implemenetation seems to be very very broken
|
||||
// TODO THIS NEED TO BE FIXED UPSTREAM !!!
|
||||
|
||||
struct SignatureVisitor;
|
||||
|
||||
impl<'de> Visitor<'de> for SignatureVisitor {
|
||||
type Value = secp256k1::Signature;
|
||||
|
||||
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 bytes = Vec::new();
|
||||
loop {
|
||||
let tmp = seq.next_element::<u8>();
|
||||
if let Ok(Some(b)) = tmp {
|
||||
bytes.push(b)
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(secp256k1::Signature::from_der(bytes.as_slice()).unwrap())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn deserialize_secp_signature<'de, D>(deserializer: D) -> Result<secp256k1::Signature, D::Error>
|
||||
where
|
||||
D: Deserializer<'de>
|
||||
{
|
||||
let a = deserializer.deserialize_seq(SignatureVisitor);
|
||||
|
||||
Ok(a.unwrap())
|
||||
}
|
||||
|
||||
|
||||
struct PublicKeyVisitor;
|
||||
|
||||
impl<'de> Visitor<'de> for PublicKeyVisitor {
|
||||
|
|
|
|||
Loading…
Reference in New Issue