add fluence mock back

backend_fluence/src/error_type.rs

@@ -0,0 +1,19 @@
+/*
+ * 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/lib.rs

@@ -0,0 +1,46 @@
+mod error_type;
+mod proof_manager;
+mod request_response;
+
+use crate::error_type::AppResult;
+use crate::proof_manager::ProofManager;
+use crate::request_response::{Request, Response};
+
+use fluence::sdk::*;
+use serde_json::Value;
+use std::cell::RefCell;
+
+thread_local! {
+    static PROOF_MANAGER: RefCell<ProofManager> = RefCell::new(ProofManager::new());
+}
+
+fn do_request(req: String) -> AppResult<Value> {
+    let request: Request = serde_json::from_str(req.as_str())?;
+
+    match request {
+
+        Request::Verify {
+            proof_id,
+            public_par,
+            proof,
+        } => PROOF_MANAGER.with(|gm| gm.borrow_mut().verify(proof_id, public_par, proof)),
+
+        Request::Check {
+            proof_id,
+        } => PROOF_MANAGER.with(|gm| gm.borrow_mut().check(proof_id))
+
+    }
+}
+
+#[invocation_handler]
+fn main(req: String) -> String {
+    match do_request(req) {
+        Ok(res) => res.to_string(),
+        Err(err) => {
+            let response = Response::Error {
+                message: err.to_string(),
+            };
+            serde_json::to_string(&response).unwrap()
+        }
+    }
+}

backend_fluence/src/proof_manager.rs

@@ -0,0 +1,359 @@
+use crate::error_type::AppResult;
+use crate::request_response::Response;
+
+use bellman_ce::groth16::*;
+
+use linked_hash_map::LinkedHashMap;
+use serde_json::Value;
+
+pub struct ProofManager {
+    // map from job id to verify status
+    proofs: LinkedHashMap<u64, u8>,
+}
+
+impl ProofManager {
+
+    pub fn new() -> Self {
+        ProofManager {
+            proofs: LinkedHashMap::new(),
+        }
+    }
+
+    pub fn verify(&mut self, proof_id: u64, public_par: [u64; 5], proof: [u64; 8]) -> AppResult<Value> {
+
+        // verify mock
+        let result: u8 = 1;
+        //test_xordemo();
+
+        // update proof status
+        self.proofs.insert(proof_id, result);
+
+        let response = Response::Verify {
+            result : result,
+        };
+
+        serde_json::to_value(response).map_err(Into::into)
+    }
+
+
+
+    pub fn check(&self, proof_id: u64) -> AppResult<Value> {
+        let status = self.proof_status(proof_id)?;
+        let response = Response::Check { verifed: status };
+
+        serde_json::to_value(response).map_err(Into::into)
+    }
+
+    fn proof_status(&self, proof_id: u64) -> AppResult<u8> {
+        let status = self
+            .proofs
+            .get(&proof_id)
+            .ok_or_else(|| format!("Proof with id {} wasn't found", proof_id))?;
+
+        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

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+
+
+#[derive(Serialize, Deserialize)]
+#[serde(tag = "action")]
+pub enum Request {
+    Verify {
+        proof_id: u64,
+        public_par: [u64; 5],
+        proof: [u64; 8],
+    },
+    Check {
+        proof_id: u64,
+    },
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Response {
+    Verify { result: u8 },
+    Check { verifed: u8 },
+    Error { message: String },
+}

backend_fluence/src/tests.rs

@@ -0,0 +1,130 @@
+/*
+ * 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 crate::request_response::{Request, Response};
+use crate::main;
+
+// TODO: add more tests
+
+#[test]
+fn correct_bets() {
+    let response = Response::Join { player_id: 0 };
+    assert_eq!(
+        main(create_join_request()),
+        serde_json::to_string(&response).unwrap()
+    );
+
+    let response = Response::Join { player_id: 1 };
+    assert_eq!(
+        main(create_join_request()),
+        serde_json::to_string(&response).unwrap()
+    );
+
+    let response = Response::Bet {
+        outcome: 6,
+        player_balance: 85,
+    };
+    assert_eq!(
+        main(create_bet_json(0, 1, 15)),
+        serde_json::to_string(&response).unwrap()
+    );
+
+    let response = Response::Bet {
+        outcome: 4,
+        player_balance: 85,
+    };
+    assert_eq!(
+        main(create_bet_json(1, 1, 15)),
+        serde_json::to_string(&response).unwrap()
+    );
+
+    let response = Response::Bet {
+        outcome: 6,
+        player_balance: 510,
+    };
+    assert_eq!(
+        main(create_bet_json(0, 6, 85)),
+        serde_json::to_string(&response).unwrap()
+    );
+
+    let response = Response::Bet {
+        outcome: 2,
+        player_balance: 0,
+    };
+    assert_eq!(
+        main(create_bet_json(1, 1, 85)),
+        serde_json::to_string(&response).unwrap()
+    );
+
+    let response = Response::GetBalance {
+        player_balance: 510,
+    };
+    assert_eq!(
+        main(create_get_balance_json(0)),
+        serde_json::to_string(&response).unwrap()
+    );
+}
+
+#[test]
+fn incorrect_bets() {
+    let response = Response::Join { player_id: 0 };
+    assert_eq!(
+        main(create_join_request()),
+        serde_json::to_string(&response).unwrap()
+    );
+
+    let response = Response::Error {
+        message: "Incorrect placement, please choose number from 1 to 6".to_string(),
+    };
+    assert_eq!(
+        main(create_bet_json(0, 7, 15)),
+        serde_json::to_string(&response).unwrap()
+    );
+
+    let response = Response::Error {
+        message: "Player with id 1 wasn\'t found".to_string(),
+    };
+    assert_eq!(
+        main(create_bet_json(1, 1, 0)),
+        serde_json::to_string(&response).unwrap()
+    );
+
+    let response = Response::Error {
+        message: "Player hasn\'t enough money: player\'s current balance is 100 while the bet is 4294967295".to_string()
+    };
+    assert_eq!(
+        main(create_bet_json(0, 6, std::u32::MAX)),
+        serde_json::to_string(&response).unwrap()
+    );
+}
+
+fn create_join_request() -> String {
+    let request = Request::Join;
+    serde_json::to_value(request).unwrap().to_string()
+}
+
+fn create_bet_json(player_id: u64, placement: u8, bet_amount: u32) -> String {
+    let request = Request::Bet {
+        player_id,
+        placement,
+        bet_amount,
+    };
+    serde_json::to_value(request).unwrap().to_string()
+}
+
+fn create_get_balance_json(player_id: u64) -> String {
+    let request = Request::GetBalance { player_id };
+    serde_json::to_value(request).unwrap().to_string()
+}