diff --git a/examples/gg18_sm_manager.rs b/examples/gg18_sm_manager.rs
index 0bba186..efc18ab 100644
--- a/examples/gg18_sm_manager.rs
+++ b/examples/gg18_sm_manager.rs
@@ -7,6 +7,8 @@ use rocket::{post, routes, State};
 // #[cfg(not(target_arch = "wasm32"))]
 // use rocket::{Request, Response};
 #[cfg(not(target_arch = "wasm32"))]
+use rand::Rng;
+#[cfg(not(target_arch = "wasm32"))]
 use rocket_cors::{AllowedOrigins, CorsOptions};
 #[cfg(not(target_arch = "wasm32"))]
 use std::collections::HashMap;
@@ -57,20 +59,51 @@ fn signup_keygen(db_mtx: &State<RwLock<HashMap<Key, String>>>) -> Json<Result<Pa
     let parties = params.parties.parse::<u16>().unwrap();
 
     let key = "signup-keygen".to_string();
+    let key_partyid = "sum-partyid".to_string();
 
     let mut hm = db_mtx.write().unwrap();
-    let party_signup = {
+    let party_signup: PartySignup = {
         let value = hm.get(&key).unwrap();
+        let value_partyid = hm.get(&key_partyid).unwrap();
+        let vector_partyid: Vec<u32> = value_partyid
+            .chars()
+            .flat_map(|ch| ch.to_digit(10))
+            .collect();
+        let tmp: u32 = vector_partyid.iter().sum();
+        let sum_partyid = tmp as u16;
         let client_signup: PartySignup = serde_json::from_str(value).unwrap();
-        if client_signup.number < parties {
+        let sum_parties = (0..parties + 1).fold(0, |a, b| a + b);
+        if value_partyid.parse::<u16>().unwrap() == 0 {
+            let num = rand::thread_rng().gen_range(0, parties);
+            hm.insert(key_partyid, num.to_string());
             PartySignup {
-                number: client_signup.number + 1,
+                number: num,
+                uuid: client_signup.uuid,
+                is_owner: 1,
+            }
+        } else if sum_partyid < sum_parties {
+            let mut vector_parties: Vec<u32> = vec![];
+            for i in 1..sum_parties {
+                vector_parties.push(i.into());
+            }
+            let difference: Vec<u32> = vector_parties
+                .into_iter()
+                .filter(|item| !vector_partyid.contains(item))
+                .collect();
+            let tmp1 = format!("{}{}", value_partyid, difference[0].to_string());
+            hm.insert(key_partyid, tmp1);
+            PartySignup {
+                number: difference[0] as u16,
                 uuid: client_signup.uuid,
+                is_owner: 0,
             }
         } else {
+            let num = rand::thread_rng().gen_range(1, parties);
+            hm.insert(key_partyid, num.to_string());
             PartySignup {
-                number: 1,
+                number: num,
                 uuid: Uuid::new_v4().to_string(),
+                is_owner: 1,
             }
         }
     };
@@ -97,11 +130,13 @@ fn signup_sign(db_mtx: &State<RwLock<HashMap<Key, String>>>) -> Json<Result<Part
             PartySignup {
                 number: client_signup.number + 1,
                 uuid: client_signup.uuid,
+                is_owner: 0,
             }
         } else {
             PartySignup {
                 number: 1,
                 uuid: Uuid::new_v4().to_string(),
+                is_owner: 0,
             }
         }
     };
