1440000bytes
commented
3 months ago I tried creating python binding based on the instructions shared in https://github.com/PyO3/pyo3 README but getting this error:
error: Python functions cannot have generic const parameters
--> src/autct.rs:41:5
|
41 | const L: usize,
| ^^^^^
error[E0425]: cannot find value __pyo3_get_function_get_curve_tree_with_proof in this scope
--> src/autct.rs:153:20
|
153 | m.add_function(wrap_pyfunction!(get_curve_tree_with_proof, m)?)?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not found in this scope
|
= note: this error originates in the macro proc_macro_call which comes from the expansion of the macro wrap_pyfunction (in Nightly builds, run with -Z macro-backtrace for more info)
For more information about this error, try rustc --explain E0425.
error: could not compile autct (bin "autct") due to 2 previous errors
💥 maturin failed
Caused by: Failed to build a native library through cargo
Caused by: Cargo build finished with "exit status: 101": env -u CARGO PYO3_ENVIRONMENT_SIGNATURE="cpython-3.10-64bit" PYO3_PYTHON="/media/test/extenstion/Downloads/aut-ct/myenv/bin/python" PYTHON_SYS_EXECUTABLE="/media/test/extenstion/Downloads/aut-ct/myenv/bin/python" "cargo" "rustc" "--message-format" "json-render-diagnostics" "--manifest-path" "/media/test/extenstion/Downloads/aut-ct/Cargo.toml" "--bin" "autct"I just tried it for get_curve_tree_with_proof():
#[pyfunction]
pub fn get_curve_tree_with_proof<
const L: usize,
F: PrimeField,
P0: SWCurveConfig<BaseField = F> + Copy,
P1: SWCurveConfig<BaseField = P0::ScalarField, ScalarField = P0::BaseField> + Copy,
>(
depth: usize,
generators_length_log_2: usize,
pubkey_file_path: &str,
our_pubkey: Affine<P0>,
) -> (R1CSProof<Affine<P0>>, R1CSProof<Affine<P1>>,
SelectAndRerandomizePath<L, P0, P1>,
P0::ScalarField,
Affine<P0>, Affine<P0>, bool) {
let mut rng = rand::thread_rng();
let generators_length = 1 << generators_length_log_2;
let sr_params =
SelRerandParameters::<P0, P1>::new(generators_length, generators_length, &mut rng);
let p0_transcript = Transcript::new(b"select_and_rerandomize");
let mut p0_prover: Prover<_, Affine<P0>> =
Prover::new(&sr_params.even_parameters.pc_gens, p0_transcript);
let p1_transcript = Transcript::new(b"select_and_rerandomize");
let mut p1_prover: Prover<_, Affine<P1>> =
Prover::new(&sr_params.odd_parameters.pc_gens, p1_transcript);
// these are called 'leaf commitments' and not 'leaves', but it's just
// to emphasize that we are not committing to scalars, but using points (i.e. pubkeys)
// as the commitments (i.e. pedersen commitments with zero randomness) at
// the leaf level.
let mut privkey_parity_flip: bool = false;
let leaf_commitments = get_leaf_commitments::<F, P0>(pubkey_file_path);
// derive the index where our pubkey is in the list:
let mut key_index: i32; // we're guaranteed to overwrite or panic but the compiler insists.
// the reason for 2 rounds of search is that BIP340 can output a different parity
// compared to ark-ec 's compression algo.
key_index = match leaf_commitments.iter().position(|&x| x == our_pubkey) {
None => -1,
Some(ks) => ks.try_into().unwrap()
};
if key_index == -1 {
key_index = match leaf_commitments.iter().position(|&x| x == -our_pubkey) {
None => panic!("provided pubkey not found in the set"),
Some(ks) => {
privkey_parity_flip = true;
ks.try_into().unwrap()
}
}
};
let (curve_tree, _) = get_curve_tree::<L, F, P0, P1>(
pubkey_file_path, depth, &sr_params);
assert_eq!(curve_tree.height(), depth);
let (path_commitments, rand_scalar) =
curve_tree.select_and_rerandomize_prover_gadget(
key_index.try_into().unwrap(),
&mut p0_prover,
&mut p1_prover,
&sr_params,
&mut rng,
);
// as well as the randomness in the blinded commitment, we also need to use the same
// blinding base:
let b_blinding = sr_params.even_parameters.pc_gens.B_blinding;
// The randomness for the PedDLEQ proof will have to be the randomness
// used in the curve tree randomization, *plus* the randomness that was used
// to convert P to a permissible point, upon initial insertion into the tree.
let mut r_offset: P0::ScalarField = P0::ScalarField::zero();
let lcindex: usize = key_index.try_into().unwrap();
let mut p_prime: Affine<P0> = leaf_commitments[lcindex];
// TODO: this is basically repeating what's already done in
// sr_params creation, but I don't know how else to extract the number
// of H bumps that were done (and we need to, see previous comment).
while !sr_params.even_parameters.uh.is_permissible(p_prime) {
p_prime = (p_prime + b_blinding).into();
r_offset += P0::ScalarField::one();
}
// print the root of the curve tree.
// TODO: how to allow the return value to be either
// Affine<P0> or Affine<P1>? And as a consequence,
// to let the code be correct for any depth.
// And/or, is there not
// a simpler way to extract the root of the tree
// (which should be just .parent_commitment, but all methods
// to extract this value seem to be private)
let newpath = curve_tree.select_and_rerandomize_verification_commitments(
path_commitments.clone());
let root_is_odd = newpath.even_commitments.len() == newpath.odd_commitments.len();
println!("Root is odd? {}", root_is_odd);
let root: Affine<P0>;
if !root_is_odd {
root = *newpath.even_commitments.first().unwrap();
}
else {
// derp, see above TODO
panic!("Wrong root parity, should be even");
}
let p0_proof = p0_prover
.prove(&sr_params.even_parameters.bp_gens)
.unwrap();
let p1_proof = p1_prover
.prove(&sr_params.odd_parameters.bp_gens)
.unwrap();
let returned_rand = rand_scalar + r_offset;
(p0_proof, p1_proof, path_commitments,
returned_rand, b_blinding, root, privkey_parity_flip)
}
#[pymodule]
fn autct(py: Python, m: &PyModule) -> PyResult<()> {
m.add_function(wrap_pyfunction!(get_curve_tree_with_proof, m)?)?;
Ok(())
}
AdamISZ
I was thinking about creating python bindings for aut-ct so that it can be easily used in joinstr. Does it make sense or we have better alternatives?