@digitaldefiance/express-suite-react-components 5.0.0 → 5.0.2

package/src/services/authService.ts

@@ -0,0 +1,692 @@
+// services/authService.js
+import {
+  EciesCryptoCore,
+  ECIESService,
+  EmailString,
+  hexToUint8Array,
+  IECIESConfig,
+  SecureString,
+  uint8ArrayToHex,
+} from '@digitaldefiance/ecies-lib';
+import {
+  getSuiteCoreTranslation,
+  IConstants,
+  IRequestUserDTO,
+  SuiteCoreStringKey,
+  TranslatableSuiteError,
+} from '@digitaldefiance/suite-core-lib';
+import { Wallet } from '@ethereumjs/wallet';
+import axios, { isAxiosError } from 'axios';
+import { createApiClient } from './api';
+import { createAuthenticatedApiClient } from './authenticatedApi';
+
+// API Response Types
+interface ApiErrorResponse {
+  message?: string;
+  error?: string | { message?: string; statusCode?: number; stack?: string };
+  errorType?: string;
+  field?: string;
+  errors?: Array<{ path: string; msg: string }>;
+}
+
+/**
+ * Extract a human-readable error string from an API error response.
+ * The backend may send `error` as either a plain string or an object
+ * with `{ message, statusCode, stack }`.
+ */
+export function extractErrorMessage(
+  errorData: ApiErrorResponse
+): string | undefined {
+  if (typeof errorData.error === 'string') {
+    return errorData.error;
+  }
+  if (
+    typeof errorData.error === 'object' &&
+    errorData.error !== null &&
+    typeof errorData.error.message === 'string'
+  ) {
+    return errorData.error.message;
+  }
+  return errorData.message;
+}
+
+interface RegisterResponse {
+  message: string;
+  mnemonic?: string;
+  data?: {
+    token: string;
+    memberId: string;
+    energyBalance: number;
+    mnemonic?: string;
+  };
+}
+
+interface LoginResponse {
+  token?: string;
+  user?: IRequestUserDTO;
+  message?: string;
+  pendingTotpToken?: string;
+}
+
+interface ChallengeResponse {
+  challenge: string;
+}
+
+interface BackupCodeLoginResponse {
+  token: string;
+  user: IRequestUserDTO;
+  codeCount: number;
+  mnemonic?: string;
+  message?: string;
+}
+
+export class AuthService {
+  private eciesService: ECIESService;
+  private cryptoCore: EciesCryptoCore;
+  private apiClient: axios.AxiosInstance;
+  private authenticatedApiClient: axios.AxiosInstance;
+
+  constructor(
+    private constants: IConstants,
+    private baseUrl: string,
+    eciesConfig: IECIESConfig,
+    private readonly siteDomain: string
+  ) {
+    this.eciesService = new ECIESService(eciesConfig);
+    this.cryptoCore = new EciesCryptoCore(eciesConfig);
+    this.apiClient = createApiClient(this.baseUrl);
+    this.authenticatedApiClient = createAuthenticatedApiClient(this.baseUrl);
+  }
+
+  getSiteDomain(): string {
+    return this.siteDomain;
+  }
+
+  async register(
+    username: string,
+    email: string,
+    timezone: string,
+    password?: string,
+    mnemonic?: string,
+    displayName?: string,
+    directChallenge?: boolean
+  ): Promise<
+    | { success: boolean; message: string; mnemonic: string }
+    | {
+        error: string;
+        errorType?: string;
+        field?: string;
+        errors?: Array<Record<string, string>>;
+      }
+  > {
+    try {
+      const response = await this.apiClient.post<RegisterResponse>(
+        '/user/register',
+        {
+          username,
+          email,
+          timezone,
+          ...(password ? { password } : {}),
+          ...(mnemonic ? { mnemonic } : {}),
+          ...(displayName ? { displayName } : {}),
+          ...(directChallenge ? { directChallenge } : {}),
+        }
+      );
+      if (response.status !== 201) {
+        const errorData = response.data as unknown as ApiErrorResponse;
+        return {
+          error: errorData.message
+            ? errorData.message
+            : getSuiteCoreTranslation(SuiteCoreStringKey.Registration_Error),
+          ...(errorData.errorType ? { errorType: errorData.errorType } : {}),
+          ...(errorData.errors ? { errors: errorData.errors } : {}),
+        };
+      }
+      return {
+        success: true,
+        message:
+          response.data.message ??
+          getSuiteCoreTranslation(SuiteCoreStringKey.Registration_Success, {
+            MNEMONIC: response.data.data?.mnemonic ?? response.data.mnemonic,
+          }),
+        mnemonic: response.data.data?.mnemonic ?? response.data.mnemonic ?? '',
+      };
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+          ...(errorData.errorType ? { errorType: errorData.errorType } : {}),
+          ...(errorData.field
+            ? { field: errorData.field }
+            : errorData.error
+              ? { field: 'general' }
+              : {}),
+          ...(errorData.errors ? { errors: errorData.errors } : {}),
+        };
+      } else {
+        return {
+          error: getSuiteCoreTranslation(
+            SuiteCoreStringKey.Common_UnexpectedError
+          ),
+        };
+      }
+    }
+  }
+
+  async directLogin(
+    mnemonic: SecureString,
+    username?: string,
+    email?: EmailString
+  ): Promise<
+    | { token: string; user: IRequestUserDTO; wallet: Wallet; message: string }
+    | { pendingTotpToken: string }
+    | { error: string; errorType?: string }
+  > {
+    if (!username && !email) {
+      return {
+        error: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Validation_UsernameOrEmailRequired
+        ),
+      };
+    }
+    try {
+      const loginRequest = await this.apiClient.post<ChallengeResponse>(
+        '/user/request-direct-login'
+      );
+      if (loginRequest.data.challenge) {
+        const { wallet } = this.cryptoCore.walletAndSeedFromMnemonic(mnemonic);
+        const challengeBuffer = hexToUint8Array(loginRequest.data.challenge);
+        const privateKeyBuffer = wallet.getPrivateKey();
+        const signature = this.eciesService.signMessage(
+          privateKeyBuffer,
+          challengeBuffer
+        );
+        const signatureHex = uint8ArrayToHex(signature);
+        const loginResponse = await this.apiClient.post<LoginResponse>(
+          '/user/direct-challenge',
+          {
+            username: username,
+            email: email ? email.email : undefined,
+            challenge: loginRequest.data.challenge,
+            signature: signatureHex,
+          }
+        );
+        if (loginResponse.data.pendingTotpToken) {
+          return {
+            pendingTotpToken: loginResponse.data.pendingTotpToken,
+          };
+        }
+        if (loginResponse.data.token && loginResponse.data.user) {
+          return {
+            message: loginResponse.data.message ?? '',
+            token: loginResponse.data.token,
+            user: loginResponse.data.user,
+            wallet,
+          };
+        }
+      }
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        // Check for DirectChallengeNotEnabled error
+        if (
+          error.response.status === 403 &&
+          error.response.data.errorType === 'DirectChallengeNotEnabledError'
+        ) {
+          return {
+            error: getSuiteCoreTranslation(
+              SuiteCoreStringKey.Error_Login_DirectChallengeNotEnabled
+            ),
+            errorType: 'DirectChallengeNotEnabled',
+          };
+        }
+        // Check for PasswordLoginNotEnabled error
+        if (
+          error.response.status === 403 &&
+          error.response.data.errorType === 'PasswordLoginNotEnabledError'
+        ) {
+          return {
+            error: getSuiteCoreTranslation(
+              SuiteCoreStringKey.Error_Login_PasswordLoginNotEnabled
+            ),
+            errorType: 'PasswordLoginNotEnabled',
+          };
+        }
+
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+          ...(errorData.errorType ? { errorType: errorData.errorType } : {}),
+        };
+      }
+      console.error('directLogin: non-axios error:', error);
+    }
+    return {
+      error: getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+    };
+  }
+
+  async requestEmailLogin(
+    username?: string,
+    email?: EmailString
+  ): Promise<string | { error: string; errorType?: string }> {
+    if (!username && !email) {
+      return {
+        error: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Validation_UsernameOrEmailRequired
+        ),
+      };
+    }
+    try {
+      const result = await this.apiClient.post<{ message: string }>(
+        '/user/request-email-login',
+        {
+          email: email ? email.email : undefined,
+          username,
+        }
+      );
+      if (result.data.message) {
+        return result.data.message;
+      }
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+          ...(errorData.errorType ? { errorType: errorData.errorType } : {}),
+        };
+      }
+    }
+    return {
+      error: getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+    };
+  }
+
+  async emailChallengeLogin(
+    mnemonic: SecureString,
+    token: string,
+    username?: string,
+    email?: EmailString
+  ): Promise<
+    | { token: string; user: IRequestUserDTO; wallet: Wallet; message: string }
+    | { pendingTotpToken: string }
+    | { error: string; errorType?: string }
+  > {
+    if (!username && !email) {
+      return {
+        error: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Validation_UsernameOrEmailRequired
+        ),
+      };
+    }
+    try {
+      const { wallet } = this.cryptoCore.walletAndSeedFromMnemonic(mnemonic);
+      const challengeBuffer = hexToUint8Array(token);
+      const privateKeyBuffer = wallet.getPrivateKey();
+      const signature = this.eciesService.signMessage(
+        privateKeyBuffer,
+        challengeBuffer
+      );
+      const signatureHex = uint8ArrayToHex(signature);
+      const response = await this.apiClient.post<LoginResponse>(
+        '/user/email-login',
+        {
+          token,
+          signature: signatureHex,
+          username: username ?? null,
+          email: email ?? null,
+        }
+      );
+      if (response.data.pendingTotpToken) {
+        return {
+          pendingTotpToken: response.data.pendingTotpToken,
+        };
+      }
+      if (response.data.token && response.data.user) {
+        return {
+          message: response.data.message ?? '',
+          token: response.data.token,
+          user: response.data.user,
+          wallet,
+        };
+      }
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+          ...(errorData.errorType ? { errorType: errorData.errorType } : {}),
+        };
+      }
+    }
+    return {
+      error: getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+    };
+  }
+
+  async verifyToken(
+    token: string
+  ): Promise<IRequestUserDTO | { error: string; errorType?: string }> {
+    try {
+      const response = await this.apiClient.get<{ user: IRequestUserDTO }>(
+        '/user/verify',
+        {
+          headers: { Authorization: `Bearer ${token}` },
+        }
+      );
+      return response.data.user;
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error: errorData.message
+            ? errorData.message
+            : (error as Error).message
+              ? (error as Error).message
+              : getSuiteCoreTranslation(
+                  SuiteCoreStringKey.Common_UnexpectedError
+                ),
+          ...(errorData.errorType ? { errorType: errorData.errorType } : {}),
+        };
+      } else {
+        return {
+          error: getSuiteCoreTranslation(
+            SuiteCoreStringKey.Common_UnexpectedError
+          ),
+        };
+      }
+    }
+  }
+
+  async refreshToken(): Promise<{
+    token: string;
+    user: IRequestUserDTO;
+  }> {
+    try {
+      const refreshResponse = await this.authenticatedApiClient.get<{
+        user: IRequestUserDTO;
+      }>('/user/refresh-token');
+      if (refreshResponse.status === 200) {
+        const newToken = refreshResponse.headers['authorization'] as
+          | string
+          | undefined;
+        let token: string | undefined = undefined;
+        let user: IRequestUserDTO | undefined = undefined;
+        if (
+          newToken &&
+          typeof newToken === 'string' &&
+          newToken.startsWith('Bearer ')
+        ) {
+          token = newToken.slice(7);
+        }
+        if (refreshResponse.data.user) {
+          user = refreshResponse.data.user;
+        }
+        if (token && user) {
+          return { token, user };
+        }
+      }
+    } catch (error) {
+      console.error('Token refresh error:', error);
+    }
+    throw new TranslatableSuiteError(SuiteCoreStringKey.Common_UnexpectedError);
+  }
+
+  async changePassword(
+    currentPassword: string,
+    newPassword: string
+  ): Promise<{ success: boolean } | { error: string; errorType?: string }> {
+    try {
+      await this.authenticatedApiClient.post('/user/change-password', {
+        currentPassword,
+        newPassword,
+      });
+      return { success: true };
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+          ...(errorData.errorType ? { errorType: errorData.errorType } : {}),
+        };
+      }
+      return {
+        error: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Common_UnexpectedError
+        ),
+      };
+    }
+  }
+
+  async backupCodeLogin(
+    identifier: string,
+    code: string,
+    isEmail: boolean,
+    recoverMnemonic: boolean,
+    newPassword?: string
+  ): Promise<
+    | {
+        token: string;
+        codeCount: number;
+        user?: IRequestUserDTO;
+        mnemonic?: string;
+        message?: string;
+      }
+    | { error: string; status?: number; errorType?: string }
+  > {
+    try {
+      const response = await this.apiClient.post<BackupCodeLoginResponse>(
+        '/user/backup-code',
+        {
+          [isEmail ? 'email' : 'username']: identifier,
+          code,
+          recoverMnemonic,
+          ...(newPassword ? { newPassword } : {}),
+        }
+      );
+      if (response.data.token && response.data.user) {
+        return {
+          token: response.data.token,
+          user: response.data.user,
+          codeCount: response.data.codeCount ?? 0,
+          ...(response.data.mnemonic
+            ? { mnemonic: response.data.mnemonic }
+            : {}),
+          ...(response.data.message ? { message: response.data.message } : {}),
+        };
+      }
+      const errorData = response.data as unknown as ApiErrorResponse;
+      return {
+        error: errorData.message
+          ? errorData.message
+          : getSuiteCoreTranslation(SuiteCoreStringKey.Validation_InvalidToken),
+        ...(errorData.errorType ? { errorType: errorData.errorType } : {}),
+      };
+    } catch (error) {
+      console.error('Backup code login error:', error);
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+          ...(errorData.errorType ? { errorType: errorData.errorType } : {}),
+          status: error.response.status,
+        };
+      }
+      return {
+        error: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Common_UnexpectedError
+        ),
+      };
+    }
+  }
+
+  async setupTotp(): Promise<
+    { provisioningUri: string; secret: string } | { error: string }
+  > {
+    try {
+      const response = await this.authenticatedApiClient.post<{
+        provisioningUri: string;
+        secret: string;
+      }>('/user/totp/setup');
+      return {
+        provisioningUri: response.data.provisioningUri,
+        secret: response.data.secret,
+      };
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+        };
+      }
+      return {
+        error: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Common_UnexpectedError
+        ),
+      };
+    }
+  }
+
+  async confirmTotp(
+    code: string
+  ): Promise<{ success: boolean } | { error: string }> {
+    try {
+      await this.authenticatedApiClient.post('/user/totp/confirm', { code });
+      return { success: true };
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+        };
+      }
+      return {
+        error: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Common_UnexpectedError
+        ),
+      };
+    }
+  }
+
+  async disableTotp(
+    code: string
+  ): Promise<{ success: boolean } | { error: string }> {
+    try {
+      await this.authenticatedApiClient.post('/user/totp/disable', { code });
+      return { success: true };
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+        };
+      }
+      return {
+        error: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Common_UnexpectedError
+        ),
+      };
+    }
+  }
+
+  async resetTotp(
+    code: string
+  ): Promise<{ provisioningUri: string; secret: string } | { error: string }> {
+    try {
+      const response = await this.authenticatedApiClient.post<{
+        provisioningUri: string;
+        secret: string;
+      }>('/user/totp/reset', { code });
+      return {
+        provisioningUri: response.data.provisioningUri,
+        secret: response.data.secret,
+      };
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+        };
+      }
+      return {
+        error: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Common_UnexpectedError
+        ),
+      };
+    }
+  }
+
+  async verifyTotpLogin(
+    pendingTotpToken: string,
+    code: string
+  ): Promise<{ token: string; user: IRequestUserDTO } | { error: string }> {
+    try {
+      const response = await this.apiClient.post<{
+        token: string;
+        user: IRequestUserDTO;
+      }>(
+        '/user/totp/verify',
+        { code },
+        {
+          headers: { Authorization: `Bearer ${pendingTotpToken}` },
+        }
+      );
+      return {
+        token: response.data.token,
+        user: response.data.user,
+      };
+    } catch (error) {
+      if (isAxiosError<ApiErrorResponse>(error) && error.response) {
+        const errorData = error.response.data;
+        return {
+          error:
+            extractErrorMessage(errorData) ??
+            (error as Error).message ??
+            getSuiteCoreTranslation(SuiteCoreStringKey.Common_UnexpectedError),
+        };
+      }
+      return {
+        error: getSuiteCoreTranslation(
+          SuiteCoreStringKey.Common_UnexpectedError
+        ),
+      };
+    }
+  }
+}
+
+export const createAuthService = (
+  constants: IConstants,
+  baseUrl: string,
+  eciesConfig: IECIESConfig,
+  siteDomain: string
+) => new AuthService(constants, baseUrl, eciesConfig, siteDomain);

package/src/services/authenticatedApi.ts

@@ -0,0 +1,17 @@
+import axios from 'axios';
+
+export function createAuthenticatedApiClient(baseURL: string, tokenKey: string = 'authToken') {
+  const api = axios.create({ baseURL });
+
+  api.interceptors.request.use((config) => {
+    const token = localStorage.getItem(tokenKey);
+    if (token) {
+      config.headers['Authorization'] = `Bearer ${token}`;
+    }
+    const languageCode = localStorage.getItem('languageCode') ?? 'en-US';
+    config.headers['Accept-Language'] = languageCode;
+    return config;
+  });
+
+  return api;
+}

package/src/services/index.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './authenticatedApi';
+export * from './authService';