b5-api-client 0.0.25 → 0.0.27

package/dist/P2PMarketplaceAPIClient.d.ts

@@ -1,10 +1,19 @@
-import { CreateOrderRequest, CreateUserRequest, Order, OrderResponse, TakeOrderRequest, TestEventParams, UpdateOrderRequest, TransactionStatusResponse, RateUserRequest, OrderEventsResponse, PushNotificationsRegisterRequest, ConfigResponse, DashboardMetricsResponse, UsersResponse, GetOrdersParams, CreateDisputeRequest, DisputesResponse, OrderOffersResponse, TransactionRequest, KioscoinOperationResponse, UpdateUserSettingsRequest } from './types';
+import { CreateOrderRequest, CreateUserRequest, Order, OrderResponse, TakeOrderRequest, TestEventParams, UpdateOrderRequest, TransactionStatusResponse, RateUserRequest, OrderEventsResponse, PushNotificationsRegisterRequest, ConfigResponse, DashboardMetricsResponse, UsersResponse, GetOrdersParams, CreateDisputeRequest, DisputesResponse, OrderOffersResponse, TransactionRequest, KioscoinOperationResponse, UpdateUserSettingsRequest, NotificationsResponse, VerifyEmailRequest } from './types';
+export interface AuthTokenProvider {
+    getToken(): Promise<string | null>;
+    refreshToken(): Promise<string | null>;
+    onRefreshFailure?(error: unknown): void;
+}
 declare class P2PMarketplaceAPIClient {
     private readonly client;
     private readonly defaultHeaders;
+    private authTokenProvider?;
+    private refreshTokenPromise?;
     constructor(baseURL: string, timeout?: number);
+    setAuthTokenProvider(provider?: AuthTokenProvider): void;
     private mergeHeaders;
     private createConfig;
+    private getRefreshedToken;
     get<T>(url: string, headers?: Record<string, string>): Promise<T>;
     post<T>(url: string, data: any, headers?: Record<string, string>): Promise<T>;
     getOrders(props: GetOrdersParams, headers?: Record<string, string>): Promise<OrderResponse>;
@@ -16,14 +25,15 @@ declare class P2PMarketplaceAPIClient {
     getUser(userId: string, headers?: Record<string, string>): Promise<UsersResponse>;
     rateUser(rateUserRequest: RateUserRequest, headers?: Record<string, string>): Promise<any>;
     updateUserSettings(request: UpdateUserSettingsRequest, headers?: Record<string, string>): Promise<UsersResponse>;
+    verifyUserEmail(request: VerifyEmailRequest, headers?: Record<string, string>): Promise<UsersResponse>;
     registerPushToken(registerRequest: PushNotificationsRegisterRequest, headers?: Record<string, string>): Promise<any>;
+    listNotifications(limit?: number, offset?: number, headers?: Record<string, string>): Promise<NotificationsResponse>;
+    markNotificationAsRead(notificationId: string, headers?: Record<string, string>): Promise<NotificationsResponse>;
     getConfig<T>(): Promise<ConfigResponse<T>>;
     getOrderEvents(id: string, headers?: Record<string, string>): Promise<OrderEventsResponse>;
     getDashboardMetrics(headers?: Record<string, string>): Promise<DashboardMetricsResponse>;
     getOrderOffers(headers?: Record<string, string>): Promise<OrderOffersResponse>;
     pointOfSaleTransact(request: TransactionRequest, headers?: Record<string, string>): Promise<KioscoinOperationResponse>;
-    testLockFunds(order: Order, testParams?: TestEventParams, headers?: Record<string, string>): Promise<void>;
-    testReleaseFunds(order: Order, testParams?: TestEventParams, headers?: Record<string, string>): Promise<void>;
     releaseFunds(order: Order, testParams?: TestEventParams, headers?: Record<string, string>): Promise<string>;
     getTransactionStatus(txHash: string, headers?: Record<string, string>): Promise<TransactionStatusResponse>;
     createDispute(request: CreateDisputeRequest, headers?: Record<string, string>): Promise<DisputesResponse>;

package/dist/P2PMarketplaceAPIClient.js

@@ -25,12 +25,29 @@ class P2PMarketplaceAPIClient {
             'x-blockchain': 'rsk_testnet'
         };
         // Add a request interceptor to transform request data to snake_case
-        this.client.interceptors.request.use((config) => {
+        this.client.interceptors.request.use((config) => __awaiter(this, void 0, void 0, function* () {
             if (config.data) {
                 config.data = toSnakeCase(config.data);
             }
-            return config;
-        }, (error) => {
+            const provider = this.authTokenProvider;
+            if (!provider) {
+                return config;
+            }
+            return provider
+                .getToken()
+                .then((token) => {
+                var _a;
+                if (token) {
+                    config.headers = (_a = config.headers) !== null && _a !== void 0 ? _a : {};
+                    config.headers['Authorization'] = `Bearer ${token}`;
+                }
+                return config;
+            })
+                .catch((error) => {
+                console.warn('[P2PMarketplaceAPIClient] Failed to obtain auth token before request:', error);
+                return config;
+            });
+        }), (error) => {
             return Promise.reject(error);
         });
         // Add a response interceptor to transform response data to camelCase
@@ -39,9 +56,37 @@ class P2PMarketplaceAPIClient {
                 response.data = toCamelCase(response.data);
             }
             return response;
-        }, (error) => {
-            return Promise.reject(error);
-        });
+        }, (error) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { response, config } = error;
+            if (!this.authTokenProvider || (response === null || response === void 0 ? void 0 : response.status) !== 401 || !config) {
+                return Promise.reject(error);
+            }
+            const originalRequest = config;
+            if (originalRequest._retry) {
+                return Promise.reject(error);
+            }
+            originalRequest._retry = true;
+            try {
+                const newToken = yield this.getRefreshedToken();
+                if (!newToken) {
+                    return Promise.reject(error);
+                }
+                originalRequest.headers = (_a = originalRequest.headers) !== null && _a !== void 0 ? _a : {};
+                originalRequest.headers['Authorization'] = `Bearer ${newToken}`;
+                return this.client(originalRequest);
+            }
+            catch (refreshError) {
+                if ((_b = this.authTokenProvider) === null || _b === void 0 ? void 0 : _b.onRefreshFailure) {
+                    this.authTokenProvider.onRefreshFailure(refreshError);
+                }
+                return Promise.reject(error);
+            }
+        }));
+    }
+    setAuthTokenProvider(provider) {
+        this.authTokenProvider = provider;
+        this.refreshTokenPromise = undefined;
     }
     mergeHeaders(customHeaders) {
         return Object.assign(Object.assign({}, this.defaultHeaders), customHeaders);
@@ -51,6 +96,28 @@ class P2PMarketplaceAPIClient {
             headers: this.mergeHeaders(headers)
         };
     }
