@verified-network/verified-custody 0.2.0 → 0.2.1

package/src/services/contracts.ts

@@ -1,817 +0,0 @@
-import { AbiCoder, decodeBytes32String, encodeBytes32String } from "ethers";
-import { combine, split } from "shamir-secret-sharing";
-import {
-  contractAddress,
-  Custody,
-  Provider,
-  VerifiedWallet,
-} from "@verified-network/verified-sdk";
-import { createSmartAccountClient } from "@biconomy/account";
-import {
-  decryptString,
-  encryptString,
-  errorToast,
-  hashTheString,
-} from "../utils/helpers";
-import {
-  defaultChainId,
-  defaultVerifiedUrl,
-  newTransactionEventHash,
-  numberPositions,
-} from "../utils/constants";
-import { ChainConfig, PaymasterConfig } from "../utils/config";
-import { VerifiedCustodyHelpers } from "../utils/types";
-
-export const checkOrCreateVault = async (
-  vaultId: string,
-  hashedVaultId: string,
-  vaultPin: string,
-  hashedVaultPin: string,
-  otpChannel: string,
-  userPk: string,
-  userAddress: string,
-  vaultContract: any,
-  action?: string,
-  reqVaultData?: any,
-  txData?: any
-) => {
-  try {
-    const vaultData = {
-      vaultId,
-      hashedVaultId,
-      vaultPin,
-      hashedVaultPin,
-      vaultContract,
-    };
-    return await vaultContract
-      .getCreator(hashedVaultId, hashedVaultPin)
-      .then(async (res: any) => {
-        if (res?.status === 0) {
-          try {
-            if (action === "invitation") {
-              return { isExisting: true, ...vaultData };
-            } else {
-              if (chrome?.storage?.local) {
-                const secretKey = encodeBytes32String(vaultPin);
-
-                const encryptedPk = encryptString(userPk, secretKey);
-                await chrome.storage.local.set({
-                  myVault: JSON.stringify({
-                    vaultId,
-                    hashedVaultId: hashedVaultId,
-                    pk: encryptedPk,
-                    channel: otpChannel,
-                  }),
-                });
-              }
-              if (chrome?.runtime?.sendMessage) {
-                chrome.runtime.sendMessage({
-                  type:
-                    action && action === "connect_wallet"
-                      ? "getPk"
-                      : action && action !== "connect_wallet"
-                      ? action
-                      : "getPk",
-                  value: {
-                    vaultData:
-                      action && action === "signRecovery"
-                        ? reqVaultData
-                        : action && action === "completeRecovery"
-                        ? reqVaultData
-                        : { vaultId, hashedVaultId, hashedVaultPin },
-                    txData: txData,
-                  },
-                });
-              } else {
-                window.location.href = defaultVerifiedUrl;
-              }
-            }
-            return true;
-          } catch (err) {
-            if (process.env.REACT_APP_NODE_ENV !== "production") {
-              console.error("error handling existing vault: ", err);
-            }
-
-            errorToast(
-              "Oops something went wrong",
-              "Error fetching existing vault key(s). Try again later"
-            );
-            return false;
-          }
-        } else if (res?.reason?.toLowerCase() === "invalid pin") {
-          return null;
-        } else if (res?.reason?.toLowerCase() === "wallet not created") {
-          return await vaultContract
-            .createVault(hashedVaultId, hashedVaultPin)
-            .then(async (vultRes: any) => {
-              if (vultRes?.status === 0) {
-                return await vaultContract
-                  .confirmParticipant(
-                    hashedVaultId,
-                    hashedVaultPin,
-                    hashedVaultId,
-                    hashedVaultPin,
-                    true
-                  )
-                  .then(async (cfrmRes: any) => {
-                    if (cfrmRes?.status === 0) {
-                      try {
-                        const secretKey = encodeBytes32String(vaultPin);
-
-                        const encryptedPk = encryptString(userPk, secretKey);
-
-                        if (chrome?.storage?.local) {
-                          await chrome.storage.local.set({
-                            myVault: JSON.stringify({
-                              address: userAddress,
-                              vaultId,
-                              hashedVaultId: hashedVaultId,
-                              pk: encryptedPk,
-                              channel: otpChannel,
-                            }),
-                          });
-                        }
-
-                        return vaultData;
-                      } catch (err) {
-                        errorToast(
-                          "Oops something went wrong",
-                          "Error savingr new vault details. Try again later"
-                        );
-                        if (process.env.REACT_APP_NODE_ENV !== "production") {
-                          console.error("save vault failed: ", err);
-                        }
-
-                        return false;
-                      }
-                    } else {
-                      errorToast(
-                        "Oops something went wrong",
-                        "Error creating pin for new vault. Try again later"
-                      );
-
-                      if (process.env.REACT_APP_NODE_ENV !== "production") {
-                        console.error("confirm pin vault failed: ", cfrmRes);
-                      }
-                      return false;
-                    }
-                  });
-              } else {
-                errorToast(
-                  "Oops something went wrong",
-                  "Error creating new vault. Try again later"
-                );
-                if (process.env.REACT_APP_NODE_ENV !== "production") {
-                  console.error("create vault failed: ", vultRes);
-                }
-
-                return false;
-              }
-            });
-        }
-      });
-  } catch (err) {
-    if (process.env.REACT_APP_NODE_ENV !== "production") {
-      console.error("unexpected error: ", err);
-    }
-    errorToast(
-      "Oops something went wrong",
-      "Error while creating pin. Try again later"
-    );
-    return false;
-  }
-};
-
-export const validateVaultPin = async (
-  vaultId: string,
-  hashedVaultId: string,
-  vaultPin: string,
-  hashedVaultPin: string,
-  encryptedPk: any,
-  userAddress: string,
-  otpChannel: "sms" | "email",
-  newChainId?: number,
-  chainId?: number
-) => {
-  try {
-    const secretKey = encodeBytes32String(vaultPin);
-
-    const userPk = decryptString(encryptedPk, secretKey);
-
-    if (userPk) {
-      const cntAddresses: any = contractAddress;
-      const sender = new VerifiedWallet(userPk);
-      const _chainId =
-        chainId &&
-        cntAddresses[chainId]?.Custody &&
-        ChainConfig[chainId]?.rpcUrls?.length > 0
-          ? chainId
-          : defaultChainId;
-      const provider = ChainConfig[_chainId]?.rpcUrls[0];
-      const signer = sender.setProvider(new Provider(provider));
-
-      const vaultContract = new Custody(signer, cntAddresses[_chainId].Custody);
-
-      if (vaultContract) {
-        return await vaultContract
-          .getCreator(hashedVaultId, hashedVaultPin)
-          .then(async (res: any) => {
-            if (res?.status === 0) {
-              return {
-                address: userAddress,
-                vaultId,
-                hashedVaultId: hashedVaultId,
-                pk: userPk,
-                channel: otpChannel,
-                chainId: newChainId ? newChainId : _chainId,
-              };
-            } else {
-              if (process.env.REACT_APP_NODE_ENV !== "production") {
-                console.error("Invalid pin");
-              }
-              return null;
-            }
-          });
-      } else {
-        if (process.env.REACT_APP_NODE_ENV !== "production") {
-          console.error("error ggetting vault contract");
-        }
-        return null;
-      }
-    } else {
-      if (process.env.REACT_APP_NODE_ENV !== "production") {
-        console.error("error decrypting pk");
-      }
-      return null;
-    }
-  } catch (err) {
-    if (process.env.REACT_APP_NODE_ENV !== "production") {
-      console.error("unexpected error: ", err);
-    }
-    return null;
-  }
-};
-
-export const acceptOrRejectInvitation = async (
-  sendCreatorAcceptance: VerifiedCustodyHelpers["sendCreatorAcceptance"],
-  sendCreatorRejection: VerifiedCustodyHelpers["sendCreatorRejection"],
-  channel: "email" | "sms",
-  hashedCosignerId: string,
-  hashedCosignerPin: string,
-  hashedCreatorVaultId: string,
-  hashedCreatorVaultPin: string,
-  creatorVaultId: string,
-  coSignerVaultId: string,
-  accepted: boolean,
-  vaultContract?: any,
-  userPk?: string,
-  chainId?: number
-) => {
-  let contract: any;
-  if (vaultContract) {
-    contract = vaultContract;
-  } else {
-    const cntAddresses: any = contractAddress;
-    const sender = new VerifiedWallet(userPk);
-    const _chainId =
-      chainId &&
-      cntAddresses[chainId]?.Custody &&
-      ChainConfig[chainId]?.rpcUrls?.length > 0
-        ? chainId
-        : defaultChainId;
-    const provider = ChainConfig[_chainId]?.rpcUrls[0];
-    const signer = sender.setProvider(new Provider(provider));
-
-    contract = new Custody(signer, cntAddresses[_chainId].Custody);
-  }
-  if (contract) {
-    return await vaultContract
-      .confirmParticipant(
-        hashedCreatorVaultId,
-        hashedCosignerPin,
-        hashedCosignerId,
-        hashedCreatorVaultPin,
-        accepted
-      )
-      .then(async (res: any) => {
-        if (res?.status === 0) {
-          if (accepted) {
-            await sendCreatorAcceptance(
-              channel,
-              creatorVaultId,
-              coSignerVaultId
-            );
-          } else {
-            await sendCreatorRejection(
-              channel,
-              creatorVaultId,
-              coSignerVaultId
-            );
-          }
-
-          return true;
-        } else {
-          if (process.env.REACT_APP_NODE_ENV !== "production") {
-            console.error("Accept or reject invitation failed with");
-          }
-          return false;
-        }
-      })
-      .catch((err: any) => {
-        if (process.env.REACT_APP_NODE_ENV !== "production") {
-          console.error("Accept or reject invitation failed with error: ", err);
-        }
-        return false;
-      });
-  } else {
-    return false;
-  }
-};
-
-// const retryCompleteVault = async () => {
-//   failedParticipants = [...new Set(failedParticipants)]
-//   await Promise.all(
-//     failedParticipants.map(async (participant, idx) => {
-//          const retryAdd = await mainService.vault.addParticipant(
-//         vaultInfo.hashedVaultId,
-//         vaultInfo.hashedVaultPin,
-//         participant.hashedCosigner,
-//         participant.share
-//       )
-
-//       if (retryAdd.status) {
-//         // failedParticipants.push({
-//         //   creatorVaultId: ,
-//         //   fcmToken,
-//         //   cosigner,
-//         //   share: sharesArrayAsString[idx],
-//         // })
-//       } else {
-//         const filtered = failedParticipants.filter(
-//           (part) => part.cosigner !== participant.cosigner
-//         )
-//         failedParticipants = [...new Set(filtered)]
-//         await sendNotification({
-//           creator: vaultInfo.vaultId,
-//           hashedCreator: vaultInfo.hashedVaultId,
-//           idType: participant.idType,
-//           email: participant.cosigner,
-//           phoneNumber: participant.cosigner,
-//         })
-//       }
-//     })
-//   )
-
-//   if (failedParticipants.length > 0) {
-//     setIsRetry(true)
-//     setIsLoading(false)
-//     return
-//   }
-
-//   const addQuorum = await mainService.vault.defineQuorum(
-//     vaultInfo.hashedVaultId,
-//     vaultInfo.hashedVaultPin,
-//     threshold.toString() // coming from the slider
-//   )
-
-//   if (addQuorum.status) {
-//     return false
-//   }
-//   return true
-// }
-
-export const completeVaultCreation = async (
-  sendCoSignerInvitation: (
-    channel: "sms" | "email",
-    cosigerId: string,
-    cretorId: string,
-    hashedCretorPin: string
-  ) => Promise<boolean>,
-  sendCreatorConfirmation: (
-    channel: "sms" | "email",
-    cretorId: string,
-    cosigersList: [],
-    requiredSigners: number
-  ) => Promise<boolean>,
-  keyHolders: any,
-  coSigners: any,
-  otpChannel: "sms" | "email",
-  KeyThreshold: number,
-  vaultId: string,
-  hashedVaultId: string,
-  vaultPin: string,
-  hashedVaultPin: string,
-  vaultContract: any,
-  pk: string
-) => {
-  const keyShardsCount = Number(keyHolders.length);
-
-  const privateKeySplits = await split(
-    Uint8Array.from(pk.split("").map((letter: string) => letter.charCodeAt(0))),
-    Number(keyShardsCount),
-    KeyThreshold
-  );
-
-  const sharesArrayAsString = privateKeySplits.map((share) => share.join(","));
-
-  let failedKeyHolders = [];
-  let succesfulKeyHolders = [];
-
-  for (let idx = 0; idx < keyHolders.length; idx++) {
-    const participant = keyHolders[idx];
-    await vaultContract
-      .addParticipant(
-        hashedVaultId,
-        hashedVaultPin,
-        hashTheString(participant.vaultId),
-        sharesArrayAsString[idx]
-      )
-      .then(async (res: any) => {
-        const keyHolder = {
-          creatorVaultId: vaultId,
-          vaultPin: vaultPin,
-          creatorHashedVaultId: hashedVaultId,
-          creatorHashedVaultPin: hashedVaultPin,
-          cosigner: participant.vaultId,
-          hashedCosigner: hashTheString(participant.vaultId),
-          cosignerVaultIdType:
-            participant.otpChannel === "sms" ? "PHONE" : "EMAIL",
-          cosignerVaultId: participant.vaultId,
-          share: sharesArrayAsString[idx],
-          ...participant,
-        };
-        if (res?.status === 0) {
-          succesfulKeyHolders.push(keyHolder);
-          if (participant.vaultId !== vaultId) {
-            await sendCoSignerInvitation(
-              participant.otpChannel,
-              participant.vaultId,
-              vaultId,
-              hashedVaultPin
-            ).then((res) => {
-              if (!res) {
-                if (process.env.REACT_APP_NODE_ENV !== "production") {
-                  console.error("error while sending cosigner invite");
-                }
-                // errorToast("Oops somethin went wrong", "error while sending cosigner invite");
-              }
-            });
-          }
-        } else {
-          failedKeyHolders.push(keyHolder);
-        }
-      });
-  }
-
-  if (
-    failedKeyHolders?.length > 0 ||
-    succesfulKeyHolders?.length !== keyHolders?.length
-  ) {
-    if (process.env.REACT_APP_NODE_ENV !== "production") {
-      console.error("error while adding co-signers");
-    }
-    errorToast("Oops somethin went wrong", "error while adding co-signers");
-    return false;
-  }
-
-  return await vaultContract
-    .defineQuorum(hashedVaultId, hashedVaultPin, KeyThreshold.toString())
-    .then(async (res: any) => {
-      if (res?.status === 0) {
-        const cosignersList = coSigners?.map((cng: any) => {
-          return {
-            name: cng?.name,
-            email: cng?.email,
-            phoneNumber: cng?.phoneNumber,
-            contactType: String(cng?.otpChannel)?.toUpperCase(),
-            position: `${numberPositions[Number(cng?.position)]} Co-Signer`,
-          };
-        });
-        await sendCreatorConfirmation(
-          otpChannel,
-          vaultId,
-          cosignersList,
-          Number(KeyThreshold)
-        ).then((res) => {
-          if (!res) {
-            if (process.env.REACT_APP_NODE_ENV !== "production") {
-              console.error("error while sending creator's confirmation");
-            }
-            // errorToast("Oops somethin went wrong", "error while sending creator's confirmation");
-          }
-        });
-
-        return true;
-      } else {
-        if (process.env.REACT_APP_NODE_ENV !== "production") {
-          console.error("error while saving vault keys");
-        }
-        errorToast("Oops somethin went wrong", "error while saving vault keys");
-        return false;
-      }
-    });
-};
-
-export const initiateVaultRecovery = async (
-  sendCreatorInitiation: (
-    channel: "sms" | "email",
-    cretorId: string,
-    hashedCretorPin: string,
-    txId: number,
-    requiredSigners: number
-  ) => Promise<boolean>,
-  hashedVaultId: string,
-  hashedVaultPin: string,
-  vaultId: string,
-  vaultPin: string,
-  encryptedPk: string,
-  vaultChannel: "sms" | "email",
-  chainId?: number
-) => {
-  const secretKey = encodeBytes32String(vaultPin);
-
-  const userPk = decryptString(encryptedPk, secretKey);
-
-  if (userPk) {
-    const cntAddresses: any = contractAddress;
-    const sender = new VerifiedWallet(userPk);
-    const _chainId =
-      chainId &&
-      cntAddresses[chainId]?.Custody &&
-      ChainConfig[chainId]?.rpcUrls?.length > 0
-        ? chainId
-        : defaultChainId;
-    const provider = ChainConfig[_chainId]?.rpcUrls[0];
-    const signer = sender.setProvider(new Provider(provider));
-
-    const vaultContract = new Custody(signer, cntAddresses[_chainId].Custody);
-
-    if (vaultContract) {
-      return await vaultContract
-        .promptSignatures(hashedVaultId, hashedVaultPin)
-        .then(async (res: any) => {
-          if (res?.status === 0 && res?.response?.result?.logs) {
-            const abiCoder = new AbiCoder();
-            const vaultLogs = res?.response?.result?.logs?.filter(
-              (log: any) =>
-                log?.address?.toLowerCase() ===
-                  cntAddresses[_chainId].Custody?.toLowerCase() &&
-                log?.topics
-                  ?.map((tp: string) => tp?.toLowerCase())
-                  ?.includes(newTransactionEventHash?.toLowerCase())
-            );
-            const txData = vaultLogs[0]?.data;
-            const decodedTxData = abiCoder
-              .decode(["bytes32", "bytes32", "uint256"], txData)
-              ?.map((val, idx) =>
-                idx < 2 ? decodeBytes32String(val) : Number(val)
-              )
-              .flat();
-            const txId = decodedTxData[decodedTxData?.length - 1];
-            await sendCreatorInitiation(
-              vaultChannel,
-              vaultId,
-              hashedVaultPin,
-              Number(txId),
-              Number(vaultLogs?.length)
-            );
-            return true;
-          } else {
-            return false;
-          }
-        })
-        .catch((err: any) => {
-          if (process.env.REACT_APP_NODE_ENV !== "production") {
-            console.error("error while initiating vault recovery", err);
-          }
-          return false;
-        });
-    }
-  }
-};
-
-export const signVaultRecovery = async (
-  sendCreatorSigned: (
-    channel: "sms" | "email",
-    cretorId: string,
-    coSignerId: string
-  ) => Promise<boolean>,
-  sendCreatorCompleted: (
-    channel: "sms" | "email",
-    cretorId: string,
-    txId: number
-  ) => Promise<boolean>,
-  hashedVaultId: string,
-  hashedVaultPin: string,
-  vaultId: string,
-  vaultPin: string,
-  encryptedPk: string,
-  reqVaultId: string,
-  hashedReqId: string,
-  hashedReqPin: string,
-  reqTxId: string,
-  chainId?: number
-) => {
-  const secretKey = encodeBytes32String(vaultPin);
-
-  const userPk = decryptString(encryptedPk, secretKey);
-
-  if (userPk) {
-    const cntAddresses: any = contractAddress;
-    const sender = new VerifiedWallet(userPk);
-    const _chainId =
-      chainId &&
-      cntAddresses[chainId]?.Custody &&
-      ChainConfig[chainId]?.rpcUrls?.length > 0
-        ? chainId
-        : defaultChainId;
-    const provider = ChainConfig[_chainId]?.rpcUrls[0];
-    const signer = sender.setProvider(new Provider(provider));
-
-    const vaultContract = new Custody(signer, cntAddresses[_chainId].Custody);
-
-    if (vaultContract) {
-      return await vaultContract
-        .signTransaction(
-          hashedReqId,
-          hashedVaultPin,
-          hashedVaultId,
-          reqTxId,
-          hashedReqPin
-        )
-        .then(async (res: any) => {
-          if (res?.status === 0) {
-            await sendCreatorSigned(
-              /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(reqVaultId) ? "email" : "sms",
-              reqVaultId,
-              vaultId
-            );
-            return await vaultContract
-              .checkQuorum(hashedReqId, hashedReqPin, hashedVaultId, reqTxId)
-              .then(async (qRes: any) => {
-                if (qRes?.status === 0 && qRes?.response?.result) {
-                  if (qRes?.response?.result[0] === true) {
-                    await sendCreatorCompleted(
-                      /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(reqVaultId)
-                        ? "email"
-                        : "sms",
-                      reqVaultId,
-                      Number(reqTxId)
-                    );
-                  }
-                  return true;
-                } else {
-                  return false;
-                }
-              });
-          } else {
-            return false;
-          }
-        })
-        .catch((err: any) => {
-          if (process.env.REACT_APP_NODE_ENV !== "production") {
-            console.error("error while signing vault recovery", err);
-          }
-          return false;
-        });
-    }
-  }
-};
-
-export const restoreVaultLogin = async (
-  hashedVaultId: string,
-  hashedVaultPin: string,
-  vaultId: string,
-  vaultPin: string,
-  encryptedPk: string,
-  reqTxId: string,
-  otpChannel: "sms" | "email",
-  chainId?: number
-) => {
-  const secretKey = encodeBytes32String(vaultPin);
-
-  const userPk = decryptString(encryptedPk, secretKey);
-
-  if (userPk) {
-    const cntAddresses: any = contractAddress;
-    const sender = new VerifiedWallet(userPk);
-    const _chainId =
-      chainId &&
-      cntAddresses[chainId]?.Custody &&
-      ChainConfig[chainId]?.rpcUrls?.length > 0
-        ? chainId
-        : defaultChainId;
-    const provider = ChainConfig[_chainId]?.rpcUrls[0];
-    const signer = sender.setProvider(new Provider(provider));
-
-    const vaultContract = new Custody(signer, cntAddresses[_chainId].Custody);
-
-    if (vaultContract) {
-      return await vaultContract
-        .checkQuorum(hashedVaultId, hashedVaultPin, hashedVaultId, reqTxId)
-        .then(async (qRes: any) => {
-          if (qRes?.status === 0 && qRes?.response?.result) {
-            if (qRes?.response?.result[0] === true) {
-              return await vaultContract
-                .signTransaction(
-                  hashedVaultId,
-                  hashedVaultPin,
-                  hashedVaultId,
-                  reqTxId,
-                  hashedVaultPin
-                )
-                .then(async (res: any) => {
-                  if (res?.status === 0) {
-                    return await vaultContract
-                      .getShards(hashedVaultId, hashedVaultPin, reqTxId)
-                      .then(async (res: any) => {
-                        if (res?.status === 0 && res?.response?.result) {
-                          const recoveredShrads = res?.response?.result.filter(
-                            (shrd: string) => shrd !== ""
-                          );
-                          if (recoveredShrads.length > 1) {
-                            //at least 2 shrads?? since minimum signers are 2??
-                            const shares = recoveredShrads.map(
-                              (shrd: string) =>
-                                new Uint8Array(shrd.split(",").map(Number))
-                            );
-
-                            const combinedShares = await combine(shares);
-
-                            const pk = new TextDecoder().decode(combinedShares);
-
-                            if (pk) {
-                              const secretKey = encodeBytes32String(vaultPin);
-
-                              const newEncryptedPk = encryptString(
-                                pk,
-                                secretKey
-                              );
-
-                              const newSender = new VerifiedWallet(pk);
-
-                              const newSigner = newSender.setProvider(
-                                new Provider(provider)
-                              );
-
-                              const smartAccount =
-                                await createSmartAccountClient({
-                                  signer: newSigner,
-                                  bundlerUrl: `${PaymasterConfig.BUNDLER_URL_FIRST_SECTION}/${_chainId}/${PaymasterConfig[_chainId]["BUNDLER_API_KEY"]}`,
-                                  biconomyPaymasterApiKey:
-                                    PaymasterConfig[_chainId][
-                                      "PAYMASTER_API_KEY"
-                                    ],
-                                });
-                              const newAddress =
-                                await smartAccount.getAccountAddress();
-                              if (chrome?.storage?.local) {
-                                await chrome.storage.local.remove("myVault");
-                                await chrome.storage.local.set({
-                                  myVault: JSON.stringify({
-                                    address: newAddress,
-                                    vaultId,
-                                    hashedVaultId: hashedVaultId,
-                                    pk: newEncryptedPk,
-                                    channel: otpChannel,
-                                  }),
-                                });
-                              }
-                              return true;
-                            }
-                          } else {
-                            return false;
-                          }
-                        } else {
-                          return false;
-                        }
-                      })
-                      .catch((err: any) => {
-                        if (process.env.REACT_APP_NODE_ENV !== "production") {
-                          console.error(
-                            "error while restoring login access",
-                            err
-                          );
-                        }
-                        return false;
-                      });
-                  } else {
-                    return false;
-                  }
-                });
-            }
-          } else {
-            return false;
-          }
-        })
-        .catch((err: any) => {
-          if (process.env.REACT_APP_NODE_ENV !== "production") {
-            console.error("error while restoring login access", err);
-          }
-          return false;
-        });
-    } else {
-      return false;
-    }
-  }
-};