finished adding final commands: ec_get_u, alloc/clone_bit, binary_push, scalar_alloc, conditionally_reverse, scalar_as_binary, scalar_enforce_equal, emit_scalar

proofs/simple.pism

@@ -9,6 +9,8 @@ contract input_spend
     param secret Fr
     param ak Point
     param value U64
+    param is_cool Bool
+    param path Scalar
 start
     # Compute P = xG + A
     witness ak param:ak
@@ -35,7 +37,21 @@ start
     #binary_truncate ivk2 JUBJUB_FR_CAPACITY
     #u64_as_binary_le value_bits param:value
     #ec_mul pk_d value_bits public
-    #pedersen_hash cm ivk NOTE_COMMIT
-    #ec_get_u cur cm
+
+    pedersen_hash cm ivk NOTE_COMMIT
+    ec_get_u cur cm
+    
+    alloc_bit is_cool param:is_cool
+    clone_bit is_cool2 is_cool
+    binary_push ivk is_cool2
+
+    alloc_scalar path param:path
+    conditionally_reverse ul ur cur path is_cool
+
+    scalar_as_binary ul_bin ul
+    binary_extend preimage ul_bin
+
+    scalar_enforce_equal ur ul
+    emit_scalar ur
 end
 

proofs/working.pism

@@ -128,9 +128,7 @@ start
     binary_push position cur_is_right2
     alloc_num path_element param:auth_path_0_0
     # let (left: Scalar, right: Scalar) = swap_if(is_right, cur, node)
-    conditionally_reverse ulur cur path_element is_right
-    get_0 ul ulur
-    get_1 ur ulur
+    conditionally_reverse ul ur cur path_element is_right
     # let mut preimage: BinaryNumber = []
     alloc_binary preimage
     # preimage.put(left)

scripts/codegen.py

@@ -55,6 +55,9 @@ def binary_clone(line, out, binary):
 def binary_extend(line, binary, value):
     return "%s.extend(%s);" % (binary, value)
 
+def binary_push(line, binary, bit):
+    return "%s.push(%s);" % (binary, bit)
+
 def binary_truncate(line, binary, size):
     return "%s.truncate(%s);" % (binary, size)
 
@@ -81,3 +84,45 @@ def emit_binary(line, binary):
     return 'multipack::pack_into_inputs(cs.namespace(|| "%s"), &%s)?;' % (
         line, binary)
 
+def alloc_bit(line, out, value):
+    return \
+r"""let %s = boolean::Boolean::from(boolean::AllocatedBit::alloc(
+    cs.namespace(|| "%s"),
+    %s
+)?);""" % (out, line, value)
+
+def clone_bit(line, out, value):
+    return "let %s = %s.clone();" % (out, value)
+
+def alloc_scalar(line, out, scalar):
+    return \
+r"""let %s =
+    num::AllocatedNum::alloc(cs.namespace(|| "%s"), || Ok(*%s.get()?))?;""" % (
+    out, line, scalar)
+
+def scalar_as_binary(line, out, scalar):
+    return 'let %s = %s.to_bits_le(cs.namespace(|| "%s"))?;' % (out, scalar,
+                                                                line)
+
+def emit_scalar(line, scalar):
+    return '%s.inputize(cs.namespace(|| "%s"))?;' % (scalar, line)
+
+def scalar_enforce_equal(line, scalar_left, scalar_right):
+    return \
+r"""cs.enforce(
+    || "%s",
+    |lc| lc + %s.get_variable(),
+    |lc| lc + CS::one(),
+    |lc| lc + %s.get_variable(),
+);""" % (line, scalar_left, scalar_right)
+
+def conditionally_reverse(line, out_left, out_right, in_left, in_right,
+                          condition):
+    return \
+r"""let (%s, %s) = num::AllocatedNum::conditionally_reverse(
+    cs.namespace(|| "%s"),
+    &%s,
+    &%s,
+    &%s,
+)?;""" % (out_left, out_right, line, in_left, in_right, condition)
+

scripts/pism.py

@@ -72,6 +72,10 @@ command_desc = {
         ("Vec<Boolean>",    False),
         ("Vec<Boolean>",    False),
     ),
+    "binary_push": (
+        ("Vec<Boolean>",    False),
+        ("Boolean",         False),
+    ),
     "binary_truncate": (
         ("Vec<Boolean>",    False),
         ("BinarySize",      False),
@@ -93,6 +97,36 @@ command_desc = {
     "emit_binary": (
         ("Vec<Boolean>",    False),
     ),
+    "alloc_bit": (
+        ("Boolean",         True),
+        ("Bool",            False),
+    ),
+    "clone_bit": (
+        ("Boolean",         True),
+        ("Boolean",         False),
+    ),
+    "alloc_scalar": (
+        ("ScalarNum",       True),
+        ("Scalar",          False),
+    ),
+    "scalar_as_binary": (
+        ("Vec<Boolean>",    True),
+        ("ScalarNum",       False),
+    ),
+    "emit_scalar": (
+        ("ScalarNum",       False),
+    ),
+    "scalar_enforce_equal": (
+        ("ScalarNum",       False),
+        ("ScalarNum",       False),
+    ),
+    "conditionally_reverse": (
+        ("Scalar",          True),
+        ("Scalar",          True),
+        ("Scalar",          False),
+        ("Scalar",          False),
+        ("Boolean",         False),
+    ),
 }
 
 def eprint(*args):
@@ -252,6 +286,8 @@ r"""use bellman::{
         boolean::{AllocatedBit, Boolean},
         multipack,
         blake2s,
+        num,
+        Assignment,
     },
     groth16, Circuit, ConstraintSystem, SynthesisError,
 };

src/simple.rs

@@ -21,6 +21,8 @@ fn main() {
             secret: None,
             ak: None,
             value: None,
+            is_cool: None,
+            path: None,
         };
         groth16::generate_random_parameters::<Bls12, _, _>(c, &mut OsRng).unwrap()
     };
@@ -30,6 +32,8 @@ fn main() {
         secret: Some(secret),
         ak: Some(ak),
         value: Some(110),
+        is_cool: Some(true),
+        path: Some(bls12_381::Scalar::one()),
     };
 
     let proof = groth16::create_random_proof(c, &params, &mut OsRng).unwrap();