@@ -122,21 +157,27 @@ async fn main() {
 
     let keygen_key = "signup-keygen".to_string();
     let sign_key = "signup-sign".to_string();
+    let party_id = "sum-partyid".to_string();
 
     let uuid_keygen = Uuid::new_v4().to_string();
     let uuid_sign = Uuid::new_v4().to_string();
 
     let party1 = 0;
+    let is_owner1 = 0;
+    let sum_partyid = "0".to_string();
     let party_signup_keygen = PartySignup {
         number: party1,
         uuid: uuid_keygen,
+        is_owner: is_owner1,
     };
     let party_signup_sign = PartySignup {
         number: party1,
         uuid: uuid_sign,
+        is_owner: 0,
     };
     {
         let mut hm = db_mtx.write().unwrap();
+        hm.insert(party_id, sum_partyid);
         hm.insert(
             keygen_key,
             serde_json::to_string(&party_signup_keygen).unwrap(),
diff --git a/scripts/run_keygen_sign_node.js b/scripts/run_keygen_sign_node.js
index 4994d20..1f70415 100644
--- a/scripts/run_keygen_sign_node.js
+++ b/scripts/run_keygen_sign_node.js
@@ -1,10 +1,12 @@
 const gg18 = require('../pkg')
 const ethers = require('ethers')
 
-var items = [{ idx: 0 }, { idx: 1 }, { idx: 2 }]
+
+
+var items = [{ idx: 0 }, { idx: 1 }]
 
 let t = 1
-let n = 3
+let n = 2
 let addr = 'http://127.0.0.1:8000'
 
 const delay_ms = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
@@ -15,15 +17,20 @@ async function keygen(m, delay) {
   console.log('keygen new context: ')
   context = await m.gg18_keygen_client_round1(context, delay)
   console.log('keygen round1:')
-  context = await m.gg18_keygen_client_round2(context, delay)
-  console.log('keygen round2: ')
-  context = await m.gg18_keygen_client_round3(context, delay)
-  console.log('keygen round3: ')
-  context = await m.gg18_keygen_client_round4(context, delay)
-  console.log('keygen round4: ')
-  keygen_json = await m.gg18_keygen_client_round5(context, delay)
-  console.log('keygen json: ', keygen_json)
-  return keygen_json
+  // console.log(context)
+  // context = await m.gg18_keygen_client_round2(context, delay)
+  // console.log('keygen round2: ')
+  // // console.log(context)
+  // context = await m.gg18_keygen_client_round3(context, delay)
+  // console.log('keygen round3: ')
+  // context = await m.gg18_keygen_client_round4(context, delay)
+  // console.log('keygen round4: ')
+  // context = await m.gg18_keygen_client_round5(context, delay)
+  // console.log('keygen round5: ')
+  // keygen_json = await m.gg18_keygen_client_round6(context, delay)
+  // console.log('keygen json: ', keygen_json)
+  // return keygen_json
+  return context;
 }
 
 async function sign(m, key_store, delay) {
@@ -67,25 +74,25 @@ async function main() {
     }),
   )
 
-  console.log('sign items: ', results)
-  await Promise.all(
-    results.map(async (item) => {
-      if (item.idx < t + 1) {
-        let delay = Math.max(Math.random() % 500, 100)
-        //select random signer
-        res = JSON.parse(await sign(gg18, item.res, delay))
-        console.log('Sign result: ', res)
-        // recover the address
-        console.log("digest", digest);
-        let address = ethers.utils.recoverAddress(digest, {
-          r: "0x"+res[0],
-          s: "0x"+res[1],
-          v: res[2]
-        })
-        console.log("recover address by etherjs", address)
-      }
-    }),
-  )
+  // console.log('sign items: ', results)
+  // await Promise.all(
+  //   results.map(async (item) => {
+  //     if (item.idx < t + 1) {
+  //       let delay = Math.max(Math.random() % 500, 100)
+  //       //select random signer
+  //       res = JSON.parse(await sign(gg18, item.res, delay))
+  //       console.log('Sign result: ', res)
+  //       // recover the address
+  //       console.log("digest", digest);
+  //       // let address = ethers.utils.recoverAddress(digest, {
+  //       //   r: "0x"+res[0],
+  //       //   s: "0x"+res[1],
+  //       //   v: res[2]
+  //       // })
+  //       // console.log("recover address by etherjs", address)
+  //     }
+  //   }),
+  // )
 }
 
 main().then(() => {
diff --git a/scripts/run_with_eigen_service.js b/scripts/run_with_eigen_service.js
index adfda17..0c1f9a7 100644
--- a/scripts/run_with_eigen_service.js
+++ b/scripts/run_with_eigen_service.js
@@ -3,12 +3,10 @@ const ethers = require("ethers");
 const axios = require("axios");
 const querystring = require("querystring");
 
-// var items = [{ idx: 0 }, { idx: 1 }, { idx: 2 }]
-// var items = [{ idx: 0 }, { idx: 1 }];
 var items = [{ idx: 0 }];
 
-let t = 1;
-let n = 2;
+let threshold = 1;
+let share = 2;
 let addr = "http://127.0.0.1:8000";
 let eigen_service = "http://127.0.0.1:3000";
 
@@ -16,12 +14,12 @@ const delay_ms = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const digest = ethers.utils.keccak256(ethers.utils.toUtf8Bytes("Hello Eigen"));
 
 async function keygen(m, delay) {
-  user_id = 1;
+  user_id = 315;
   key_name = "Just test";
   keygen_url = `${eigen_service}/tss/keygen`;
   res = await axios.post(
     keygen_url,
-    querystring.stringify({ user_id: user_id, name: key_name, t: 1, n: 2 }),
+    querystring.stringify({ user_id: user_id, name: key_name, threshold: 1, share: 2 }),
     {
       headers: {
         "Content-Type": "application/x-www-form-urlencoded",
@@ -29,14 +27,11 @@ async function keygen(m, delay) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
-
-  let context = await m.gg18_keygen_client_new_context(addr, t, n, delay);
-
-  console.log("keygen new context: ");
+  let context = await m.gg18_keygen_client_new_context(addr, threshold, share, delay);
+  console.log("keygen new context");
 
-  round = 1;
   console.time(1);
+  round = 1;
   res = await axios.post(
     keygen_url,
     querystring.stringify({ user_id: user_id, round: round }),
@@ -46,89 +41,87 @@ async function keygen(m, delay) {
       },
     }
   );
-  console.log(res.data);
-  // await delay_ms(50);
-
+  console.log("test1");
   context = await m.gg18_keygen_client_round1(context, delay);
+  console.log("test2");
   console.log("keygen round1:");
-  console.timeEnd(1);
-
-  round = 2;
-  console.time(2);
-  res = await axios.post(
-    keygen_url,
-    querystring.stringify({ user_id: user_id, round: round }),
-    {
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-    }
-  );
-  console.log(res.data);
-  // await delay_ms(50);
-
-  context = await m.gg18_keygen_client_round2(context, delay);
-  console.log("keygen round2: ");
-  console.timeEnd(2);
-
-  round = 3;
-  console.time(3);
-  res = await axios.post(
-    keygen_url,
-    querystring.stringify({ user_id: user_id, round: round }),
-    {
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-    }
-  );
   console.log(res.data);
-  // await delay_ms(50);
-
-  context = await m.gg18_keygen_client_round3(context, delay);
-  console.log("keygen round3: ");
-  console.timeEnd(3);
-
-  round = 4;
-  console.time(4);
-  res = await axios.post(
-    keygen_url,
-    querystring.stringify({ user_id: user_id, round: round }),
-    {
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-    }
-  );
-  console.log(res.data);
-  // await delay_ms(50);
-
-  context = await m.gg18_keygen_client_round4(context, delay);
-  console.log("keygen round4: ");
-  console.timeEnd(4);
-
-  round = 5;
-  console.time(5);
-  res = await axios.post(
-    keygen_url,
-    querystring.stringify({ user_id: user_id, round: round }),
-    {
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-    }
-  );
-  console.log(res.data);
-  // await delay_ms(50);
-
-  keygen_json = await m.gg18_keygen_client_round5(context, delay);
-  console.timeEnd(5);
-  console.log("keygen json: ", keygen_json);
-  context = JSON.parse(context);
+  console.timeEnd(1);
 
-  public_key_address = context["public_key_address"];
-  console.log("public_key_address: ", public_key_address);
-  return { keygen_json: keygen_json, public_key_address: public_key_address };
+  return context;
+  // console.time(2);
+  // round = 2;
+  // res = await axios.post(
+  //   keygen_url,
+  //   querystring.stringify({ user_id: user_id, round: round }),
+  //   {
+  //     headers: {
+  //       "Content-Type": "application/x-www-form-urlencoded",
+  //     },
+  //   }
+  // );
+
+  
+  // console.log("test3");
+  
+  // context = await m.gg18_keygen_client_round2(context, delay);
+  // console.log("test4");
+  // console.log("keygen round2: ");
+  // console.log(res.data);
+  // console.timeEnd(2);
+
+  // console.time(3);
+  // round = 3;
+  // res = await axios.post(
+  //   keygen_url,
+  //   querystring.stringify({ user_id: user_id, round: round }),
+  //   {
+  //     headers: {
+  //       "Content-Type": "application/x-www-form-urlencoded",
+  //     },
+  //   }
+  // );
+  // context = await m.gg18_keygen_client_round3(context, delay);
+  // console.log("keygen round3: ");
+  // console.log(res.data);
+  // console.timeEnd(3);
+
+  // console.time(4);
+  // round = 4;
+  // res = await axios.post(
+  //   keygen_url,
+  //   querystring.stringify({ user_id: user_id, round: round }),
+  //   {
+  //     headers: {
+  //       "Content-Type": "application/x-www-form-urlencoded",
+  //     },
+  //   }
+  // );
+  // context = await m.gg18_keygen_client_round4(context, delay);
+  // console.log("keygen round4: ");
+  // console.log(res.data);
+  // console.timeEnd(4);
+
+  // console.time(5);
+  // round = 5;
+  // res = await axios.post(
+  //   keygen_url,
+  //   querystring.stringify({ user_id: user_id, round: round }),
+  //   {
+  //     headers: {
+  //       "Content-Type": "application/x-www-form-urlencoded",
+  //     },
+  //   }
+  // );
+  // keygen_json = await m.gg18_keygen_client_round5(context, delay);
+  // console.log("keygen json: ", keygen_json);
+  // console.log(res.data);
+  // console.timeEnd(5);
+
+  // context = JSON.parse(context);
+  // public_key_address = context["public_key_address"];
+  // console.log("public_key_address: ", public_key_address);
+  // return { keygen_json: keygen_json, public_key_address: public_key_address };
 }
 
 async function sign(m, key_store, delay, public_key_address) {
@@ -141,8 +134,8 @@ async function sign(m, key_store, delay, public_key_address) {
       digest: digest.slice(2),
       user_address: public_key_address,
       user_id: user_id,
-      t: 1,
-      n: 2,
+      threshold: 1,
+      share: 2,
     }),
     {
       headers: {
@@ -151,12 +144,12 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   let context = await m.gg18_sign_client_new_context(
     addr,
-    t,
-    n,
+    threshold,
+    share,
     key_store,
     digest.slice(2)
   );
@@ -173,7 +166,7 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   context = await m.gg18_sign_client_round0(context, delay);
   console.log("sign round0: ");
@@ -190,7 +183,7 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   context = await m.gg18_sign_client_round1(context, delay);
   console.log("sign round1: ");
@@ -208,7 +201,7 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   context = await m.gg18_sign_client_round2(context, delay);
   console.log("sign round2: ");
@@ -226,7 +219,7 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   context = await m.gg18_sign_client_round3(context, delay);
   console.log("sign round3: ");
@@ -244,7 +237,7 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   context = await m.gg18_sign_client_round4(context, delay);
   console.log("sign round4: ");
@@ -262,7 +255,7 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   context = await m.gg18_sign_client_round5(context, delay);
   console.log("sign round5: ");
@@ -280,7 +273,7 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   context = await m.gg18_sign_client_round6(context, delay);
   console.log("sign round6: ");
@@ -298,7 +291,7 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   context = await m.gg18_sign_client_round7(context, delay);
   console.log("sign round7: ");
@@ -316,7 +309,7 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   context = await m.gg18_sign_client_round8(context, delay);
   console.log("sign round8: ");
@@ -334,7 +327,7 @@ async function sign(m, key_store, delay, public_key_address) {
     }
   );
   console.log(res.data);
-  // await delay_ms(50);
+  await delay_ms(50);
 
   sign_json = await m.gg18_sign_client_round9(context, delay);
   console.timeEnd(9);
@@ -346,36 +339,37 @@ async function main() {
   var results = await Promise.all(
     items.map(async (item) => {
       let delay = Math.max(Math.random() % 500, 100);
-      let { keygen_json, public_key_address } = await keygen(gg18, delay);
-      return {
-        idx: item.idx,
-        res: keygen_json,
-        public_key_address: public_key_address,
-      };
+      let context = await keygen(gg18, delay);
+      // let { keygen_json, public_key_address } = await keygen(gg18, delay);
+      // return {
+      //   idx: item.idx,
+      //   res: keygen_json,
+      //   public_key_address: public_key_address,
+      // };
     })
   );
 
-  console.log("sign items: ", results);
-  await Promise.all(
-    results.map(async (item) => {
-      if (item.idx < t + 1) {
-        let delay = Math.max(Math.random() % 500, 100);
-        //select random signer
-        res = JSON.parse(
-          await sign(gg18, item.res, delay, item.public_key_address)
-        );
-        console.log("Sign result: ", res);
-        // recover the address
-        console.log("digest", digest);
-        let address = ethers.utils.recoverAddress(digest, {
-          r: "0x" + res[0],
-          s: "0x" + res[1],
-          v: res[2],
-        });
-        console.log("recover address by etherjs", address);
-      }
-    })
-  );
+  // console.log("sign items: ", results);
+  // await Promise.all(
+  //   results.map(async (item) => {
+  //     // if (item.idx < threshold + 1) {
+  //       let delay = Math.max(Math.random() % 500, 100);
+  //       //select random signer
+  //       res = JSON.parse(
+  //         await sign(gg18, item.res, delay, item.public_key_address)
+  //       );
+  //       console.log("Sign result: ", res);
+  //       // recover the address
+  //       console.log("digest", digest);
+  //       let address = ethers.utils.recoverAddress(digest, {
+  //         r: "0x" + res[0],
+  //         s: "0x" + res[1],
+  //         v: res[2],
+  //       });
+  //       console.log("recover address by etherjs", address);
+  //     // }
+  //   })
+  // );
 }
 
 main().then(() => {
diff --git a/src/api.rs b/src/api.rs
index f5d6c64..b4d72c5 100644
--- a/src/api.rs
+++ b/src/api.rs
@@ -2,7 +2,7 @@
 #![allow(non_snake_case)]
 use crate::common::{
     aes_decrypt, aes_encrypt, broadcast, check_sig, poll_for_broadcasts, poll_for_p2p, postb,
-    public_key_address, sendp2p, PartySignup, AEAD, AES_KEY_BYTES_LEN,
+    public_key_address, sendp2p, PartySignup, AEAD, AES_KEY_BYTES_LEN, sleep,Entry,
 };
 use crate::curv::elliptic::curves::traits::{ECPoint, ECScalar};
 use crate::curv::{
@@ -30,6 +30,7 @@ pub struct GG18KeygenClientContext {
     params: Parameters,
     party_num_int: u16,
     uuid: String,
+    is_owner: u16,
     bc1_vec: Option<Vec<KeyGenBroadcastMessage1>>,
     decom_i: Option<KeyGenDecommitMessage1>,
     party_keys: Option<Keys>,
@@ -74,8 +75,12 @@ pub async fn gg18_keygen_client_new_context(
         share_count: n,
     };
 
-    let (party_num_int, uuid) = match signup_keygen(&client, &addr).await? {
-        PartySignup { number, uuid } => (number, uuid),
+    let (party_num_int, uuid, is_owner) = match signup_keygen(&client, &addr).await? {
+        PartySignup {
+            number,
+            uuid,
+            is_owner,
+        } => (number, uuid, is_owner),
     };
 
     Ok(serde_json::to_string(&GG18KeygenClientContext {
@@ -83,6 +88,7 @@ pub async fn gg18_keygen_client_new_context(
         params,
         party_num_int,
         uuid,
+        is_owner,
         bc1_vec: None,
         decom_i: None,
         party_keys: None,
@@ -102,11 +108,11 @@ pub async fn gg18_keygen_client_new_context(
 #[wasm_bindgen]
 pub async fn gg18_keygen_client_round1(context: String, delay: u32) -> Result<String> {
     let mut context = serde_json::from_str::<GG18KeygenClientContext>(&context)?;
-    let client = reqwest::Client::new();
+    let client = new_client_with_headers()?;
     let party_keys = Keys::create(context.party_num_int as usize);
     let (bc_i, decom_i) = party_keys.phase1_broadcast_phase3_proof_of_correct_key();
 
-    broadcast(
+    let _test = broadcast(
         &client,
         &context.addr,
         context.party_num_int,
@@ -116,6 +122,20 @@ pub async fn gg18_keygen_client_round1(context: String, delay: u32) -> Result<St
     )
     .await?;
 
+    let mut bc1_vec = Vec::new();
+    bc1_vec.push(bc_i);
+    context.bc1_vec = Some(bc1_vec);
+    context.party_keys = Some(party_keys);
+    context.decom_i = Some(decom_i);
+
+    Ok(serde_json::to_string(&context)?)
+}
+
+#[wasm_bindgen]
+pub async fn gg18_keygen_client_round2(context: String, delay: u32) -> Result<String> {
+    let mut context = serde_json::from_str::<GG18KeygenClientContext>(&context)?;
+    let client = reqwest::Client::new();
+
     let round1_ans_vec = poll_for_broadcasts(
         &client,
         &context.addr,
@@ -131,22 +151,13 @@ pub async fn gg18_keygen_client_round1(context: String, delay: u32) -> Result<St
         .into_iter()
         .map(|m| serde_json::from_str::<KeyGenBroadcastMessage1>(&m))
         .collect::<std::result::Result<Vec<KeyGenBroadcastMessage1>, serde_json::Error>>()?;
-
-    bc1_vec.insert(context.party_num_int as usize - 1, bc_i);
-
+    let cc = context.bc1_vec.unwrap();
+    bc1_vec.insert(context.party_num_int as usize - 1, cc[0].clone());
+     
     context.bc1_vec = Some(bc1_vec);
-    context.party_keys = Some(party_keys);
-    context.decom_i = Some(decom_i);
 
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_keygen_client_round2(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18KeygenClientContext>(&context)?;
-    let client = reqwest::Client::new();
-    // send ephemeral public keys and check commitments correctness
-    broadcast(
+//  send ephemeral public keys and check commitments correctness
+    let _test =broadcast(
         &client,
         &context.addr,
         context.party_num_int,
@@ -156,6 +167,14 @@ pub async fn gg18_keygen_client_round2(context: String, delay: u32) -> Result<St
     )
     .await?;
 
+    Ok(serde_json::to_string(&context)?)
+}
+
+#[wasm_bindgen]
+pub async fn gg18_keygen_client_round3(context: String, delay: u32) -> Result<String> {
+    let mut context = serde_json::from_str::<GG18KeygenClientContext>(&context)?;
+    let client = reqwest::Client::new();
+
     let round2_ans_vec = poll_for_broadcasts(
         &client,
         &context.addr,
@@ -213,13 +232,6 @@ pub async fn gg18_keygen_client_round2(context: String, delay: u32) -> Result<St
     context.enc_keys = Some(enc_keys);
     context.point_vec = Some(point_vec);
 
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_keygen_client_round3(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18KeygenClientContext>(&context)?;
-    let client = reqwest::Client::new();
     let mut j = 0;
     for (k, i) in (1..=context.params.share_count as u16).enumerate() {
         if i != context.party_num_int {
@@ -228,7 +240,7 @@ pub async fn gg18_keygen_client_round3(context: String, delay: u32) -> Result<St
             let plaintext =
                 BigInt::to_vec(&context.secret_shares.as_ref().unwrap()[k].to_big_int());
             let aead_pack_i = aes_encrypt(key_i, &plaintext)?;
-            sendp2p(
+            let _test = sendp2p(
                 &client,
                 &context.addr,
                 context.party_num_int,
@@ -242,6 +254,16 @@ pub async fn gg18_keygen_client_round3(context: String, delay: u32) -> Result<St
         }
     }
 
+    Ok(serde_json::to_string(&context)?)
+}
+
+
+
+#[wasm_bindgen]
+pub async fn gg18_keygen_client_round4(context: String, delay: u32) -> Result<String> {
+    let mut context = serde_json::from_str::<GG18KeygenClientContext>(&context)?;
+    let client = reqwest::Client::new();
+    
     let round3_ans_vec = poll_for_p2p(
         &client,
         &context.addr,
@@ -252,7 +274,7 @@ pub async fn gg18_keygen_client_round3(context: String, delay: u32) -> Result<St
         context.uuid.clone(),
     )
     .await?;
-
+    
     let mut j = 0;
     let mut party_shares: Vec<Scalar> = Vec::new();
     for i in 1..=context.params.share_count as u16 {
@@ -269,17 +291,9 @@ pub async fn gg18_keygen_client_round3(context: String, delay: u32) -> Result<St
             j += 1;
         }
     }
-
     context.party_shares = Some(party_shares);
 
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_keygen_client_round4(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18KeygenClientContext>(&context)?;
-    let client = reqwest::Client::new();
-    broadcast(
+    let _test =broadcast(
         &client,
         &context.addr,
         context.party_num_int,
@@ -288,6 +302,15 @@ pub async fn gg18_keygen_client_round4(context: String, delay: u32) -> Result<St
         context.uuid.clone(),
     )
     .await?;
+
+    Ok(serde_json::to_string(&context)?)
+}
+
+#[wasm_bindgen]
+pub async fn gg18_keygen_client_round5(context: String, delay: u32) -> Result<String> {
+    let mut context = serde_json::from_str::<GG18KeygenClientContext>(&context)?;
+    let client = reqwest::Client::new();
+
     let round4_ans_vec = poll_for_broadcasts(
         &client,
         &context.addr,
@@ -327,14 +350,7 @@ pub async fn gg18_keygen_client_round4(context: String, delay: u32) -> Result<St
     context.dlog_proof = Some(dlog_proof);
     context.vss_scheme_vec = Some(vss_scheme_vec);
 
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_keygen_client_round5(context: String, delay: u32) -> Result<String> {
-    let context = serde_json::from_str::<GG18KeygenClientContext>(&context)?;
-    let client = reqwest::Client::new();
-    broadcast(
+    let _test =broadcast(
         &client,
         &context.addr,
         context.party_num_int,
@@ -343,6 +359,15 @@ pub async fn gg18_keygen_client_round5(context: String, delay: u32) -> Result<St
         context.uuid.clone(),
     )
     .await?;
+
+    Ok(serde_json::to_string(&context)?)
+}
+
+#[wasm_bindgen]
+pub async fn gg18_keygen_client_round6(context: String, delay: u32) -> Result<String> {
+    let context = serde_json::from_str::<GG18KeygenClientContext>(&context)?;
+    let client = reqwest::Client::new();
+   
     let round5_ans_vec = poll_for_broadcasts(
         &client,
         &context.addr,
@@ -380,6 +405,7 @@ pub async fn gg18_keygen_client_round5(context: String, delay: u32) -> Result<St
         context.party_keys.as_ref().unwrap(),
         context.shared_keys.as_ref().unwrap(),
         context.party_num_int,
+        context.is_owner,
         context.vss_scheme_vec.as_ref().unwrap(),
         paillier_key_vec,
         context.y_sum.as_ref().unwrap(),
@@ -409,6 +435,7 @@ pub struct GG18SignClientContext {
     party_keys: Keys,
     shared_keys: SharedKeys,
     party_id: u16,
+    is_owner: u16,
     vss_scheme_vec: Vec<VerifiableSS>,
     paillier_key_vector: Vec<EncryptionKey>,
     y_sum: Point,
@@ -460,18 +487,23 @@ pub async fn gg18_sign_client_new_context(
     // let message = &message[..];
     let client = new_client_with_headers()?;
 
-    let (party_keys, shared_keys, party_id, vss_scheme_vec, paillier_key_vector, y_sum): (
+    let (party_keys, shared_keys, party_id, is_owner, vss_scheme_vec, paillier_key_vector, y_sum): (
         Keys,
         SharedKeys,
         u16,
+        u16,
         Vec<VerifiableSS>,
         Vec<EncryptionKey>,
         Point,
     ) = serde_json::from_str(&key_store)?;
 
     //signup:
-    let (party_num_int, uuid) = match signup_sign(&client, &addr).await? {
-        PartySignup { number, uuid } => (number, uuid),
+    let (party_num_int, uuid, _is_owner) = match signup_sign(&client, &addr).await? {
+        PartySignup {
+            number,
+            uuid,
+            is_owner,
+        } => (number, uuid, is_owner),
     };
 
     Ok(serde_json::to_string(&GG18SignClientContext {
@@ -479,6 +511,7 @@ pub async fn gg18_sign_client_new_context(
         party_keys,
         shared_keys,
         party_id,
+        is_owner,
         vss_scheme_vec,
         paillier_key_vector,
         y_sum,
@@ -515,643 +548,651 @@ pub async fn gg18_sign_client_new_context(
     })?)
 }
 
-#[wasm_bindgen]
-pub async fn gg18_sign_client_round0(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
-    let client = new_client_with_headers()?;
-    // round 0: collect signers IDs
-    broadcast(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        "round0",
-        serde_json::to_string(&context.party_id)?,
-        context.uuid.clone(),
-    )
-    .await?;
-    let round0_ans_vec = poll_for_broadcasts(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        context.threshould + 1,
-        "round0",
-        context.uuid.clone(),
-        delay,
-    )
-    .await?;
-
-    let mut j = 0;
-    let mut signers_vec: Vec<usize> = Vec::new();
-    for i in 1..=context.threshould + 1 {
-        if i == context.party_num_int {
-            signers_vec.push((context.party_id - 1).into());
-        } else {
-            let signer_j: u16 = serde_json::from_str(&round0_ans_vec[j])?;
-            signers_vec.push((signer_j - 1).into());
-            j += 1;
-        }
-    }
-
-    let private =
-        PartyPrivate::set_private(context.party_keys.clone(), context.shared_keys.clone());
-
-    let sign_keys = SignKeys::create(
-        &private,
-        &context.vss_scheme_vec[usize::from(signers_vec[usize::from(context.party_num_int - 1)])],
-        signers_vec[usize::from(context.party_num_int - 1)].into(),
-        &signers_vec,
-    );
-
-    let xi_com_vec = Keys::get_commitments_to_xi(&context.vss_scheme_vec);
-
-    context.sign_keys = Some(sign_keys);
-    context.signers_vec = Some(signers_vec);
-    context.xi_com_vec = Some(xi_com_vec);
-
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_sign_client_round1(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
-    let client = new_client_with_headers()?;
-    let (com, decommit) = context.sign_keys.as_ref().unwrap().phase1_broadcast();
-    let (m_a_k, _) = MessageA::a(
-        &context.sign_keys.as_ref().unwrap().k_i,
-        &context.party_keys.ek,
-        &[],
-    );
-    broadcast(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        "round1",
-        serde_json::to_string(&(com.clone(), m_a_k))?,
-        context.uuid.clone(),
-    )
-    .await?;
-    let round1_ans_vec = poll_for_broadcasts(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        context.threshould + 1,
-        "round1",
-        context.uuid.clone(),
-        delay,
-    )
-    .await?;
-
-    context.com = Some(com);
-    context.decommit = Some(decommit);
-    context.round1_ans_vec = Some(round1_ans_vec);
-
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_sign_client_round2(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
-    let client = new_client_with_headers()?;
-    let mut j = 0;
-    let mut bc1_vec: Vec<SignBroadcastPhase1> = Vec::new();
-    let mut m_a_vec: Vec<MessageA> = Vec::new();
-
-    for i in 1..context.threshould + 2 {
-        if i == context.party_num_int {
-            bc1_vec.push(context.com.as_ref().unwrap().clone());
-        //   m_a_vec.push(m_a_k.clone());
-        } else {
-            //     if signers_vec.contains(&(i as usize)) {
-            let (bc1_j, m_a_party_j): (SignBroadcastPhase1, MessageA) =
-                serde_json::from_str(&context.round1_ans_vec.as_ref().unwrap()[j])?;
-            bc1_vec.push(bc1_j);
-            m_a_vec.push(m_a_party_j);
-
-            j += 1;
-            //       }
-        }
-    }
-    assert_eq!(context.signers_vec.as_ref().unwrap().len(), bc1_vec.len());
-
-    //////////////////////////////////////////////////////////////////////////////
-    let mut m_b_gamma_send_vec: Vec<MessageB> = Vec::new();
-    let mut beta_vec: Vec<Scalar> = Vec::new();
-    let mut m_b_w_send_vec: Vec<MessageB> = Vec::new();
-    let mut ni_vec: Vec<Scalar> = Vec::new();
-    let mut j = 0;
-    for i in 1..context.threshould + 2 {
-        if i != context.party_num_int {
-            let (m_b_gamma, beta_gamma, _, _) = MessageB::b(
-                &context.sign_keys.as_ref().unwrap().gamma_i,
-                &context.paillier_key_vector
-                    [usize::from(context.signers_vec.as_ref().unwrap()[usize::from(i - 1)])],
-                m_a_vec[j].clone(),
-                &[],
-            )
-            .unwrap();
-            let (m_b_w, beta_wi, _, _) = MessageB::b(
-                &context.sign_keys.as_ref().unwrap().w_i,
-                &context.paillier_key_vector
-                    [usize::from(context.signers_vec.as_ref().unwrap()[usize::from(i - 1)])],
-                m_a_vec[j].clone(),
-                &[],
-            )
-            .unwrap();
-            m_b_gamma_send_vec.push(m_b_gamma);
-            m_b_w_send_vec.push(m_b_w);
-            beta_vec.push(beta_gamma);
-            ni_vec.push(beta_wi);
-            j += 1;
-        }
-    }
-
-    let mut j = 0;
-    for i in 1..context.threshould + 2 {
-        if i != context.party_num_int {
-            sendp2p(
-                &client,
-                &context.addr,
-                context.party_num_int,
-                i,
-                "round2",
-                serde_json::to_string(&(m_b_gamma_send_vec[j].clone(), m_b_w_send_vec[j].clone()))?,
-                context.uuid.clone(),
-            )
-            .await?;
-            j += 1;
-        }
-    }
-
-    let round2_ans_vec = poll_for_p2p(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        context.threshould + 1,
-        delay,
-        "round2",
-        context.uuid.clone(),
-    )
-    .await?;
-
-    context.round2_ans_vec = Some(round2_ans_vec);
-    context.beta_vec = Some(beta_vec);
-    context.ni_vec = Some(ni_vec);
-    context.bc1_vec = Some(bc1_vec);
-
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_sign_client_round3(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
-    let client = new_client_with_headers()?;
-    let mut m_b_gamma_rec_vec: Vec<MessageB> = Vec::new();
-    let mut m_b_w_rec_vec: Vec<MessageB> = Vec::new();
-
-    for i in 0..context.threshould {
-        //  if signers_vec.contains(&(i as usize)) {
-        let (m_b_gamma_i, m_b_w_i): (MessageB, MessageB) =
-            serde_json::from_str(&context.round2_ans_vec.as_ref().unwrap()[i as usize])?;
-        m_b_gamma_rec_vec.push(m_b_gamma_i);
-        m_b_w_rec_vec.push(m_b_w_i);
-        //     }
-    }
+// #[wasm_bindgen]
+// pub async fn gg18_sign_client_round0(context: String, delay: u32) -> Result<String> {
+//     let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
+//     let client = new_client_with_headers()?;
+//     // round 0: collect signers IDs
+//     broadcast(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         "round0",
+//         serde_json::to_string(&context.party_id)?,
+//         context.uuid.clone(),
+//     )
+//     .await?;
+//     let round0_ans_vec = poll_for_broadcasts(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         context.threshould + 1,
+//         "round0",
+//         context.uuid.clone(),
+//         delay,
+//     )
+//     .await?;
+
+//     let mut j = 0;
+//     let mut signers_vec: Vec<usize> = Vec::new();
+//     for i in 1..=context.threshould + 1 {
+//         if i == context.party_num_int {
+//             signers_vec.push((context.party_id - 1).into());
+//         } else {
+//             let signer_j: u16 = serde_json::from_str(&round0_ans_vec[j])?;
+//             signers_vec.push((signer_j - 1).into());
+//             j += 1;
+//         }
+//     }
+
+//     let private =
+//         PartyPrivate::set_private(context.party_keys.clone(), context.shared_keys.clone());
+     
+//     let sign_keys = SignKeys::create(
+//         &private,
+//         &context.vss_scheme_vec[usize::from(signers_vec[usize::from(context.party_num_int - 1)])],
+//         signers_vec[usize::from(context.party_num_int - 1)].into(),
+//         &signers_vec,
+//     );
+
+//     let xi_com_vec = Keys::get_commitments_to_xi(&context.vss_scheme_vec);
+
+//     context.sign_keys = Some(sign_keys);
+//     context.signers_vec = Some(signers_vec);
+//     context.xi_com_vec = Some(xi_com_vec);
+
+//     Ok(serde_json::to_string(&context)?)
+// }
+
+// #[wasm_bindgen]
+// pub async fn gg18_sign_client_round1(context: String, delay: u32) -> Result<String> {
+//     let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
+//     let client = new_client_with_headers()?;
+//     let (com, decommit) = context.sign_keys.as_ref().unwrap().phase1_broadcast();
+//     let (m_a_k, _) = MessageA::a(
+//         &context.sign_keys.as_ref().unwrap().k_i,
+//         &context.party_keys.ek,
+//         &[],
+//     );
+//     broadcast(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         "round1",
+//         serde_json::to_string(&(com.clone(), m_a_k))?,
+//         context.uuid.clone(),
+//     )
+//     .await?;
+//     let round1_ans_vec = poll_for_broadcasts(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         context.threshould + 1,
+//         "round1",
+//         context.uuid.clone(),
+//         delay,
+//     )
+//     .await?;
+
+//     context.com = Some(com);
+//     context.decommit = Some(decommit);
+//     context.round1_ans_vec = Some(round1_ans_vec);
+
+//     Ok(serde_json::to_string(&context)?)
+// }
+
+// #[wasm_bindgen]
+// pub async fn gg18_sign_client_round2(context: String, delay: u32) -> Result<String> {
+//     let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
+//     let client = new_client_with_headers()?;
+//     let mut j = 0;
+//     let mut bc1_vec: Vec<SignBroadcastPhase1> = Vec::new();
+//     let mut m_a_vec: Vec<MessageA> = Vec::new();
+
+//     for i in 1..context.threshould + 2 {
+//         if i == context.party_num_int {
+//             bc1_vec.push(context.com.as_ref().unwrap().clone());
+//         //   m_a_vec.push(m_a_k.clone());
+//         } else {
+//             //     if signers_vec.contains(&(i as usize)) {
+//             let (bc1_j, m_a_party_j): (SignBroadcastPhase1, MessageA) =
+//                 serde_json::from_str(&context.round1_ans_vec.as_ref().unwrap()[j])?;
+//             bc1_vec.push(bc1_j);
+//             m_a_vec.push(m_a_party_j);
+
+//             j += 1;
+//             //       }
+//         }
+//     }
+//     assert_eq!(context.signers_vec.as_ref().unwrap().len(), bc1_vec.len());
+
+//     //////////////////////////////////////////////////////////////////////////////
+//     let mut m_b_gamma_send_vec: Vec<MessageB> = Vec::new();
+//     let mut beta_vec: Vec<Scalar> = Vec::new();
+//     let mut m_b_w_send_vec: Vec<MessageB> = Vec::new();
+//     let mut ni_vec: Vec<Scalar> = Vec::new();
+//     let mut j = 0;
+//     for i in 1..context.threshould + 2 {
+//         if i != context.party_num_int {
+//             let (m_b_gamma, beta_gamma, _, _) = MessageB::b(
+//                 &context.sign_keys.as_ref().unwrap().gamma_i,
+//                 &context.paillier_key_vector
+//                     [usize::from(context.signers_vec.as_ref().unwrap()[usize::from(i - 1)])],
+//                 m_a_vec[j].clone(),
+//                 &[],
+//             )
+//             .unwrap();
+//             let (m_b_w, beta_wi, _, _) = MessageB::b(
+//                 &context.sign_keys.as_ref().unwrap().w_i,
+//                 &context.paillier_key_vector
+//                     [usize::from(context.signers_vec.as_ref().unwrap()[usize::from(i - 1)])],
+//                 m_a_vec[j].clone(),
+//                 &[],
+//             )
+//             .unwrap();
+//             m_b_gamma_send_vec.push(m_b_gamma);
+//             m_b_w_send_vec.push(m_b_w);
+//             beta_vec.push(beta_gamma);
+//             ni_vec.push(beta_wi);
+//             j += 1;
+//         }
+//     }
+
+//     let mut j = 0;
+//     for i in 1..context.threshould + 2 {
+//         if i != context.party_num_int {
+//             sendp2p(
+//                 &client,
+//                 &context.addr,
+//                 context.party_num_int,
+//                 i,
+//                 "round2",
+//                 serde_json::to_string(&(m_b_gamma_send_vec[j].clone(), m_b_w_send_vec[j].clone()))?,
+//                 context.uuid.clone(),
+//             )
+//             .await?;
+//             j += 1;
+//         }
+//     }
+
+//     let round2_ans_vec = poll_for_p2p(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         context.threshould + 1,
+//         delay,
+//         "round2",
+//         context.uuid.clone(),
+//     )
+//     .await?;
+
+//     context.round2_ans_vec = Some(round2_ans_vec);
+//     context.beta_vec = Some(beta_vec);
+//     context.ni_vec = Some(ni_vec);
+//     context.bc1_vec = Some(bc1_vec);
+
+//     Ok(serde_json::to_string(&context)?)
+// }
+
+// #[wasm_bindgen]
+// pub async fn gg18_sign_client_round3(context: String, delay: u32) -> Result<String> {
+//     let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
+//     let client = new_client_with_headers()?;
+//     let mut m_b_gamma_rec_vec: Vec<MessageB> = Vec::new();
+//     let mut m_b_w_rec_vec: Vec<MessageB> = Vec::new();
+
+//     for i in 0..context.threshould {
+//         //  if signers_vec.contains(&(i as usize)) {
+//         let (m_b_gamma_i, m_b_w_i): (MessageB, MessageB) =
+//             serde_json::from_str(&context.round2_ans_vec.as_ref().unwrap()[i as usize])?;
+//         m_b_gamma_rec_vec.push(m_b_gamma_i);
+//         m_b_w_rec_vec.push(m_b_w_i);
+//         //     }
+//     }
+
+//     let mut alpha_vec: Vec<Scalar> = Vec::new();
+//     let mut miu_vec: Vec<Scalar> = Vec::new();
+
+//     let mut j = 0;
+//     for i in 1..context.threshould + 2 {
+//         if i != context.party_num_int {
+//             let m_b = m_b_gamma_rec_vec[j].clone();
+
+//             let alpha_ij_gamma = m_b.verify_proofs_get_alpha(
+//                 &context.party_keys.dk,
+//                 &context.sign_keys.as_ref().unwrap().k_i,
+//             )?;
+//             let m_b = m_b_w_rec_vec[j].clone();
+//             let alpha_ij_wi = m_b.verify_proofs_get_alpha(
+//                 &context.party_keys.dk,
+//                 &context.sign_keys.as_ref().unwrap().k_i,
+//             )?;
+//             alpha_vec.push(alpha_ij_gamma.0);
+//             miu_vec.push(alpha_ij_wi.0);
+//             let g_w_i = Keys::update_commitments_to_xi(
+//                 &context.xi_com_vec.as_ref().unwrap()
+//                     [usize::from(context.signers_vec.as_ref().unwrap()[usize::from(i - 1)])],
+//                 &context.vss_scheme_vec
+//                     [usize::from(context.signers_vec.as_ref().unwrap()[usize::from(i - 1)])],
+//                 context.signers_vec.as_ref().unwrap()[usize::from(i - 1)],
+//                 &context.signers_vec.as_ref().unwrap(),
+//             );
+//             assert_eq!(m_b.b_proof.pk, g_w_i);
+//             j += 1;
+//         }
+//     }
+//     //////////////////////////////////////////////////////////////////////////////
+//     let delta_i = context
+//         .sign_keys
+//         .as_ref()
+//         .unwrap()
+//         .phase2_delta_i(&alpha_vec, &context.beta_vec.as_ref().unwrap());
+//     let sigma = context
+//         .sign_keys
+//         .as_ref()
+//         .unwrap()
+//         .phase2_sigma_i(&miu_vec, &context.ni_vec.as_ref().unwrap());
+
+//     broadcast(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         "round3",
+//         serde_json::to_string(&delta_i)?,
+//         context.uuid.clone(),
+//     )
+//     .await?;
+//     let round3_ans_vec = poll_for_broadcasts(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         context.threshould + 1,
+//         "round3",
+//         context.uuid.clone(),
+//         delay,
+//     )
+//     .await?;
+//     let mut delta_vec: Vec<Scalar> = Vec::new();
+//     format_vec_from_reads(
+//         &round3_ans_vec,
+//         context.party_num_int as usize,
+//         delta_i,
+//         &mut delta_vec,
+//     )?;
+//     let delta_inv = SignKeys::phase3_reconstruct_delta(&delta_vec);
+
+//     context.m_b_gamma_rec_vec = Some(m_b_gamma_rec_vec);
+//     context.delta_inv = Some(delta_inv);
+//     context.sigma = Some(sigma);
+
+//     Ok(serde_json::to_string(&context)?)
+// }
+
+// #[wasm_bindgen]
+// pub async fn gg18_sign_client_round4(context: String, delay: u32) -> Result<String> {
+//     let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
+//     let client = new_client_with_headers()?;
+//     // decommit to gamma_i
+//     broadcast(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         "round4",
+//         serde_json::to_string(&context.decommit.as_ref().unwrap())?,
+//         context.uuid.clone(),
+//     )
+//     .await?;
+//     let round4_ans_vec = poll_for_broadcasts(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         context.threshould + 1,
+//         "round4",
+//         context.uuid.clone(),
+//         delay,
+//     )
+//     .await?;
+
+//     let mut decommit_vec: Vec<SignDecommitPhase1> = Vec::new();
+//     format_vec_from_reads(
+//         &round4_ans_vec,
+//         context.party_num_int as usize,
+//         context.decommit.clone().unwrap(),
+//         &mut decommit_vec,
+//     )?;
+
+//     let decomm_i = decommit_vec.remove(usize::from(context.party_num_int - 1));
+//     let _ = &context
+//         .bc1_vec
+//         .as_mut()
+//         .unwrap()
+//         .remove(usize::from(context.party_num_int - 1));
+//     let b_proof_vec = (0..context.m_b_gamma_rec_vec.as_ref().unwrap().len())
+//         .map(|i| &context.m_b_gamma_rec_vec.as_ref().unwrap()[i].b_proof)
+//         .collect::<Vec<&DLogProof>>();
+
+//     let R = SignKeys::phase4(
+//         &context.delta_inv.as_ref().unwrap(),
+//         &b_proof_vec,
+//         decommit_vec,
+//         &context.bc1_vec.as_ref().unwrap(),
+//     )?;
+
+//     // adding local g_gamma_i
+//     let R = R + decomm_i.g_gamma_i * context.delta_inv.as_ref().unwrap();
+
+//     // we assume the message is already hashed (by the signer).
+//     let message = &context.message[..];
+//     let message_bn = BigInt::from_bytes_be(message);
+//     let local_sig = LocalSignature::phase5_local_sig(
+//         &context.sign_keys.as_ref().unwrap().k_i,
+//         &message_bn,
+//         &R,
+//         &context.sigma.as_ref().unwrap(),
+//         &context.y_sum,
+//     );
+
+//     let (phase5_com, phase_5a_decom, helgamal_proof, dlog_proof_rho) =
+//         local_sig.phase5a_broadcast_5b_zkproof();
+
+//     context.phase5_com = Some(phase5_com);
+//     context.phase_5a_decom = Some(phase_5a_decom);
+//     context.helgamal_proof = Some(helgamal_proof);
+//     context.dlog_proof_rho = Some(dlog_proof_rho);
+//     context.local_sig = Some(local_sig);
+//     context.r = Some(R);
+
+//     Ok(serde_json::to_string(&context)?)
+// }
+
+// #[wasm_bindgen]
+// pub async fn gg18_sign_client_round5(context: String, delay: u32) -> Result<String> {
+//     let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
+//     let client = new_client_with_headers()?;
+//     //phase (5A)  broadcast commit
+//     broadcast(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         "round5",
+//         serde_json::to_string(&context.phase5_com.as_ref().unwrap())?,
+//         context.uuid.clone(),
+//     )
+//     .await?;
+//     let round5_ans_vec = poll_for_broadcasts(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         context.threshould + 1,
+//         "round5",
+//         context.uuid.clone(),
+//         delay,
+//     )
+//     .await?;
+
+//     let mut commit5a_vec: Vec<Phase5Com1> = Vec::new();
+//     format_vec_from_reads(
+//         &round5_ans_vec,
+//         context.party_num_int as usize,
+//         context.phase5_com.clone().unwrap(),
+//         &mut commit5a_vec,
+//     )?;
+
+//     context.commit5a_vec = Some(commit5a_vec);
+
+//     Ok(serde_json::to_string(&context)?)
+// }
+
+// #[wasm_bindgen]
+// pub async fn gg18_sign_client_round6(context: String, delay: u32) -> Result<String> {
+//     let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
+//     let client = new_client_with_headers()?;
+//     //phase (5B)  broadcast decommit and (5B) ZK proof
+//     broadcast(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         "round6",
+//         serde_json::to_string(&(
+//             context.phase_5a_decom.clone().unwrap(),
+//             context.helgamal_proof.clone().unwrap(),
+//             context.dlog_proof_rho.clone().unwrap(),
+//         ))?,
+//         context.uuid.clone(),
+//     )
+//     .await?;
+//     let round6_ans_vec = poll_for_broadcasts(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         context.threshould + 1,
+//         "round6",
+//         context.uuid.clone(),
+//         delay,
+//     )
+//     .await?;
+
+//     let mut decommit5a_and_elgamal_and_dlog_vec: Vec<(Phase5ADecom1, HomoELGamalProof, DLogProof)> =
+//         Vec::new();
+//     format_vec_from_reads(
+//         &round6_ans_vec,
+//         context.party_num_int as usize,
+//         (
+//             context.phase_5a_decom.clone().unwrap(),
+//             context.helgamal_proof.clone().unwrap(),
+//             context.dlog_proof_rho.clone().unwrap(),
+//         ),
+//         &mut decommit5a_and_elgamal_and_dlog_vec,
+//     )?;
+//     let decommit5a_and_elgamal_and_dlog_vec_includes_i =
+//         decommit5a_and_elgamal_and_dlog_vec.clone();
+//     decommit5a_and_elgamal_and_dlog_vec.remove(usize::from(context.party_num_int - 1));
+//     context
+//         .commit5a_vec
+//         .as_mut()
+//         .unwrap()
+//         .remove(usize::from(context.party_num_int - 1));
+//     let phase_5a_decomm_vec = (0..context.threshould)
+//         .map(|i| decommit5a_and_elgamal_and_dlog_vec[i as usize].0.clone())
+//         .collect::<Vec<Phase5ADecom1>>();
+//     let phase_5a_elgamal_vec = (0..context.threshould)
+//         .map(|i| decommit5a_and_elgamal_and_dlog_vec[i as usize].1.clone())
+//         .collect::<Vec<HomoELGamalProof>>();
+//     let phase_5a_dlog_vec = (0..context.threshould)
+//         .map(|i| decommit5a_and_elgamal_and_dlog_vec[i as usize].2.clone())
+//         .collect::<Vec<DLogProof>>();
+//     let (phase5_com2, phase_5d_decom2) = context.local_sig.clone().unwrap().phase5c(
+//         &phase_5a_decomm_vec,
+//         &context.commit5a_vec.as_ref().unwrap(),
+//         &phase_5a_elgamal_vec,
+//         &phase_5a_dlog_vec,
+//         &context.phase_5a_decom.as_ref().unwrap().V_i,
+//         &context.r.as_ref().unwrap(),
+//     )?;
+
+//     context.phase5_com2 = Some(phase5_com2);
+//     context.phase_5d_decom2 = Some(phase_5d_decom2);
+//     context.decommit5a_and_elgamal_and_dlog_vec_includes_i =
+//         Some(decommit5a_and_elgamal_and_dlog_vec_includes_i);
+
+//     Ok(serde_json::to_string(&context)?)
+// }
+
+// #[wasm_bindgen]
+// pub async fn gg18_sign_client_round7(context: String, delay: u32) -> Result<String> {
+//     let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
+//     let client = new_client_with_headers()?;
+//     //////////////////////////////////////////////////////////////////////////////
+//     broadcast(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         "round7",
+//         serde_json::to_string(&context.phase5_com2.as_ref().unwrap())?,
+//         context.uuid.clone(),
+//     )
+//     .await?;
+//     let round7_ans_vec = poll_for_broadcasts(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         context.threshould + 1,
+//         "round7",
+//         context.uuid.clone(),
+//         delay,
+//     )
+//     .await?;
+
+//     let mut commit5c_vec: Vec<Phase5Com2> = Vec::new();
+//     format_vec_from_reads(
+//         &round7_ans_vec,
+//         context.party_num_int as usize,
+//         context.phase5_com2.clone().unwrap(),
+//         &mut commit5c_vec,
+//     )?;
+
+//     context.commit5c_vec = Some(commit5c_vec);
+
+//     Ok(serde_json::to_string(&context)?)
+// }
+
+// #[wasm_bindgen]
+// pub async fn gg18_sign_client_round8(context: String, delay: u32) -> Result<String> {
+//     let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
+//     let client = new_client_with_headers()?;
+//     //phase (5B)  broadcast decommit and (5B) ZK proof
+//     broadcast(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         "round8",
+//         serde_json::to_string(&context.phase_5d_decom2.as_ref().unwrap())?,
+//         context.uuid.clone(),
+//     )
+//     .await?;
+//     let round8_ans_vec = poll_for_broadcasts(
+//         &client,
+//         &context.addr,
+//         context.party_num_int,
+//         context.threshould + 1,
+//         "round8",
+//         context.uuid.clone(),
+//         delay,
+//     )
+//     .await?;
+
+//     let mut decommit5d_vec: Vec<Phase5DDecom2> = Vec::new();
+//     format_vec_from_reads(
+//         &round8_ans_vec,
+//         context.party_num_int as usize,
+//         context.phase_5d_decom2.clone().unwrap(),
+//         &mut decommit5d_vec,
+//     )?;
+
+//     let phase_5a_decomm_vec_includes_i = (0..=context.threshould)
+//         .map(|i| {
+//             context
+//                 .decommit5a_and_elgamal_and_dlog_vec_includes_i
+//                 .clone()
+//                 .unwrap()[i as usize]
+//                 .0
+//                 .clone()
+//         })
+//         .collect::<Vec<Phase5ADecom1>>();
+//     let s_i = context.local_sig.clone().unwrap().phase5d(
+//         &decommit5d_vec,
+//         &context.commit5c_vec.as_ref().unwrap(),
+//         &phase_5a_decomm_vec_includes_i,
+//     )?;
+
+//     context.s_i = Some(s_i);
+
+//     Ok(serde_json::to_string(&context)?)
+// }
+
+// #[wasm_bindgen]
+// pub async fn gg18_sign_client_round9(context: String, delay: u32) -> Result<String> {
+//     let context = serde_json::from_str::<GG18SignClientContext>(&context)?;
+//     let client = new_client_with_headers()?;
+//     //////////////////////////////////////////////////////////////////////////////
+//     if context.is_owner == 1 {
+//         let round9_ans_vec = poll_for_broadcasts(
+//             &client,
+//             &context.addr,
+//             context.party_num_int,
+//             context.threshould + 1,
+//             "round9",
+//             context.uuid.clone(),
+//             delay,
+//         )
+//         .await?;
+
+//         let mut s_i_vec: Vec<Scalar> = Vec::new();
+//         format_vec_from_reads(
+//             &round9_ans_vec,
+//             context.party_num_int as usize,
+//             context.s_i.unwrap(),
+//             &mut s_i_vec,
+//         )?;
+
+//         s_i_vec.remove(usize::from(context.party_num_int - 1));
+//         let sig = context
+//             .local_sig
+//             .clone()
+//             .unwrap()
+//             .output_signature(&s_i_vec)?;
+
+//         let sign_json = serde_json::to_string(&vec![
+//             //"r",
+//             sig.r.to_big_int().to_hex(),
+//             //"s",
+//             sig.s.to_big_int().to_hex(),
+//             //"v"
+//             sig.recid.to_string(),
+//         ])?;
+//         crate::console_log!("sign_json: {:?}", sign_json);
+
+//         check_sig(
+//             &sig.r,
+//             &sig.s,
+//             &context.local_sig.clone().unwrap().m,
+//             &context.y_sum.clone(),
+//         )?;
+
+//         return Ok(sign_json);
+//     } else {
+//         broadcast(
+//             &client,
+//             &context.addr,
+//             context.party_num_int,
+//             "round9",
+//             serde_json::to_string(&context.s_i.as_ref().unwrap())?,
+//             context.uuid.clone(),
+//         )
+//         .await?;
+//     }
+
+//     Ok(serde_json::to_string(
+//         "part of the signed work has been completed",
+//     )?)
+// }
+
+// fn format_vec_from_reads<'a, T: serde::Deserialize<'a> + Clone>(
+//     ans_vec: &'a [String],
+//     party_num: usize,
+//     value_i: T,
+//     new_vec: &'a mut Vec<T>,
+// ) -> Result<()> {
+//     let mut j = 0;
+//     for i in 1..ans_vec.len() + 2 {
+//         if i == party_num {
+//             new_vec.push(value_i.clone());
+//         } else {
+//             let value_j: T = serde_json::from_str(&ans_vec[j])?;
+//             new_vec.push(value_j);
+//             j += 1;
+//         }
+//     }
+//     Ok(())
+// }
 
-    let mut alpha_vec: Vec<Scalar> = Vec::new();
-    let mut miu_vec: Vec<Scalar> = Vec::new();
-
-    let mut j = 0;
-    for i in 1..context.threshould + 2 {
-        if i != context.party_num_int {
-            let m_b = m_b_gamma_rec_vec[j].clone();
-
-            let alpha_ij_gamma = m_b.verify_proofs_get_alpha(
-                &context.party_keys.dk,
-                &context.sign_keys.as_ref().unwrap().k_i,
-            )?;
-            let m_b = m_b_w_rec_vec[j].clone();
-            let alpha_ij_wi = m_b.verify_proofs_get_alpha(
-                &context.party_keys.dk,
-                &context.sign_keys.as_ref().unwrap().k_i,
-            )?;
-            alpha_vec.push(alpha_ij_gamma.0);
-            miu_vec.push(alpha_ij_wi.0);
-            let g_w_i = Keys::update_commitments_to_xi(
-                &context.xi_com_vec.as_ref().unwrap()
-                    [usize::from(context.signers_vec.as_ref().unwrap()[usize::from(i - 1)])],
-                &context.vss_scheme_vec
-                    [usize::from(context.signers_vec.as_ref().unwrap()[usize::from(i - 1)])],
-                context.signers_vec.as_ref().unwrap()[usize::from(i - 1)],
-                &context.signers_vec.as_ref().unwrap(),
-            );
-            assert_eq!(m_b.b_proof.pk, g_w_i);
-            j += 1;
-        }
-    }
-    //////////////////////////////////////////////////////////////////////////////
-    let delta_i = context
-        .sign_keys
-        .as_ref()
-        .unwrap()
-        .phase2_delta_i(&alpha_vec, &context.beta_vec.as_ref().unwrap());
-    let sigma = context
-        .sign_keys
-        .as_ref()
-        .unwrap()
-        .phase2_sigma_i(&miu_vec, &context.ni_vec.as_ref().unwrap());
-
-    broadcast(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        "round3",
-        serde_json::to_string(&delta_i)?,
-        context.uuid.clone(),
-    )
-    .await?;
-    let round3_ans_vec = poll_for_broadcasts(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        context.threshould + 1,
-        "round3",
-        context.uuid.clone(),
-        delay,
-    )
-    .await?;
-    let mut delta_vec: Vec<Scalar> = Vec::new();
-    format_vec_from_reads(
-        &round3_ans_vec,
-        context.party_num_int as usize,
-        delta_i,
-        &mut delta_vec,
-    )?;
-    let delta_inv = SignKeys::phase3_reconstruct_delta(&delta_vec);
-
-    context.m_b_gamma_rec_vec = Some(m_b_gamma_rec_vec);
-    context.delta_inv = Some(delta_inv);
-    context.sigma = Some(sigma);
-
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_sign_client_round4(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
-    let client = new_client_with_headers()?;
-    // decommit to gamma_i
-    broadcast(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        "round4",
-        serde_json::to_string(&context.decommit.as_ref().unwrap())?,
-        context.uuid.clone(),
-    )
-    .await?;
-    let round4_ans_vec = poll_for_broadcasts(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        context.threshould + 1,
-        "round4",
-        context.uuid.clone(),
-        delay,
-    )
-    .await?;
-
-    let mut decommit_vec: Vec<SignDecommitPhase1> = Vec::new();
-    format_vec_from_reads(
-        &round4_ans_vec,
-        context.party_num_int as usize,
-        context.decommit.clone().unwrap(),
-        &mut decommit_vec,
-    )?;
-
-    let decomm_i = decommit_vec.remove(usize::from(context.party_num_int - 1));
-    let _ = &context
-        .bc1_vec
-        .as_mut()
-        .unwrap()
-        .remove(usize::from(context.party_num_int - 1));
-    let b_proof_vec = (0..context.m_b_gamma_rec_vec.as_ref().unwrap().len())
-        .map(|i| &context.m_b_gamma_rec_vec.as_ref().unwrap()[i].b_proof)
-        .collect::<Vec<&DLogProof>>();
-
-    let R = SignKeys::phase4(
-        &context.delta_inv.as_ref().unwrap(),
-        &b_proof_vec,
-        decommit_vec,
-        &context.bc1_vec.as_ref().unwrap(),
-    )?;
-
-    // adding local g_gamma_i
-    let R = R + decomm_i.g_gamma_i * context.delta_inv.as_ref().unwrap();
-
-    // we assume the message is already hashed (by the signer).
-    let message = &context.message[..];
-    let message_bn = BigInt::from_bytes_be(message);
-    let local_sig = LocalSignature::phase5_local_sig(
-        &context.sign_keys.as_ref().unwrap().k_i,
-        &message_bn,
-        &R,
-        &context.sigma.as_ref().unwrap(),
-        &context.y_sum,
-    );
-
-    let (phase5_com, phase_5a_decom, helgamal_proof, dlog_proof_rho) =
-        local_sig.phase5a_broadcast_5b_zkproof();
-
-    context.phase5_com = Some(phase5_com);
-    context.phase_5a_decom = Some(phase_5a_decom);
-    context.helgamal_proof = Some(helgamal_proof);
-    context.dlog_proof_rho = Some(dlog_proof_rho);
-    context.local_sig = Some(local_sig);
-    context.r = Some(R);
-
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_sign_client_round5(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
-    let client = new_client_with_headers()?;
-    //phase (5A)  broadcast commit
-    broadcast(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        "round5",
-        serde_json::to_string(&context.phase5_com.as_ref().unwrap())?,
-        context.uuid.clone(),
-    )
-    .await?;
-    let round5_ans_vec = poll_for_broadcasts(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        context.threshould + 1,
-        "round5",
-        context.uuid.clone(),
-        delay,
-    )
-    .await?;
-
-    let mut commit5a_vec: Vec<Phase5Com1> = Vec::new();
-    format_vec_from_reads(
-        &round5_ans_vec,
-        context.party_num_int as usize,
-        context.phase5_com.clone().unwrap(),
-        &mut commit5a_vec,
-    )?;
-
-    context.commit5a_vec = Some(commit5a_vec);
-
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_sign_client_round6(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
-    let client = new_client_with_headers()?;
-    //phase (5B)  broadcast decommit and (5B) ZK proof
-    broadcast(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        "round6",
-        serde_json::to_string(&(
-            context.phase_5a_decom.clone().unwrap(),
-            context.helgamal_proof.clone().unwrap(),
-            context.dlog_proof_rho.clone().unwrap(),
-        ))?,
-        context.uuid.clone(),
-    )
-    .await?;
-    let round6_ans_vec = poll_for_broadcasts(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        context.threshould + 1,
-        "round6",
-        context.uuid.clone(),
-        delay,
-    )
-    .await?;
-
-    let mut decommit5a_and_elgamal_and_dlog_vec: Vec<(Phase5ADecom1, HomoELGamalProof, DLogProof)> =
-        Vec::new();
-    format_vec_from_reads(
-        &round6_ans_vec,
-        context.party_num_int as usize,
-        (
-            context.phase_5a_decom.clone().unwrap(),
-            context.helgamal_proof.clone().unwrap(),
-            context.dlog_proof_rho.clone().unwrap(),
-        ),
-        &mut decommit5a_and_elgamal_and_dlog_vec,
-    )?;
-    let decommit5a_and_elgamal_and_dlog_vec_includes_i =
-        decommit5a_and_elgamal_and_dlog_vec.clone();
-    decommit5a_and_elgamal_and_dlog_vec.remove(usize::from(context.party_num_int - 1));
-    context
-        .commit5a_vec
-        .as_mut()
-        .unwrap()
-        .remove(usize::from(context.party_num_int - 1));
-    let phase_5a_decomm_vec = (0..context.threshould)
-        .map(|i| decommit5a_and_elgamal_and_dlog_vec[i as usize].0.clone())
-        .collect::<Vec<Phase5ADecom1>>();
-    let phase_5a_elgamal_vec = (0..context.threshould)
-        .map(|i| decommit5a_and_elgamal_and_dlog_vec[i as usize].1.clone())
-        .collect::<Vec<HomoELGamalProof>>();
-    let phase_5a_dlog_vec = (0..context.threshould)
-        .map(|i| decommit5a_and_elgamal_and_dlog_vec[i as usize].2.clone())
-        .collect::<Vec<DLogProof>>();
-    let (phase5_com2, phase_5d_decom2) = context.local_sig.clone().unwrap().phase5c(
-        &phase_5a_decomm_vec,
-        &context.commit5a_vec.as_ref().unwrap(),
-        &phase_5a_elgamal_vec,
-        &phase_5a_dlog_vec,
-        &context.phase_5a_decom.as_ref().unwrap().V_i,
-        &context.r.as_ref().unwrap(),
-    )?;
-
-    context.phase5_com2 = Some(phase5_com2);
-    context.phase_5d_decom2 = Some(phase_5d_decom2);
-    context.decommit5a_and_elgamal_and_dlog_vec_includes_i =
-        Some(decommit5a_and_elgamal_and_dlog_vec_includes_i);
-
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_sign_client_round7(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
-    let client = new_client_with_headers()?;
-    //////////////////////////////////////////////////////////////////////////////
-    broadcast(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        "round7",
-        serde_json::to_string(&context.phase5_com2.as_ref().unwrap())?,
-        context.uuid.clone(),
-    )
-    .await?;
-    let round7_ans_vec = poll_for_broadcasts(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        context.threshould + 1,
-        "round7",
-        context.uuid.clone(),
-        delay,
-    )
-    .await?;
-
-    let mut commit5c_vec: Vec<Phase5Com2> = Vec::new();
-    format_vec_from_reads(
-        &round7_ans_vec,
-        context.party_num_int as usize,
-        context.phase5_com2.clone().unwrap(),
-        &mut commit5c_vec,
-    )?;
-
-    context.commit5c_vec = Some(commit5c_vec);
-
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_sign_client_round8(context: String, delay: u32) -> Result<String> {
-    let mut context = serde_json::from_str::<GG18SignClientContext>(&context)?;
-    let client = new_client_with_headers()?;
-    //phase (5B)  broadcast decommit and (5B) ZK proof
-    broadcast(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        "round8",
-        serde_json::to_string(&context.phase_5d_decom2.as_ref().unwrap())?,
-        context.uuid.clone(),
-    )
-    .await?;
-    let round8_ans_vec = poll_for_broadcasts(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        context.threshould + 1,
-        "round8",
-        context.uuid.clone(),
-        delay,
-    )
-    .await?;
-
-    let mut decommit5d_vec: Vec<Phase5DDecom2> = Vec::new();
-    format_vec_from_reads(
-        &round8_ans_vec,
-        context.party_num_int as usize,
-        context.phase_5d_decom2.clone().unwrap(),
-        &mut decommit5d_vec,
-    )?;
-
-    let phase_5a_decomm_vec_includes_i = (0..=context.threshould)
-        .map(|i| {
-            context
-                .decommit5a_and_elgamal_and_dlog_vec_includes_i
-                .clone()
-                .unwrap()[i as usize]
-                .0
-                .clone()
-        })
-        .collect::<Vec<Phase5ADecom1>>();
-    let s_i = context.local_sig.clone().unwrap().phase5d(
-        &decommit5d_vec,
-        &context.commit5c_vec.as_ref().unwrap(),
-        &phase_5a_decomm_vec_includes_i,
-    )?;
-
-    context.s_i = Some(s_i);
-
-    Ok(serde_json::to_string(&context)?)
-}
-
-#[wasm_bindgen]
-pub async fn gg18_sign_client_round9(context: String, delay: u32) -> Result<String> {
-    let context = serde_json::from_str::<GG18SignClientContext>(&context)?;
-    let client = new_client_with_headers()?;
-    //////////////////////////////////////////////////////////////////////////////
-    broadcast(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        "round9",
-        serde_json::to_string(&context.s_i.as_ref().unwrap())?,
-        context.uuid.clone(),
-    )
-    .await?;
-    let round9_ans_vec = poll_for_broadcasts(
-        &client,
-        &context.addr,
-        context.party_num_int,
-        context.threshould + 1,
-        "round9",
-        context.uuid.clone(),
-        delay,
-    )
-    .await?;
-
-    let mut s_i_vec: Vec<Scalar> = Vec::new();
-    format_vec_from_reads(
-        &round9_ans_vec,
-        context.party_num_int as usize,
-        context.s_i.unwrap(),
-        &mut s_i_vec,
-    )?;
-
-    s_i_vec.remove(usize::from(context.party_num_int - 1));
-    let sig = context
-        .local_sig
-        .clone()
-        .unwrap()
-        .output_signature(&s_i_vec)?;
-
-    let sign_json = serde_json::to_string(&vec![
-        //"r",
-        sig.r.to_big_int().to_hex(),
-        //"s",
-        sig.s.to_big_int().to_hex(),
-        //"v"
-        sig.recid.to_string(),
-    ])?;
-    crate::console_log!("sign_json: {:?}", sign_json);
-
-    check_sig(
-        &sig.r,
-        &sig.s,
-        &context.local_sig.clone().unwrap().m,
-        &context.y_sum.clone(),
-    )?;
-
-    Ok(sign_json)
-}
-
-fn format_vec_from_reads<'a, T: serde::Deserialize<'a> + Clone>(
-    ans_vec: &'a [String],
-    party_num: usize,
-    value_i: T,
-    new_vec: &'a mut Vec<T>,
-) -> Result<()> {
-    let mut j = 0;
-    for i in 1..ans_vec.len() + 2 {
-        if i == party_num {
-            new_vec.push(value_i.clone());
-        } else {
-            let value_j: T = serde_json::from_str(&ans_vec[j])?;
-            new_vec.push(value_j);
-            j += 1;
-        }
-    }
-    Ok(())
-}
diff --git a/src/common.rs b/src/common.rs
index a48dbed..b99a9be 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -36,6 +36,7 @@ pub struct AEAD {
 pub struct PartySignup {
     pub number: u16,
     pub uuid: String,
+    pub is_owner: u16,
 }
 
 #[derive(Clone, PartialEq, Debug, Serialize, Deserialize)]
diff --git a/src/curv/arithmetic/num_bigint.rs b/src/curv/arithmetic/num_bigint.rs
index d9abcd0..60743d7 100644
--- a/src/curv/arithmetic/num_bigint.rs
+++ b/src/curv/arithmetic/num_bigint.rs
@@ -71,19 +71,37 @@ impl Modulo for BigUint {
         x_ubn
     }
 }
-
 fn egcd(a: &BigUint, b: &BigUint) -> (BN, BN, BN) {
-    if a.mod_floor(b) == BigUint::zero() {
-        return (
-            b.clone().to_bigint().unwrap(),
-            BigUint::zero().to_bigint().unwrap(),
-            BigUint::one().to_bigint().unwrap(),
-        );
-    } else {
-        let (q, r) = a.div_rem(b);
-        let (d, x, y) = egcd(b, &r);
-        return (d, y.clone(), x - y * (q.to_bigint().unwrap()));
+    let mut a = a.clone().to_bigint().unwrap();
+    let mut b = b.clone().to_bigint().unwrap();
+
+    let mut ua = BN::one();
+    let mut va = BN::zero();
+
+    let mut ub = BN::zero();
+    let mut vb = BN::one();
+
+    let mut q;
+    let mut tmp;
+    let mut r;
+
+    while !b.is_zero() {
+        q = &a / &b;
+
+        r = &a % &b;
+
+        a = b;
+        b = r;
+
+        tmp = ua;
+        ua = ub.clone();
+        ub = tmp - &q * &ub;
+
+        tmp = va;
+        va = vb.clone();
+        vb = tmp - &q * &vb;
     }
+    (a, ua, va)
 }
 impl ConvertFrom<BigUint> for usize {
     fn _from(x: &BigUint) -> usize {