work for demo

backend_fluence/.idea/workspace.xml

@@ -21,35 +21,8 @@
       <file pinned="false" current-in-tab="true">
         <entry file="file://$PROJECT_DIR$/src/proof_manager.rs">
           <provider selected="true" editor-type-id="text-editor">
-            <state relative-caret-position="-1575">
+            <state relative-caret-position="-15">
-              <caret line="3" column="26" selection-start-line="3" selection-start-column="26" selection-end-line="3" selection-end-column="26" />
+              <caret line="8" column="25" lean-forward="true" selection-start-line="8" selection-start-column="25" selection-end-line="8" selection-end-column="25" />
-            </state>
-          </provider>
-        </entry>
-      </file>
-      <file pinned="false" current-in-tab="false">
-        <entry file="file://$USER_HOME$/.cargo/registry/src/github.com-1ecc6299db9ec823/bellman_ce-0.3.0/src/lib.rs">
-          <provider selected="true" editor-type-id="text-editor">
-            <state relative-caret-position="75">
-              <caret line="5" column="17" lean-forward="true" selection-start-line="5" selection-start-column="17" selection-end-line="5" selection-end-column="17" />
-            </state>
-          </provider>
-        </entry>
-      </file>
-      <file pinned="false" current-in-tab="false">
-        <entry file="file://$PROJECT_DIR$/Cargo.toml">
-          <provider selected="true" editor-type-id="text-editor">
-            <state relative-caret-position="375">
-              <caret line="25" column="11" selection-start-line="25" selection-start-column="11" selection-end-line="25" selection-end-column="11" />
-            </state>
-          </provider>
-        </entry>
-      </file>
-      <file pinned="false" current-in-tab="false">
-        <entry file="file://$PROJECT_DIR$/src/lib.rs">
-          <provider selected="true" editor-type-id="text-editor">
-            <state relative-caret-position="30">
-              <caret line="2" column="21" selection-start-line="2" selection-start-column="21" selection-end-line="2" selection-end-column="21" />
             </state>
           </provider>
         </entry>
@@ -67,7 +40,7 @@
   <component name="MacroExpansionManager">
     <option name="directoryName" value="yNaPhLBk" />
   </component>
-  <component name="ProjectFrameBounds" extendedState="7">
+  <component name="ProjectFrameBounds" extendedState="6">
     <option name="x" value="67" />
     <option name="y" value="25" />
     <option name="width" value="767" />
@@ -86,11 +59,6 @@
               <item name="backend_fluence" type="b2602c69:ProjectViewProjectNode" />
               <item name="backend_fluence" type="462c0819:PsiDirectoryNode" />
             </path>
-            <path>
-              <item name="backend_fluence" type="b2602c69:ProjectViewProjectNode" />
-              <item name="backend_fluence" type="462c0819:PsiDirectoryNode" />
-              <item name="src" type="462c0819:PsiDirectoryNode" />
-            </path>
           </expand>
           <select />
         </subPane>
@@ -159,17 +127,18 @@
     <servers />
   </component>
   <component name="ToolWindowManager">
-    <frame x="67" y="25" width="1533" height="875" extended-state="7" />
+    <frame x="67" y="25" width="1533" height="875" extended-state="6" />
+    <editor active="true" />
     <layout>
       <window_info id="Image Layers" />
       <window_info id="Designer" />
       <window_info id="UI Designer" />
       <window_info id="Capture Tool" />
       <window_info id="Favorites" side_tool="true" />
-      <window_info active="true" content_ui="combo" id="Project" order="0" visible="true" weight="0.24949563" />
+      <window_info active="true" content_ui="combo" id="Project" order="0" visible="true" weight="0.1472764" />
       <window_info id="Structure" order="1" side_tool="true" weight="0.25" />
       <window_info anchor="bottom" id="Version Control" />
-      <window_info anchor="bottom" id="Terminal" visible="true" weight="0.328877" />
+      <window_info anchor="bottom" id="Terminal" visible="true" weight="0.1644385" />
       <window_info anchor="bottom" id="Event Log" side_tool="true" />
       <window_info anchor="bottom" id="Message" order="0" />
       <window_info anchor="bottom" id="Find" order="1" />
@@ -202,7 +171,7 @@
     </entry>
     <entry file="file://$PROJECT_DIR$/src/lib.rs">
       <provider selected="true" editor-type-id="text-editor">
-        <state relative-caret-position="30">
+        <state relative-caret-position="-60">
           <caret line="2" column="21" selection-start-line="2" selection-start-column="21" selection-end-line="2" selection-end-column="21" />
         </state>
       </provider>
