Add algebraic cap hash

Author: alexander-zw

libiop/bcs/hashing/algebraic_sponge.hpp

@@ -99,14 +99,15 @@ class algebraic_hashchain : public hashchain<FieldT, MT_root_type>
     void absorb_internal(const typename libff::enable_if<std::is_same<MT_root_type, FieldT>::value, MT_root_type>::type new_input);
 };
 
+/** The algebraic_vector_hash is used for both the algebraic leaf hash and cap hash. */
 template<typename FieldT>
-class algebraic_leafhash : public leafhash<FieldT, FieldT>
+class algebraic_vector_hash : public leafhash<FieldT, FieldT>
 {
     protected:
     std::shared_ptr<algebraic_sponge<FieldT>> sponge_;
 
     public:
-    algebraic_leafhash(
+    algebraic_vector_hash(
         std::shared_ptr<algebraic_sponge<FieldT>> sponge,
         size_t security_parameter);
     FieldT hash(const std::vector<FieldT> &leaf);
@@ -115,6 +116,9 @@ class algebraic_leafhash : public leafhash<FieldT, FieldT>
         const zk_salt_type &zk_salt);
 };
 
+template<typename FieldT>
+using algebraic_leafhash = algebraic_vector_hash<FieldT>;
+
 template<typename FieldT>
 class algebraic_two_to_one_hash
 {

libiop/bcs/hashing/algebraic_sponge.tcc

@@ -206,7 +206,7 @@ MT_root_type algebraic_hashchain<FieldT, MT_root_type>::squeeze_root_type()
 }
 
 template<typename FieldT>
-algebraic_leafhash<FieldT>::algebraic_leafhash(
+algebraic_vector_hash<FieldT>::algebraic_vector_hash(
     std::shared_ptr<algebraic_sponge<FieldT>> sponge,
     size_t security_parameter) :
     sponge_(sponge->new_sponge())
@@ -218,7 +218,7 @@ algebraic_leafhash<FieldT>::algebraic_leafhash(
 }
 
 template<typename FieldT>
-FieldT algebraic_leafhash<FieldT>::hash(
+FieldT algebraic_vector_hash<FieldT>::hash(
     const std::vector<FieldT> &leaf)
 {
     this->sponge_->absorb(leaf);
@@ -228,7 +228,7 @@ FieldT algebraic_leafhash<FieldT>::hash(
 }
 
 template<typename FieldT>
-FieldT algebraic_leafhash<FieldT>::zk_hash(
+FieldT algebraic_vector_hash<FieldT>::zk_hash(
     const std::vector<FieldT> &leaf,
     const zk_salt_type &zk_salt)
 {

libiop/bcs/hashing/hash_enum.tcc

@@ -100,9 +100,8 @@ std::shared_ptr<leafhash<FieldT, leaf_hash_type>> get_leafhash_internal(
         poseidon_params<FieldT> params = get_poseidon_parameters<FieldT>(hash_enum);
         /* security parameter is -1 b/c */
         std::shared_ptr<poseidon<FieldT>> permutation = std::make_shared<poseidon<FieldT>>(params);
-        std::shared_ptr<leafhash<FieldT, leaf_hash_type>> leafhasher = std::make_shared<algebraic_leafhash<FieldT>>(
-            permutation, 
-            security_parameter - 1);
+        std::shared_ptr<leafhash<FieldT, leaf_hash_type>> leafhasher =
+            std::make_shared<algebraic_leafhash<FieldT>>(permutation, security_parameter - 1);
         return leafhasher;
     }
     throw std::invalid_argument("bcs_hash_type unknown (algebraic leaf hash)");
@@ -149,7 +148,7 @@ two_to_one_hash_function<FieldT> get_two_to_one_hash_internal(
            as this reference has to live after the function terminates */
         std::shared_ptr<algebraic_two_to_one_hash<FieldT>> hash_class = 
             std::make_shared<algebraic_two_to_one_hash<FieldT>>(permutation, security_parameter - 1);
-        std::function<FieldT(const FieldT&, const FieldT&, const std::size_t)> f = [permutation, hash_class](const FieldT& left, const FieldT& right, const std::size_t unused) -> FieldT 
+        std::function<FieldT(const FieldT&, const FieldT&, const std::size_t)> f = [permutation, hash_class](const FieldT& left, const FieldT& right, const std::size_t unused) -> FieldT
         {
             return hash_class->hash(left, right);
         };
@@ -185,25 +184,25 @@ cap_hash_function<FieldT> get_cap_hash_internal(
     const bcs_hash_type hash_enum,
     const size_t security_parameter)
 {
-    // if (hash_enum == starkware_poseidon_type || hash_enum == high_alpha_poseidon_type)
-    // {
-    //     if (security_parameter != 128)
-    //     {
-    //         throw std::invalid_argument("Poseidon only supported for 128 bit soundness.");
-    //     }
-    //     poseidon_params<FieldT> params = get_poseidon_parameters<FieldT>(hash_enum);
-    //     /* security parameter is -1 b/c */
-    //     std::shared_ptr<algebraic_sponge<FieldT>> permutation = std::make_shared<poseidon<FieldT>>(params);
-    //     /* We explicitly place this on heap with no destructor,
-    //        as this reference has to live after the function terminates */
-    //     std::shared_ptr<algebraic_two_to_one_hash<FieldT>> hash_class =
-    //         std::make_shared<algebraic_two_to_one_hash<FieldT>>(permutation, security_parameter - 1);
-    //     std::function<FieldT(const FieldT&, const FieldT&, const std::size_t)> f = [permutation, hash_class](const FieldT& left, const FieldT& right, const std::size_t unused) -> FieldT 
-    //     {
-    //         return hash_class->hash(left, right);
-    //     };
-    //     return f;
-    // }
+    if (hash_enum == starkware_poseidon_type || hash_enum == high_alpha_poseidon_type)
+    {
+        if (security_parameter != 128)
+        {
+            throw std::invalid_argument("Poseidon only supported for 128 bit soundness.");
+        }
+        poseidon_params<FieldT> params = get_poseidon_parameters<FieldT>(hash_enum);
+        /* security parameter is -1 b/c */
+        std::shared_ptr<algebraic_sponge<FieldT>> permutation = std::make_shared<poseidon<FieldT>>(params);
+        /* We explicitly place this on heap with no destructor,
+           as this reference has to live after the function terminates */
+        std::shared_ptr<algebraic_vector_hash<FieldT>> hash_class =
+            std::make_shared<algebraic_vector_hash<FieldT>>(permutation, security_parameter - 1);
+        std::function<FieldT(const std::vector<FieldT> &leaf, const std::size_t)> f = [permutation, hash_class](const std::vector<FieldT> &leaf, const std::size_t unused) -> FieldT
+        {
+            return hash_class->hash(leaf);
+        };
+        return f;
+    }
     throw std::invalid_argument("bcs_hash_type unknown (algebraic cap hash)");
 }