+    getRefreshedToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.authTokenProvider) {
+                return null;
+            }
+            if (!this.refreshTokenPromise) {
+                this.refreshTokenPromise = this.authTokenProvider
+                    .refreshToken()
+                    .catch((error) => {
+                    var _a;
+                    if ((_a = this.authTokenProvider) === null || _a === void 0 ? void 0 : _a.onRefreshFailure) {
+                        this.authTokenProvider.onRefreshFailure(error);
+                    }
+                    throw error;
+                })
+                    .finally(() => {
+                    this.refreshTokenPromise = undefined;
+                });
+            }
+            return this.refreshTokenPromise;
+        });
+    }
     get(url, headers) {
         return __awaiter(this, void 0, void 0, function* () {
             const config = this.createConfig(headers);
@@ -157,12 +224,30 @@ class P2PMarketplaceAPIClient {
             return this.post(url, request, headers);
         });
     }
+    verifyUserEmail(request, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = '/api/users/verify_email';
+            return this.post(url, request, headers);
+        });
+    }
     registerPushToken(registerRequest, headers) {
         return __awaiter(this, void 0, void 0, function* () {
             const url = `/api/notifications/register-push`;
             return this.post(url, registerRequest, headers);
         });
     }
+    listNotifications(limit = 10, offset = 0, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `/api/notifications?limit=${limit}&offset=${offset}`;
+            return this.get(url, headers);
+        });
+    }
+    markNotificationAsRead(notificationId, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `/api/notifications/${notificationId}/read`;
+            return this.post(url, {}, headers);
+        });
+    }
     getConfig() {
         return __awaiter(this, void 0, void 0, function* () {
             const url = '/api/configuration';
@@ -193,59 +278,6 @@ class P2PMarketplaceAPIClient {
             return this.post(url, request, headers);
         });
     }
-    testLockFunds(order, testParams, headers) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const orderEvent = {
-                type: "LOCKED",
-                orderId: (_a = order.id) !== null && _a !== void 0 ? _a : "",
-                buyerAddress: (_b = order.buyerAddress) !== null && _b !== void 0 ? _b : "",
-                amount: (_d = (_c = order.amount) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : "0",
-                transaction: {
-                    hash: "0x976d8c61b958e286d907a2e1c5ffde8c9316800ab4de1396a54927a39dc533a2",
-                },
-                tokenContractAddress: "0xee5e8291b551603a19ef41eea69ae49592ed14f8",
-                buyerHash: "02809d5cc2ec09a7503ef77358654a5bfc958e08c04ecb33f412884c0933be68",
-                sellerAddress: "0x2A4E89D18C2742FEDC65444d339cC5fAF3dE4dF1",
-                sellerHash: "4b3560738b8e3cb8a0a30ac664b12de2ace977c62ade94bc08a37fe5b93bf34b",
-                fee: "30000000000000000",
-                timestamp: new Date().toISOString(),
-            };
-            const url = "api/events/simulate/lock";
-            try {
-                yield this.post(url, orderEvent, headers);
-            }
-            catch (error) {
-                console.error("Error locking funds:", error);
-                throw new Error("Failed to lock funds");
-            }
-        });
-    }
-    testReleaseFunds(order, testParams, headers) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const releaseOrderEvent = {
-                type: "RELEASED",
-                orderId: (_a = order.id) !== null && _a !== void 0 ? _a : "",
-                buyerAddress: (_b = order.buyerAddress) !== null && _b !== void 0 ? _b : "",
-                amount: (_d = (_c = order.amount) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : "0",
-                transaction: {
-                    hash: "0xeab4797bf0e13dff0bda481503a544698127c5f97dd826c465ebdb41bcfec3f5",
-                },
-                tokenContractAddress: "0xee5e8291b551603a19ef41eea69ae49592ed14f8",
-                adminAction: true,
-                timestamp: new Date().toISOString(),
-            };
-            const url = "api/events/simulate/release";
-            try {
-                yield this.post(url, releaseOrderEvent, headers);
-            }
-            catch (error) {
-                console.error("Error releasing funds:", error);
-                throw new Error("Failed to release funds");
-            }
-        });
-    }
     releaseFunds(order, testParams, headers) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {

package/dist/auth/FirebaseLoginService.d.ts

@@ -52,10 +52,18 @@ export declare class FirebaseUnifiedService implements LoginService {
     private messaging;
     private auth;
     private readonly actionCodeSettings;
+    private readonly emailVerificationUrl;
+    private readonly emailVerificationContinueUrl?;
     private client;
+    private readonly initializationPromise;
     constructor(client: P2PMarketplaceAPIClient, config?: FirebaseLoginServiceConfig);
     private initializeFirebase;
+    private ensureAuthInstance;
+    private buildAuthTokenProvider;
     private fetchFirebaseConfig;
+    private buildEmailVerificationSettings;
+    private buildEmailVerificationUrl;
+    private ensureBackendVerification;
     requestNotificationPermission(): Promise<string | null>;
     fetchToken(): Promise<string | null>;
     onMessageListener(callback: (payload: any) => void): void;
@@ -72,6 +80,7 @@ export declare class FirebaseUnifiedService implements LoginService {
     isSignInWithEmailLink(): boolean;
     signInWithEmailLink(email: string): Promise<AuthResult>;
     getEmailForSignIn(): string | null;
+    applyEmailVerificationCode(oobCode: string): Promise<void>;
     private _createSuccessAuthResult;
     private getUserFromBackend;
     private createUserInBackend;

package/dist/auth/FirebaseLoginService.js

@@ -8,12 +8,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FirebaseUnifiedService = exports.AuthResult = exports.UserData = exports.AuthState = exports.AuthProvider = void 0;
 const app_1 = require("firebase/app");
 const auth_1 = require("firebase/auth");
 const messaging_1 = require("firebase/messaging");
 const UserContext_1 = require("./UserContext");
+const DEFAULT_EMAIL_VERIFICATION_PAGE = (_a = process.env.NEXT_PUBLIC_EMAIL_VERIFICATION_URL) !== null && _a !== void 0 ? _a : "http://localhost:3000/auth/email-verified";
+const trimTrailingSlash = (value) => value.replace(/\/+$/, "");
+const appendQueryParams = (base, params) => {
+    const query = Object.entries(params)
+        .filter(([, value]) => value !== undefined && value !== null)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+        .join("&");
+    if (!query) {
+        return base;
+    }
+    const separator = base.includes("?") ? "&" : "?";
+    return `${base}${separator}${query}`;
+};
 // Auth provider type for better type safety
 var AuthProvider;
 (function (AuthProvider) {
@@ -75,19 +89,28 @@ class AuthResult {
 exports.AuthResult = AuthResult;
 class FirebaseUnifiedService {
     constructor(client, config) {
-        var _a;
+        var _a, _b, _c, _d, _e;
         this.app = null;
         this.messaging = null;
         this.auth = null;
         this.client = client;
-        this.actionCodeSettings = (_a = config === null || config === void 0 ? void 0 : config.actionCodeSettings) !== null && _a !== void 0 ? _a : {
-            url: 'http://localhost:3000/auth/verify-email',
-            handleCodeInApp: true,
+        const fallbackVerificationPage = (_a = config === null || config === void 0 ? void 0 : config.emailVerificationUrl) !== null && _a !== void 0 ? _a : DEFAULT_EMAIL_VERIFICATION_PAGE;
+        this.emailVerificationUrl = trimTrailingSlash(fallbackVerificationPage);
+        this.emailVerificationContinueUrl = config === null || config === void 0 ? void 0 : config.emailVerificationContinueUrl;
+        const configuredActionSettings = config === null || config === void 0 ? void 0 : config.actionCodeSettings;
+        const defaultActionUrl = (_d = (_c = (_b = configuredActionSettings === null || configuredActionSettings === void 0 ? void 0 : configuredActionSettings.url) !== null && _b !== void 0 ? _b : process.env.REACT_APP_EMAIL_LINK_URL) !== null && _c !== void 0 ? _c : process.env.NEXT_PUBLIC_EMAIL_LINK_URL) !== null && _d !== void 0 ? _d : "http://localhost:3000/auth/verify-email";
+        this.actionCodeSettings = {
+            url: defaultActionUrl,
+            handleCodeInApp: (_e = configuredActionSettings === null || configuredActionSettings === void 0 ? void 0 : configuredActionSettings.handleCodeInApp) !== null && _e !== void 0 ? _e : true,
         };
-        this.initializeFirebase();
+        this.initializationPromise = this.initializeFirebase();
+        this.client.setAuthTokenProvider(this.buildAuthTokenProvider());
     }
     initializeFirebase() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.app) {
+                return;
+            }
             try {
                 const firebaseConfig = yield this.fetchFirebaseConfig();
                 this.app = (0, app_1.initializeApp)(firebaseConfig);
@@ -98,6 +121,42 @@ class FirebaseUnifiedService {
             }
         });
     }
+    ensureAuthInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.initializationPromise;
+            }
+            catch (_error) {
+                return null;
+            }
+            return this.auth;
+        });
+    }
+    buildAuthTokenProvider() {
+        return {
+            getToken: () => __awaiter(this, void 0, void 0, function* () {
+                const auth = yield this.ensureAuthInstance();
+                const currentUser = auth === null || auth === void 0 ? void 0 : auth.currentUser;
+                if (!currentUser) {
+                    return null;
+                }
+                return currentUser.getIdToken();
+            }),
+            refreshToken: () => __awaiter(this, void 0, void 0, function* () {
+                const auth = yield this.ensureAuthInstance();
+                const currentUser = auth === null || auth === void 0 ? void 0 : auth.currentUser;
+                if (!currentUser) {
+                    return null;
+                }
+                const refreshedToken = yield currentUser.getIdToken(true);
+                UserContext_1.userContext.updateUser({ idToken: refreshedToken });
+                return refreshedToken;
+            }),
+            onRefreshFailure: (error) => {
+                console.error("Failed to refresh Firebase ID token:", error);
+            }
+        };
+    }
     fetchFirebaseConfig() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -110,6 +169,54 @@ class FirebaseUnifiedService {
             }
         });
     }