@@ -216,8 +185,8 @@
     </entry>
     <entry file="file://$PROJECT_DIR$/src/proof_manager.rs">
       <provider selected="true" editor-type-id="text-editor">
-        <state relative-caret-position="-1575">
+        <state relative-caret-position="-15">
-          <caret line="3" column="26" selection-start-line="3" selection-start-column="26" selection-end-line="3" selection-end-column="26" />
+          <caret line="8" column="25" lean-forward="true" selection-start-line="8" selection-start-column="25" selection-end-line="8" selection-end-column="25" />
         </state>
       </provider>
     </entry>

backend_fluence/src/error_type.rs

@@ -1,19 +1,3 @@
-/*
- * Copyright 2018 Fluence Labs Limited
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 use std::error::Error;
 
 pub type AppResult<T> = ::std::result::Result<T, Box<Error>>;

backend_fluence/src/proof_manager.rs

@@ -1,5 +1,6 @@
 use crate::error_type::AppResult;
 use crate::request_response::Response;
+use std::io::{Cursor, Read, Seek, SeekFrom, Write};
 
 use bellman_ce::groth16::*;
 
@@ -19,11 +20,43 @@ impl ProofManager {
         }
     }
 
-    pub fn verify(&mut self, proof_id: u64, public_par: [u64; 5], proof: [u64; 8]) -> AppResult<Value> {
+    pub fn verify(&mut self, proof_id: u64, public_par: [f64; 5], proof: [f64; 8]) -> AppResult<Value> {
 
         // verify mock
-        let result: u8 = 1;
+        let mut result: u8 = 1;
-        //test_xordemo();
+        if proof[0] != 8.51065254754666e75 {
+            result = 0
+        }
+
+        /*
+        let tt = "99999";
+
+        let mut c = Cursor::new(Vec::new());
+
+        // Write into the "file" and seek to the beginning
+        c.write_all(tt.as_bytes()).unwrap();
+        c.seek(SeekFrom::Start(0)).unwrap();
+
+
+
+        
+        let pvk = {
+
+        } 
+
+        let proof = {
+
+        }
+
+        let pub_input = {
+
+        }
+
+        result_bool = verify_proof(
+            &pvk,
+            &proof,
+            &[Fr::one()]
+        ).unwrap();*/
 
         // update proof status
         self.proofs.insert(proof_id, result);
@@ -35,11 +68,64 @@ impl ProofManager {
         serde_json::to_value(response).map_err(Into::into)
     }
 
+    /*pub fn read<R: Read>(
+        mut reader: R
+    ) -> io::Result<Self>
+    {
+        let mut g1_repr = <E::G1Affine as CurveAffine>::Uncompressed::empty();
+        let mut g2_repr = <E::G2Affine as CurveAffine>::Uncompressed::empty();
+
+        reader.read_exact(g1_repr.as_mut())?;
+        let alpha_g1 = g1_repr.into_affine().map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        reader.read_exact(g1_repr.as_mut())?;
+        let beta_g1 = g1_repr.into_affine().map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        reader.read_exact(g2_repr.as_mut())?;
+        let beta_g2 = g2_repr.into_affine().map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        reader.read_exact(g2_repr.as_mut())?;
+        let gamma_g2 = g2_repr.into_affine().map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        reader.read_exact(g1_repr.as_mut())?;
+        let delta_g1 = g1_repr.into_affine().map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        reader.read_exact(g2_repr.as_mut())?;
+        let delta_g2 = g2_repr.into_affine().map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        let ic_len = reader.read_u32::<BigEndian>()? as usize;
+
+        let mut ic = vec![];
+
+        for _ in 0..ic_len {
+            reader.read_exact(g1_repr.as_mut())?;
+            let g1 = g1_repr
+                .into_affine()
+                .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+                .and_then(|e| if e.is_zero() {
+                    Err(io::Error::new(io::ErrorKind::InvalidData, "point at infinity"))
+                } else {
+                    Ok(e)
+                })?;
+
+            ic.push(g1);
+        }
+
+        Ok(VerifyingKey {
+            alpha_g1: alpha_g1,
+            beta_g1: beta_g1,
+            beta_g2: beta_g2,
+            gamma_g2: gamma_g2,
+            delta_g1: delta_g1,
+            delta_g2: delta_g2,
+            ic: ic
+        })
+    }*/
 
 
     pub fn check(&self, proof_id: u64) -> AppResult<Value> {
         let status = self.proof_status(proof_id)?;
-        let response = Response::Check { verifed: status };
+        let response = Response::Check { verified: status };
 
         serde_json::to_value(response).map_err(Into::into)
     }
