feat: add loginStatus field

src/helpers/citadelUtils.ts

@@ -0,0 +1,37 @@
+import { BUILD_ENV_TYPE, CITADEL_SERVER_MAP } from "@toruslabs/constants";
+import { get } from "@toruslabs/http-helpers";
+
+import { LoginStatus } from "../interfaces";
+
+export interface CitadelAllowParams {
+  buildEnv: BUILD_ENV_TYPE;
+  verifier: string;
+  verifierId: string;
+  network: string;
+  clientId: string;
+  source?: string;
+  loginStatus?: LoginStatus;
+}
+
+export function buildAllowUrl(params: CitadelAllowParams): string {
+  const url = new URL(`${CITADEL_SERVER_MAP[params.buildEnv]}/v1/signer/allow`);
+  url.searchParams.set("verifier", params.verifier);
+  url.searchParams.set("verifierid", params.verifierId);
+  url.searchParams.set("network", params.network);
+  url.searchParams.set("clientid", params.clientId);
+  if (params.source) {
+    url.searchParams.set("source", params.source);
+  }
+  if (params.loginStatus) {
+    url.searchParams.set("loginstatus", params.loginStatus);
+  }
+  return url.toString();
+}
+
+export async function callAllowApi(params: CitadelAllowParams): Promise<void> {
+  try {
+    await get<void>(buildAllowUrl(params));
+  } catch {
+    return;
+  }
+}

src/helpers/index.ts

@@ -1,3 +1,4 @@
+export * from "./citadelUtils";
 export * from "./common";
 export * from "./errorUtils";
 export * from "./keyUtils";

src/helpers/nodeUtils.ts

@@ -1,6 +1,6 @@
-import { BUILD_ENV_TYPE, CITADEL_SERVER_MAP, INodePub, KEY_TYPE, TORUS_NETWORK_TYPE } from "@toruslabs/constants";
+import { BUILD_ENV_TYPE, INodePub, KEY_TYPE, TORUS_NETWORK_TYPE } from "@toruslabs/constants";
 import { generatePrivate, getPublic } from "@toruslabs/eccrypto";
-import { generateJsonRPCObject, get, post } from "@toruslabs/http-helpers";
+import { generateJsonRPCObject, post } from "@toruslabs/http-helpers";
 import { lagrangeInterpolation } from "@toruslabs/metadata-helpers";
 
 import { config } from "../config";
@@ -16,6 +16,7 @@ import {
   JRPCResponse,
   KeyLookupResult,
   KeyType,
+  LoginStatus,
   SessionToken,
   ShareRequestResult,
   TorusKey,
@@ -27,6 +28,7 @@ import {
 import log from "../loglevel";
 import { Some } from "../some";
 import { TorusUtilsExtraParams } from "../TorusUtilsExtraParams";
+import { callAllowApi } from "./citadelUtils";
 import {
   base64ToBytes,
   bigintToHex,
@@ -387,15 +389,7 @@ export async function retrieveOrImportShare(params: {
     checkCommitment = true,
     source,
   } = params;
-  const url = new URL(`${CITADEL_SERVER_MAP[buildEnv]}/v1/signer/allow`);
-  url.searchParams.set("verifier", verifier);
-  url.searchParams.set("verifierid", verifierParams.verifier_id);
-  url.searchParams.set("network", network);
-  url.searchParams.set("clientid", clientId);
-  if (source) {
-    url.searchParams.set("source", source);
-  }
-  await get<void>(url.toString());
+  callAllowApi({ buildEnv, verifier, verifierId: verifierParams.verifier_id, network, clientId, source, loginStatus: LoginStatus.INITIATED });
 
   // generate temporary private and public key that is used to secure receive shares
   const sessionAuthKey = generatePrivate();

src/interfaces.ts

@@ -25,6 +25,12 @@ export type v1NonceResultType = { typeOfUser: "v1"; nonce?: string; seed?: strin
 export type GetOrSetNonceResult = v2NonceResultType | v1NonceResultType;
 export type KeyType = "secp256k1" | "ed25519";
 
+export enum LoginStatus {
+  INITIATED = "initiated",
+  SUCCESS = "success",
+  FAILED = "failed",
+}
+
 export interface SetNonceData {
   operation: string;
   data: string;

src/torus.ts

@@ -5,6 +5,7 @@ import { config } from "./config";
 import {
   bigintToHex,
   bytesToHex,
+  callAllowApi,
   Curve,
   encodeEd25519Point,
   generateAddressFromPubKey,
@@ -27,6 +28,7 @@ import {
   ImportKeyParams,
   KeyType,
   LegacyVerifierLookupResponse,
+  LoginStatus,
   RetrieveSharesParams,
   TorusCtorOptions,
   TorusKey,
@@ -147,28 +149,46 @@ class Torus {
       extraParams.session_token_exp_second = Torus.sessionTime;
     }
 
-    return retrieveOrImportShare({
-      legacyMetadataHost: this.legacyMetadataHost,
-      serverTimeOffset: this.serverTimeOffset,
-      enableOneKey: this.enableOneKey,
-      ecCurve: this.ec,
-      keyType: this.keyType,
-      network: this.network,
-      clientId: this.clientId,
+    const allowParams = {
       buildEnv: this.buildEnv,
-      endpoints,
-      indexes,
       verifier,
-      verifierParams,
-      idToken,
-      useDkg: shouldUseDkg,
-      newImportedShares: [],
-      overrideExistingKey: false,
-      nodePubkeys,
-      extraParams,
-      checkCommitment,
+      verifierId: verifierParams.verifier_id,
+      network: this.network,
+      clientId: this.clientId,
       source: this.source,
-    });
+    };
+
+    let result: TorusKey;
+    try {
+      result = await retrieveOrImportShare({
+        legacyMetadataHost: this.legacyMetadataHost,
+        serverTimeOffset: this.serverTimeOffset,
+        enableOneKey: this.enableOneKey,
+        ecCurve: this.ec,
+        keyType: this.keyType,
+        network: this.network,
+        clientId: this.clientId,
+        buildEnv: this.buildEnv,
+        endpoints,
+        indexes,
+        verifier,
+        verifierParams,
+        idToken,
+        useDkg: shouldUseDkg,
+        newImportedShares: [],
+        overrideExistingKey: false,
+        nodePubkeys,
+        extraParams,
+        checkCommitment,
+        source: this.source,
+      });
+    } catch (error) {
+      callAllowApi({ ...allowParams, loginStatus: LoginStatus.FAILED });
+      throw error;
+    }
+
+    callAllowApi({ ...allowParams, loginStatus: LoginStatus.SUCCESS });
+    return result;
   }
 
   async getPublicAddress(