+    buildEmailVerificationSettings(loginId) {
+        return {
+            url: this.buildEmailVerificationUrl(loginId),
+            handleCodeInApp: false,
+        };
+    }
+    buildEmailVerificationUrl(loginId) {
+        return appendQueryParams(this.emailVerificationUrl, {
+            loginId,
+            continueUrl: this.emailVerificationContinueUrl,
+        });
+    }
+    ensureBackendVerification(firebaseUser, backendUser, idToken) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        return __awaiter(this, void 0, void 0, function* () {
+            const firebaseVerified = firebaseUser.emailVerified;
+            const backendVerified = (_b = (_a = backendUser.settings) === null || _a === void 0 ? void 0 : _a.hasVerified) !== null && _b !== void 0 ? _b : false;
+            if (!firebaseVerified || backendVerified) {
+                return backendUser;
+            }
+            if (!backendUser.id) {
+                console.warn("Missing backend user id when attempting to mark verification status.");
+                return backendUser;
+            }
+            const settingsUpdate = {
+                paymentMethods: ((_d = (_c = backendUser.settings) === null || _c === void 0 ? void 0 : _c.paymentMethods) !== null && _d !== void 0 ? _d : []).map((method) => (Object.assign({}, method))),
+                hasVerified: true,
+            };
+            const preferredToken = (_e = backendUser.settings) === null || _e === void 0 ? void 0 : _e.preferredTokenCode;
+            if (preferredToken !== undefined && preferredToken !== null) {
+                settingsUpdate.preferredTokenCode = preferredToken;
+            }
+            const request = {
+                userId: backendUser.id,
+                settings: settingsUpdate,
+            };
+            try {
+                const response = yield this.client.updateUserSettings(request, {
+                    Authorization: `Bearer ${idToken}`,
+                });
+                return (_g = (_f = response.users) === null || _f === void 0 ? void 0 : _f[0]) !== null && _g !== void 0 ? _g : backendUser;
+            }
+            catch (error) {
+                console.error("Failed to update backend verification status:", error);
+                return backendUser;
+            }
+        });
+    }
     // Messaging methods
     requestNotificationPermission() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -169,22 +276,24 @@ class FirebaseUnifiedService {
     signInWithEmail(email, password) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.auth) {
+                const auth = yield this.ensureAuthInstance();
+                if (!auth) {
                     console.error("Firebase Auth not initialized");
                     return AuthResult.failure("Firebase Auth not initialized");
                 }
-                const userCredential = yield (0, auth_1.signInWithEmailAndPassword)(this.auth, email, password);
+                const userCredential = yield (0, auth_1.signInWithEmailAndPassword)(auth, email, password);
                 const idToken = yield userCredential.user.getIdToken();
                 const backendUser = yield this.getUserFromBackend(userCredential.user.uid, idToken);
                 if (backendUser) {
-                    const authResult = this._createSuccessAuthResult(userCredential.user, backendUser, AuthProvider.EMAIL, idToken);
+                    const syncedBackendUser = yield this.ensureBackendVerification(userCredential.user, backendUser, idToken);
+                    const authResult = this._createSuccessAuthResult(userCredential.user, syncedBackendUser, AuthProvider.EMAIL, idToken);
                     // Update UserContext
                     UserContext_1.userContext.setUser({
                         id: userCredential.user.uid,
-                        username: backendUser.username || '',
+                        username: syncedBackendUser.username || '',
                         email: userCredential.user.email || '',
-                        idToken: idToken,
-                        isAdmin: backendUser.admin || false
+                        idToken,
+                        isAdmin: syncedBackendUser.admin || false
                     });
                     return authResult;
                 }
@@ -205,15 +314,16 @@ class FirebaseUnifiedService {
     createUserWithEmail(email, password, username) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.auth) {
+                const auth = yield this.ensureAuthInstance();
+                if (!auth) {
                     return AuthResult.failure("Firebase Auth not initialized");
                 }
                 // First create the user in Firebase
-                const userCredential = yield (0, auth_1.createUserWithEmailAndPassword)(this.auth, email, password);
+                const userCredential = yield (0, auth_1.createUserWithEmailAndPassword)(auth, email, password);
                 const user = userCredential.user;
                 const idToken = yield user.getIdToken();
                 // Send email verification
-                yield (0, auth_1.sendEmailVerification)(user);
+                yield (0, auth_1.sendEmailVerification)(user, this.buildEmailVerificationSettings(user.uid));
                 const backendUser = yield this.createUserInBackend(user.uid, username, idToken);
                 if (backendUser) {
                     return this._createSuccessAuthResult(user, backendUser, AuthProvider.EMAIL, idToken);
@@ -231,18 +341,20 @@ class FirebaseUnifiedService {
     signInWithGoogle() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.auth) {
+                const auth = yield this.ensureAuthInstance();
+                if (!auth) {
                     return AuthResult.failure("Firebase Auth not initialized");
                 }
                 const provider = new auth_1.GoogleAuthProvider();
-                const userCredential = yield (0, auth_1.signInWithPopup)(this.auth, provider);
+                const userCredential = yield (0, auth_1.signInWithPopup)(auth, provider);
                 const user = userCredential.user;
-                // Get or create user in your Kotlin backend
-                const backendUser = yield this.getUserFromBackend(user.uid, user.displayName || '');
                 const idToken = yield user.getIdToken();
+                // Get or create user in your Kotlin backend
+                const backendUser = yield this.getUserFromBackend(user.uid, idToken);
                 if (backendUser) {
+                    const syncedBackendUser = yield this.ensureBackendVerification(user, backendUser, idToken);
                     // Use the new helper method
-                    return this._createSuccessAuthResult(user, backendUser, AuthProvider.GOOGLE, idToken);
+                    return this._createSuccessAuthResult(user, syncedBackendUser, AuthProvider.GOOGLE, idToken);
                 }
                 else {
                     return AuthResult.failure('Failed to get or create user in backend');
@@ -257,18 +369,20 @@ class FirebaseUnifiedService {
     signInWithFacebook() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.auth) {
+                const auth = yield this.ensureAuthInstance();
+                if (!auth) {
                     return AuthResult.failure("Firebase Auth not initialized");
                 }
                 const provider = new auth_1.FacebookAuthProvider();
-                const userCredential = yield (0, auth_1.signInWithPopup)(this.auth, provider);
+                const userCredential = yield (0, auth_1.signInWithPopup)(auth, provider);
                 const user = userCredential.user;
-                // Get or create user in your Kotlin backend
-                const backendUser = yield this.getUserFromBackend(user.uid, user.displayName || '');
                 const idToken = yield user.getIdToken();
+                // Get or create user in your Kotlin backend
+                const backendUser = yield this.getUserFromBackend(user.uid, idToken);
                 if (backendUser) {
+                    const syncedBackendUser = yield this.ensureBackendVerification(user, backendUser, idToken);
                     // Use the new helper method
-                    return this._createSuccessAuthResult(user, backendUser, AuthProvider.FACEBOOK, idToken);
+                    return this._createSuccessAuthResult(user, syncedBackendUser, AuthProvider.FACEBOOK, idToken);
                 }
                 else {
                     return AuthResult.failure('Failed to get or create user in backend');
@@ -283,18 +397,20 @@ class FirebaseUnifiedService {
     signInWithTwitter() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.auth) {
+                const auth = yield this.ensureAuthInstance();
+                if (!auth) {
                     return AuthResult.failure("Firebase Auth not initialized");
                 }
                 const provider = new auth_1.TwitterAuthProvider();
-                const userCredential = yield (0, auth_1.signInWithPopup)(this.auth, provider);
+                const userCredential = yield (0, auth_1.signInWithPopup)(auth, provider);
                 const user = userCredential.user;
-                // Get or create user in your Kotlin backend
-                const backendUser = yield this.getUserFromBackend(user.uid, user.displayName || '');
                 const idToken = yield user.getIdToken();
+                // Get or create user in your Kotlin backend
+                const backendUser = yield this.getUserFromBackend(user.uid, idToken);
                 if (backendUser) {
+                    const syncedBackendUser = yield this.ensureBackendVerification(user, backendUser, idToken);
                     // Use the new helper method
-                    return this._createSuccessAuthResult(user, backendUser, AuthProvider.TWITTER, idToken);
+                    return this._createSuccessAuthResult(user, syncedBackendUser, AuthProvider.TWITTER, idToken);
                 }
                 else {
                     return AuthResult.failure('Failed to get or create user in backend');
@@ -309,12 +425,13 @@ class FirebaseUnifiedService {
     sendEmailVerification() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.auth) {
+                const auth = yield this.ensureAuthInstance();
+                if (!auth) {
                     return false;
                 }
-                const user = this.auth.currentUser;
+                const user = auth.currentUser;
                 if (user) {
-                    yield (0, auth_1.sendEmailVerification)(user);
+                    yield (0, auth_1.sendEmailVerification)(user, this.buildEmailVerificationSettings(user.uid));
                     return true;
                 }
                 return false;
@@ -328,10 +445,11 @@ class FirebaseUnifiedService {
     sendPasswordResetEmail(email) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.auth) {
+                const auth = yield this.ensureAuthInstance();
+                if (!auth) {
                     return false;
                 }
-                yield (0, auth_1.sendPasswordResetEmail)(this.auth, email);
+                yield (0, auth_1.sendPasswordResetEmail)(auth, email);
                 return true;
             }
             catch (error) {
@@ -343,10 +461,12 @@ class FirebaseUnifiedService {
     signOut() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.auth) {
+                const auth = yield this.ensureAuthInstance();
+                if (!auth) {
+                    UserContext_1.userContext.clearUser();
                     return;
                 }
-                yield (0, auth_1.signOut)(this.auth);
+                yield (0, auth_1.signOut)(auth);
                 // Clear UserContext
                 UserContext_1.userContext.clearUser();
             }
@@ -364,10 +484,11 @@ class FirebaseUnifiedService {
     sendSignInLinkToEmail(email) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.auth) {
+                const auth = yield this.ensureAuthInstance();
+                if (!auth) {
                     return false;
                 }
-                yield (0, auth_1.sendSignInLinkToEmail)(this.auth, email, this.actionCodeSettings);
+                yield (0, auth_1.sendSignInLinkToEmail)(auth, email, this.actionCodeSettings);
                 // Save the email locally to use it later when the user clicks the link
                 window.localStorage.setItem('emailForSignIn', email);
                 return true;
@@ -387,22 +508,24 @@ class FirebaseUnifiedService {
     signInWithEmailLink(email) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                if (!this.auth) {
+                const auth = yield this.ensureAuthInstance();
+                if (!auth) {
                     return AuthResult.failure("Firebase Auth not initialized");
                 }
-                if (!this.isSignInWithEmailLink()) {
+                if (!(0, auth_1.isSignInWithEmailLink)(auth, window.location.href)) {
                     return AuthResult.failure("Invalid sign-in link");
                 }
-                const userCredential = yield (0, auth_1.signInWithEmailLink)(this.auth, email, window.location.href);
+                const userCredential = yield (0, auth_1.signInWithEmailLink)(auth, email, window.location.href);
                 const user = userCredential.user;
                 // Clear the email from localStorage
                 window.localStorage.removeItem('emailForSignIn');
-                // Get or create user in your Kotlin backend
-                const backendUser = yield this.getUserFromBackend(user.uid, user.displayName || '');
                 const idToken = yield user.getIdToken();
+                // Get or create user in your Kotlin backend
+                const backendUser = yield this.getUserFromBackend(user.uid, idToken);
                 if (backendUser) {
+                    const syncedBackendUser = yield this.ensureBackendVerification(user, backendUser, idToken);
                     // Use the new helper method
-                    return this._createSuccessAuthResult(user, backendUser, AuthProvider.EMAIL, idToken);
+                    return this._createSuccessAuthResult(user, syncedBackendUser, AuthProvider.EMAIL, idToken);
                 }
                 else {
                     return AuthResult.failure('Failed to get or create user in backend');
@@ -417,17 +540,26 @@ class FirebaseUnifiedService {
     getEmailForSignIn() {
         return window.localStorage.getItem('emailForSignIn');
     }
+    applyEmailVerificationCode(oobCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const auth = yield this.ensureAuthInstance();
+            if (!auth) {
+                throw new Error("Firebase Auth not initialized");
+            }
+            yield (0, auth_1.applyActionCode)(auth, oobCode);
+        });
+    }
     // Helper method to create success AuthResult
     _createSuccessAuthResult(user, backendUser, provider, idToken) {
         const userData = UserData.create(user.uid, user.email || '', backendUser.username || '', user.emailVerified, idToken, backendUser.admin || false);
         return AuthResult.success(backendUser, userData, provider);
     }
     // Backend integration methods
-    getUserFromBackend(userId, loginId) {
+    getUserFromBackend(userId, authToken) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const response = yield this.client.getUser(userId, {
-                    Authorization: `Bearer ${loginId}`,
+                    Authorization: `Bearer ${authToken}`,
                 });
                 return response.users[0];
             }