@@ -52,308 +138,4 @@ impl ProofManager {
 
         Ok(*status)
     }
-/*
-    fn test_xordemo() {
-        let g1 = Fr::one();
-        let g2 = Fr::one();
-        let alpha = Fr::from_str("48577").unwrap();
-        let beta = Fr::from_str("22580").unwrap();
-        let gamma = Fr::from_str("53332").unwrap();
-        let delta = Fr::from_str("5481").unwrap();
-        let tau = Fr::from_str("3673").unwrap();
-
-        let params = {
-            let c = XORDemo::<DummyEngine> {
-                a: None,
-                b: None,
-                _marker: PhantomData
-            };
-
-            generate_parameters(
-                c,
-                g1,
-                g2,
-                alpha,
-                beta,
-                gamma,
-                delta,
-                tau
-            ).unwrap()
-        };
-
-        // This will synthesize the constraint system:
-        //
-        // public inputs: a_0 = 1, a_1 = c
-        // aux inputs: a_2 = a, a_3 = b
-        // constraints:
-        //     (a_0 - a_2) * (a_2) = 0
-        //     (a_0 - a_3) * (a_3) = 0
-        //     (a_2 + a_2) * (a_3) = (a_2 + a_3 - a_1)
-        //     (a_0) * 0 = 0
-        //     (a_1) * 0 = 0
-
-        // The evaluation domain is 8. The H query should
-        // have 7 elements (it's a quotient polynomial)
-        assert_eq!(7, params.h.len());
-
-        let mut root_of_unity = Fr::root_of_unity();
-
-        // We expect this to be a 2^10 root of unity
-        assert_eq!(Fr::one(), root_of_unity.pow(&[1 << 10]));
-
-        // Let's turn it into a 2^3 root of unity.
-        root_of_unity = root_of_unity.pow(&[1 << 7]);
-        assert_eq!(Fr::one(), root_of_unity.pow(&[1 << 3]));
-        assert_eq!(Fr::from_str("20201").unwrap(), root_of_unity);
-
-        // Let's compute all the points in our evaluation domain.
-        let mut points = Vec::with_capacity(8);
-        for i in 0..8 {
-            points.push(root_of_unity.pow(&[i]));
-        }
-
-        // Let's compute t(tau) = (tau - p_0)(tau - p_1)...
-        //                      = tau^8 - 1
-        let mut t_at_tau = tau.pow(&[8]);
-        t_at_tau.sub_assign(&Fr::one());
-        {
-            let mut tmp = Fr::one();
-            for p in &points {
-                let mut term = tau;
-                term.sub_assign(p);
-                tmp.mul_assign(&term);
-            }
-            assert_eq!(tmp, t_at_tau);
-        }
-
-        // We expect our H query to be 7 elements of the form...
-        // {tau^i t(tau) / delta}
-        let delta_inverse = delta.inverse().unwrap();
-        let gamma_inverse = gamma.inverse().unwrap();
-        {
-            let mut coeff = delta_inverse;
-            coeff.mul_assign(&t_at_tau);
-
-            let mut cur = Fr::one();
-            for h in params.h.iter() {
-                let mut tmp = cur;
-                tmp.mul_assign(&coeff);
-
-                assert_eq!(*h, tmp);
-
-                cur.mul_assign(&tau);
-            }
-        }
-
-        // The density of the IC query is 2 (2 inputs)
-        assert_eq!(2, params.vk.ic.len());
-
-        // The density of the L query is 2 (2 aux variables)
-        assert_eq!(2, params.l.len());
-
-        // The density of the A query is 4 (each variable is in at least one A term)
-        assert_eq!(4, params.a.len());
-
-        // The density of the B query is 2 (two variables are in at least one B term)
-        assert_eq!(2, params.b_g1.len());
-        assert_eq!(2, params.b_g2.len());
-
-        /*
-        Lagrange interpolation polynomials in our evaluation domain:
-
-        ,-------------------------------. ,-------------------------------. ,-------------------------------.
-        |            A TERM             | |            B TERM             | |            C TERM             |
-        `-------------------------------. `-------------------------------' `-------------------------------'
-        | a_0   | a_1   | a_2   | a_3   | | a_0   | a_1   | a_2   | a_3   | | a_0   | a_1   | a_2   | a_3   |
-        | 1     | 0     | 64512 | 0     | | 0     | 0     | 1     | 0     | | 0     | 0     | 0     | 0     |
-        | 1     | 0     | 0     | 64512 | | 0     | 0     | 0     | 1     | | 0     | 0     | 0     | 0     |
-        | 0     | 0     | 2     | 0     | | 0     | 0     | 0     | 1     | | 0     | 64512 | 1     | 1     |
-        | 1     | 0     | 0     | 0     | | 0     | 0     | 0     | 0     | | 0     | 0     | 0     | 0     |
-        | 0     | 1     | 0     | 0     | | 0     | 0     | 0     | 0     | | 0     | 0     | 0     | 0     |
-        `-------'-------'-------'-------' `-------'-------'-------'-------' `-------'-------'-------'-------'
-
-        Example for u_0:
-
-        sage: r = 64513
-        sage: Fr = GF(r)
-        sage: omega = (Fr(5)^63)^(2^7)
-        sage: tau = Fr(3673)
-        sage: R.<x> = PolynomialRing(Fr, 'x')
-        sage: def eval(tau, c0, c1, c2, c3, c4):
-        ....:     p = R.lagrange_polynomial([(omega^0, c0), (omega^1, c1), (omega^2, c2), (omega^3, c3), (omega^4, c4), (omega^5, 0), (omega^6, 0), (omega^7, 0)])
-        ....:     return p.substitute(tau)
-        sage: eval(tau, 1, 1, 0, 1, 0)
-        59158
-        */
-
-        let u_i = [59158, 48317, 21767, 10402].iter().map(|e| {
-            Fr::from_str(&format!("{}", e)).unwrap()
-        }).collect::<Vec<Fr>>();
-        let v_i = [0, 0, 60619, 30791].iter().map(|e| {
-            Fr::from_str(&format!("{}", e)).unwrap()
-        }).collect::<Vec<Fr>>();
-        let w_i = [0, 23320, 41193, 41193].iter().map(|e| {
-            Fr::from_str(&format!("{}", e)).unwrap()
-        }).collect::<Vec<Fr>>();
-
-        for (u, a) in u_i.iter()
-            .zip(&params.a[..])
-            {
-                assert_eq!(u, a);
-            }
-
-        for (v, b) in v_i.iter()
-            .filter(|&&e| e != Fr::zero())
-            .zip(&params.b_g1[..])
-            {
-                assert_eq!(v, b);
-            }
-
-        for (v, b) in v_i.iter()
-            .filter(|&&e| e != Fr::zero())
-            .zip(&params.b_g2[..])
-            {
-                assert_eq!(v, b);
-            }
-
-        for i in 0..4 {
-            let mut tmp1 = beta;
-            tmp1.mul_assign(&u_i[i]);
-
-            let mut tmp2 = alpha;
-            tmp2.mul_assign(&v_i[i]);
-
-            tmp1.add_assign(&tmp2);
-            tmp1.add_assign(&w_i[i]);
-
-            if i < 2 {
-                // Check the correctness of the IC query elements
-                tmp1.mul_assign(&gamma_inverse);
-
-                assert_eq!(tmp1, params.vk.ic[i]);
-            } else {
-                // Check the correctness of the L query elements
-                tmp1.mul_assign(&delta_inverse);
-
-                assert_eq!(tmp1, params.l[i - 2]);
-            }
-        }
-
-        // Check consistency of the other elements
-        assert_eq!(alpha, params.vk.alpha_g1);
-        assert_eq!(beta, params.vk.beta_g1);
-        assert_eq!(beta, params.vk.beta_g2);
-        assert_eq!(gamma, params.vk.gamma_g2);
-        assert_eq!(delta, params.vk.delta_g1);
-        assert_eq!(delta, params.vk.delta_g2);
-
-        let pvk = prepare_verifying_key(&params.vk);
-
-        let r = Fr::from_str("27134").unwrap();
-        let s = Fr::from_str("17146").unwrap();
-
-        let proof = {
-            let c = XORDemo {
-                a: Some(true),
-                b: Some(false),
-                _marker: PhantomData
-            };
-
-            create_proof(
-                c,
-                &params,
-                r,
-                s
-            ).unwrap()
-        };
-
-        // A(x) =
-        //  a_0 * (44865*x^7 + 56449*x^6 + 44865*x^5 + 8064*x^4 + 3520*x^3 + 56449*x^2 + 3520*x + 40321) +
-        //  a_1 * (8064*x^7 + 56449*x^6 + 8064*x^5 + 56449*x^4 + 8064*x^3 + 56449*x^2 + 8064*x + 56449) +
-        //  a_2 * (16983*x^7 + 24192*x^6 + 63658*x^5 + 56449*x^4 + 16983*x^3 + 24192*x^2 + 63658*x + 56449) +
-        //  a_3 * (5539*x^7 + 27797*x^6 + 6045*x^5 + 56449*x^4 + 58974*x^3 + 36716*x^2 + 58468*x + 8064) +
-        {
-            // proof A = alpha + A(tau) + delta * r
-            let mut expected_a = delta;
-            expected_a.mul_assign(&r);
-            expected_a.add_assign(&alpha);
-            expected_a.add_assign(&u_i[0]); // a_0 = 1
-            expected_a.add_assign(&u_i[1]); // a_1 = 1
-            expected_a.add_assign(&u_i[2]); // a_2 = 1
-            // a_3 = 0
-            assert_eq!(proof.a, expected_a);
-        }
-
-        // B(x) =
-        // a_0 * (0) +
-        // a_1 * (0) +
-        // a_2 * (56449*x^7 + 56449*x^6 + 56449*x^5 + 56449*x^4 + 56449*x^3 + 56449*x^2 + 56449*x + 56449) +
-        // a_3 * (31177*x^7 + 44780*x^6 + 21752*x^5 + 42255*x^3 + 35861*x^2 + 33842*x + 48385)
-        {
-            // proof B = beta + B(tau) + delta * s
-            let mut expected_b = delta;
-            expected_b.mul_assign(&s);
-            expected_b.add_assign(&beta);
-            expected_b.add_assign(&v_i[0]); // a_0 = 1
-            expected_b.add_assign(&v_i[1]); // a_1 = 1
-            expected_b.add_assign(&v_i[2]); // a_2 = 1
-            // a_3 = 0
-            assert_eq!(proof.b, expected_b);
-        }
-
-        // C(x) =
-        // a_0 * (0) +
-        // a_1 * (27797*x^7 + 56449*x^6 + 36716*x^5 + 8064*x^4 + 27797*x^3 + 56449*x^2 + 36716*x + 8064) +
-        // a_2 * (36716*x^7 + 8064*x^6 + 27797*x^5 + 56449*x^4 + 36716*x^3 + 8064*x^2 + 27797*x + 56449) +
-        // a_3 * (36716*x^7 + 8064*x^6 + 27797*x^5 + 56449*x^4 + 36716*x^3 + 8064*x^2 + 27797*x + 56449)
-        //
-        // If A * B = C at each point in the domain, then the following polynomial...
-        // P(x) = A(x) * B(x) - C(x)
-        //      = 49752*x^14 + 13914*x^13 + 29243*x^12 + 27227*x^11 + 62362*x^10 + 35703*x^9 + 4032*x^8 + 14761*x^6 + 50599*x^5 + 35270*x^4 + 37286*x^3 + 2151*x^2 + 28810*x + 60481
-        //
-        // ... should be divisible by t(x), producing the quotient polynomial:
-        // h(x) = P(x) / t(x)
-        //      = 49752*x^6 + 13914*x^5 + 29243*x^4 + 27227*x^3 + 62362*x^2 + 35703*x + 4032
-        {
-            let mut expected_c = Fr::zero();
-
-            // A * s
-            let mut tmp = proof.a;
-            tmp.mul_assign(&s);
-            expected_c.add_assign(&tmp);
-
-            // B * r
-            let mut tmp = proof.b;
-            tmp.mul_assign(&r);
-            expected_c.add_assign(&tmp);
-
-            // delta * r * s
-            let mut tmp = delta;
-            tmp.mul_assign(&r);
-            tmp.mul_assign(&s);
-            expected_c.sub_assign(&tmp);
-
-            // L query answer
-            // a_2 = 1, a_3 = 0
-            expected_c.add_assign(&params.l[0]);
-
-            // H query answer
-            for (i, coeff) in [5040, 11763, 10755, 63633, 128, 9747, 8739].iter().enumerate() {
-                let coeff = Fr::from_str(&format!("{}", coeff)).unwrap();
-
-                let mut tmp = params.h[i];
-                tmp.mul_assign(&coeff);
-                expected_c.add_assign(&tmp);
-            }
-
-            assert_eq!(expected_c, proof.c);
-        }
-
-        assert!(verify_proof(
-            &pvk,
-            &proof,
-            &[Fr::one()]
-        ).unwrap());
-    }*/
-
 }

backend_fluence/src/request_response.rs

@@ -6,8 +6,8 @@ use serde::{Deserialize, Serialize};
 pub enum Request {
     Verify {
         proof_id: u64,
-        public_par: [u64; 5],
+        public_par: [f64; 5],
-        proof: [u64; 8],
+        proof: [f64; 8],
     },
     Check {
         proof_id: u64,
@@ -18,6 +18,6 @@ pub enum Request {
 #[serde(untagged)]
 pub enum Response {
     Verify { result: u8 },
-    Check { verifed: u8 },
+    Check { verified: u8 },
     Error { message: String },
 }