b5-api-client 0.0.22 → 0.0.24

package/dist/types.d.ts

@@ -43,6 +43,8 @@ export interface Order {
     sellerCanDispute?: boolean;
     buyerDisputed?: boolean;
     sellerDisputed?: boolean;
+    escrowOrder?: EscrowOrderModel;
+    dispute?: Dispute[];
 }
 export interface OrderResponse {
     orders: Order[];
@@ -50,6 +52,14 @@ export interface OrderResponse {
 export interface UsersResponse {
     users: KioscoinUser[];
 }
+export interface UserSettings {
+    preferredTokenCode?: string;
+    paymentMethods: PaymentMethod[];
+}
+export interface UpdateUserSettingsRequest {
+    userId: string;
+    settings: UserSettings;
+}
 export interface PaymentMethod {
     type: string;
     alias?: string;
@@ -239,6 +249,7 @@ export interface KioscoinUser {
     timeToRelease?: number;
     timeToFiatSent?: number;
     reviews?: UserReview[];
+    settings?: UserSettings;
 }
 export type DisputeReason = 'SELLER_NOT_LOCKING' | 'BUYER_FIAT_NOT_SENT' | 'SELLER_NOT_RELEASING';
 export interface CreateDisputeRequest {
@@ -280,3 +291,51 @@ export interface TransactionRequest {
     offer: OrderOffer;
     buyerAddress?: string;
 }
+export type EscrowOrderStatus = 'NON_EXISTING' | 'LOCKED' | 'RELEASED' | 'REFUNDED';
+export interface EscrowOrderModel {
+    id: string;
+    timestamp?: string;
+    tokenContractAddress?: string;
+    buyerAddress?: string;
+    sellerAddress?: string;
+    amount?: string;
+    fee?: string;
+    status?: EscrowOrderStatus;
+    adminAction?: boolean;
+    token?: string;
+}
+export interface ExchangeRateOffer {
+    id: string;
+    tokenCode: string;
+    blockchainEnvironment: string;
+    fiatCode: string;
+    baseFiatRate: string;
+    offeredFiatRate: string;
+    margin: string;
+    validUntil: string;
+    isActive: boolean;
+    createdAt: string;
+}
+export interface KioscoinOperation {
+    orderType: OrderType;
+    tokenAmount: string;
+    fiatAmount: string;
+    tokenCode: string;
+    fiatCode: string;
+    blockchain: string;
+    userId: string;
+    username?: string;
+    buyerAddress?: string;
+    paymentMethods?: PaymentMethod[];
+    orderOffer?: OrderOffer;
+    exchangeRateOffer?: ExchangeRateOffer;
+}
+export type OperationErrorType = 'INVALID_TRANSACTION' | 'HAS_ACTIVE_ORDERS' | 'INSUFFICIENT_FUNDS' | 'UNKNOWN_ERROR';
+export interface OperationError {
+    type: OperationErrorType;
+    message: string;
+}
+export interface KioscoinOperationResponse {
+    error?: OperationError;
+    order?: Order;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "b5-api-client",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "Escrow Backend API client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,7 +12,8 @@
   "dependencies": {
     "axios": "^1.6.7",
     "https-proxy-agent": "^7.0.5",
-    "lodash": "^4.17.21"
+    "lodash": "^4.17.21",
+    "firebase": "11.1.0"
   },
   "devDependencies": {
     "@types/lodash": "^4.17.7",

package/src/FirebaseLoginService.ts

@@ -0,0 +1,496 @@
+import { initializeApp } from "firebase/app";
+import {
+    getAuth,
+    signInWithEmailAndPassword,
+    createUserWithEmailAndPassword,
+    sendEmailVerification,
+    sendPasswordResetEmail,
+    signOut,
+    User,
+    GoogleAuthProvider,
+    FacebookAuthProvider,
+    TwitterAuthProvider,
+    signInWithPopup,
+    isSignInWithEmailLink,
+    sendSignInLinkToEmail,
+    signInWithEmailLink,
+    Auth
+} from "firebase/auth";
+import { getMessaging, getToken, onMessage, MessagePayload } from "firebase/messaging";
+import { CreateUserRequest, KioscoinUser } from "./types";
+import P2PMarketplaceAPIClient from "./P2PMarketplaceAPIClient";
+import { FirebaseLoginServiceConfig, LoginService } from "./auth/LoginService";
+import { userContext } from './auth/UserContext';
+
+
+// Auth provider type for better type safety
+export enum AuthProvider {
+    EMAIL = 'EMAIL',
+    GOOGLE = 'GOOGLE',
+    FACEBOOK = 'FACEBOOK',
+    TWITTER = 'TWITTER'
+}
+
+// Immutable auth state class
+export class AuthState {
+    private constructor(
+        public readonly isAuthenticated: boolean,
+        public readonly user: UserData | null,
+        public readonly provider: AuthProvider | null
+    ) { }
+
+    static authenticated(user: UserData, provider: AuthProvider): AuthState {
+        return new AuthState(true, user, provider);
+    }
+
+    static unauthenticated(): AuthState {
+        return new AuthState(false, null, null);
+    }
+}
+
+// Enhanced UserData class with additional safety
+export class UserData {
+    private constructor(
+        public readonly id: string,
+        public readonly email: string,
+        public readonly username: string,
+        public readonly isEmailVerified: boolean,
+        public readonly idToken: string | null
+    ) { }
+
+    static create(
+        id: string,
+        email: string,
+        username: string,
+        isEmailVerified: boolean,
+        idToken: string | null
+    ): UserData {
+        return new UserData(
+            id,
+            email,
+            username,
+            isEmailVerified,
+            idToken
+        );
+    }
+
+    withEmailVerified(): UserData {
+        return new UserData(
+            this.id,
+            this.email,
+            this.username,
+            true,
+            this.idToken
+        );
+    }
+}
+
+// Enhanced AuthResult class
+export class AuthResult {
+    private constructor(
+        public readonly success: boolean,
+        public readonly user: KioscoinUser | null,
+        public readonly userData: UserData | null,
+        public readonly error: string | null,
+        public readonly provider: AuthProvider | null
+    ) { }
+
+    static success(user: KioscoinUser, userData: UserData, provider: AuthProvider): AuthResult {
+        return new AuthResult(true, user, userData, null, provider);
+    }
+
+    static failure(error: string): AuthResult {
+        return new AuthResult(false, null, null, error, null);
+    }
+}
+
+export interface FirebaseConfig {
+    apiKey: string;
+    authDomain: string;
+    projectId: string;
+    storageBucket: string;
+    messagingSenderId: string;
+    appId: string;
+    measurementId?: string;
+}
+
+export class FirebaseUnifiedService implements LoginService {
+    private app: ReturnType<typeof initializeApp> | null = null;
+    private messaging: ReturnType<typeof getMessaging> | null = null;
+    private auth: Auth | null = null;
+    private readonly actionCodeSettings: { url: string; handleCodeInApp: boolean };
+    private client: P2PMarketplaceAPIClient;
+
+    constructor(client: P2PMarketplaceAPIClient, config?: FirebaseLoginServiceConfig) {
+        this.client = client;
+        this.actionCodeSettings = config?.actionCodeSettings ?? {
+            url: 'http://localhost:3000/auth/verify-email',
+            handleCodeInApp: true,
+        };
+        this.initializeFirebase();
+    }
+
+    private async initializeFirebase() {
+        try {
+            const firebaseConfig = await this.fetchFirebaseConfig();
+            this.app = initializeApp(firebaseConfig);
+            this.auth = getAuth(this.app);
+        } catch (error) {
+            console.error("Failed to initialize Firebase app:", error);
+        }
+    }
+
+    private async fetchFirebaseConfig(): Promise<FirebaseConfig> {
+        try {
+            const response = await this.client.getConfig<{ firebase: FirebaseConfig }>();
+            return response.config.firebase;
+        } catch (error) {
+            console.error("Error fetching Firebase configuration:", error);
+            throw new Error("Failed to initialize Firebase configuration");
+        }
+    }
+
+    // Messaging methods
+    public async requestNotificationPermission(): Promise<string | null> {
+        if (!this.app) {
+            await this.initializeFirebase();
+        }
+
+        if (!this.messaging) {
+            console.warn("Messaging is not available");
+            return null;
+        }
+
+        try {
+            const permission = await Notification.requestPermission();
+            if (permission === "granted") {
+                const token = await getToken(this.messaging, {
+                    vapidKey: process.env.REACT_APP_FIREBASE_VAPID_KEY,
+                });
+                return token;
+            }
+            return null;
+        } catch (error) {
+            console.error("Failed to get notification token:", error);
+            return null;
+        }
+    }
+    async fetchToken(): Promise<string | null> {
+        try {
+            if (!this.messaging && this.app) {
+                this.messaging = getMessaging(this.app);
+            }
+            if (this.messaging) {
+                const currentToken = await getToken(this.messaging);
+                return currentToken;
+            }
+            return null;
+        } catch (error) {
+            console.error("An error occurred while retrieving token. ", error);
+            return null;
+        }
+    }
+
+    onMessageListener(callback: (payload: any) => void) {
+        if (!this.messaging && this.app) {
+            this.messaging = getMessaging(this.app);
+        }
+        if (this.messaging) {
+            onMessage(this.messaging, callback);
+        } else {
+            console.error("Messaging is not initialized.");
+        }
+    }
+
+    // Authentication methods
+    async signInWithEmail(email: string, password: string): Promise<AuthResult> {
+        try {
+            if (!this.auth) {
+                console.error("Firebase Auth not initialized");
+                return AuthResult.failure("Firebase Auth not initialized");
+            }
+            const userCredential = await signInWithEmailAndPassword(this.auth, email, password);
+            const idToken = await userCredential.user.getIdToken();
+            const backendUser = await this.getUserFromBackend(userCredential.user.uid, idToken);
+
+            if (backendUser) {
+                const authResult = this._createSuccessAuthResult(userCredential.user, backendUser, AuthProvider.EMAIL, idToken);
+                // Update UserContext
+                userContext.setUser({
+                    id: userCredential.user.uid,
+                    username: backendUser.username || '',
+                    email: userCredential.user.email || '',
+                    idToken: idToken
+                });
+                return authResult;
+            } else {
+                return AuthResult.failure('User not found in backend');
+            }
+        } catch (error: any) {
+            console.error('Detailed error signing in with email:', {
+                code: error.code,
+                message: error.message,
+                fullError: error
+            });
+            return AuthResult.failure(error.message || 'Authentication failed');
+        }
+    }
+
+    async createUserWithEmail(email: string, password: string, username: string): Promise<AuthResult> {
+        try {
+            if (!this.auth) {
+                return AuthResult.failure("Firebase Auth not initialized");
+            }
+
+            // First create the user in Firebase
+            const userCredential = await createUserWithEmailAndPassword(this.auth, email, password);
+            const user = userCredential.user;
+            const idToken = await user.getIdToken();
+            // Send email verification
+            await sendEmailVerification(user);
+
+            const backendUser = await this.createUserInBackend(user.uid, username, idToken);
+
+            if (backendUser) {
+                return this._createSuccessAuthResult(user, backendUser, AuthProvider.EMAIL, idToken);
+            } else {
+                return AuthResult.failure('Failed to create user in backend');
+            }
+        } catch (error: any) {
+            console.error('Error creating user with email:', error);
+            return AuthResult.failure(error.message || 'User creation failed');
+        }
+    }
+
+    async signInWithGoogle(): Promise<AuthResult> {
+        try {
+            if (!this.auth) {
+                return AuthResult.failure("Firebase Auth not initialized");
+            }
+
+            const provider = new GoogleAuthProvider();
+            const userCredential = await signInWithPopup(this.auth, provider);
+            const user = userCredential.user;
+
+            // Get or create user in your Kotlin backend
+            const backendUser = await this.getUserFromBackend(user.uid, user.displayName || '');
+            const idToken = await user.getIdToken();
+            if (backendUser) {
+                // Use the new helper method
+                return this._createSuccessAuthResult(user, backendUser, AuthProvider.GOOGLE, idToken);
+            } else {
+                return AuthResult.failure('Failed to get or create user in backend');
+            }
+        } catch (error: any) {
+            console.error('Error signing in with Google:', error);
+            return AuthResult.failure(error.message || 'Google authentication failed');
+        }
+    }
+
+    async signInWithFacebook(): Promise<AuthResult> {
+        try {
+            if (!this.auth) {
+                return AuthResult.failure("Firebase Auth not initialized");
+            }
+
+            const provider = new FacebookAuthProvider();
+            const userCredential = await signInWithPopup(this.auth, provider);
+            const user = userCredential.user;
+
+            // Get or create user in your Kotlin backend
+            const backendUser = await this.getUserFromBackend(user.uid, user.displayName || '');
+            const idToken = await user.getIdToken();
+            if (backendUser) {
+                // Use the new helper method
+                return this._createSuccessAuthResult(user, backendUser, AuthProvider.FACEBOOK, idToken);
+            } else {
+                return AuthResult.failure('Failed to get or create user in backend');
+            }
+        } catch (error: any) {
+            console.error('Error signing in with Facebook:', error);
+            return AuthResult.failure(error.message || 'Facebook authentication failed');
+        }
+    }
+
+    async signInWithTwitter(): Promise<AuthResult> {
+        try {
+            if (!this.auth) {
+                return AuthResult.failure("Firebase Auth not initialized");
+            }
+
+            const provider = new TwitterAuthProvider();
+            const userCredential = await signInWithPopup(this.auth, provider);
+            const user = userCredential.user;
+
+            // Get or create user in your Kotlin backend
+            const backendUser = await this.getUserFromBackend(user.uid, user.displayName || '');
+            const idToken = await user.getIdToken();
+            if (backendUser) {
+                // Use the new helper method
+                return this._createSuccessAuthResult(user, backendUser, AuthProvider.TWITTER, idToken);
+            } else {
+                return AuthResult.failure('Failed to get or create user in backend');
+            }
+        } catch (error: any) {
+            console.error('Error signing in with Twitter:', error);
+            return AuthResult.failure(error.message || 'Twitter authentication failed');
+        }
+    }
+
+    async sendEmailVerification(): Promise<boolean> {
+        try {
+            if (!this.auth) {
+                return false;
+            }
+
+            const user = this.auth.currentUser;
+            if (user) {
+                await sendEmailVerification(user);
+                return true;
+            }
+            return false;
+        } catch (error) {
+            console.error('Error sending email verification:', error);
+            return false;
+        }
+    }
+
+    async sendPasswordResetEmail(email: string): Promise<boolean> {
+        try {
+            if (!this.auth) {
+                return false;
+            }
+
+            await sendPasswordResetEmail(this.auth, email);
+            return true;
+        } catch (error) {
+            console.error('Error sending password reset email:', error);
+            return false;
+        }
+    }
+
+    async signOut(): Promise<void> {
+        try {
+            if (!this.auth) {
+                return;
+            }
+
+            await signOut(this.auth);
+            // Clear UserContext
+            userContext.clearUser();
+        } catch (error) {
+            console.error('Error signing out:', error);
+        }
+    }
+
+    getCurrentUser(): User | null {
+        if (!this.auth) {
+            return null;
+        }
+        return this.auth.currentUser;
+    }
+
+    async sendSignInLinkToEmail(email: string): Promise<boolean> {
+        try {
+            if (!this.auth) {
+                return false;
+            }
+
+            await sendSignInLinkToEmail(this.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;
+        } catch (error: any) {
+            console.error('Error sending sign-in link to email:', error);
+            return false;
+        }
+    }
+
+    isSignInWithEmailLink(): boolean {
+        if (!this.auth) {
+            return false;
+        }
+        return isSignInWithEmailLink(this.auth, window.location.href);
+    }
+
+    async signInWithEmailLink(email: string): Promise<AuthResult> {
+        try {
+            if (!this.auth) {
+                return AuthResult.failure("Firebase Auth not initialized");
+            }
+
+            if (!this.isSignInWithEmailLink()) {
+                return AuthResult.failure("Invalid sign-in link");
+            }
+
+            const userCredential = await signInWithEmailLink(this.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 = await this.getUserFromBackend(user.uid, user.displayName || '');
+            const idToken = await user.getIdToken();
+            if (backendUser) {
+                // Use the new helper method
+                return this._createSuccessAuthResult(user, backendUser, AuthProvider.EMAIL, idToken);
+            } else {
+                return AuthResult.failure('Failed to get or create user in backend');
+            }
+        } catch (error: any) {
+            console.error('Error signing in with email link:', error);
+            return AuthResult.failure(error.message || 'Email link authentication failed');
+        }
+    }
+
+    getEmailForSignIn(): string | null {
+        return window.localStorage.getItem('emailForSignIn');
+    }
+
+    // Helper method to create success AuthResult
+    private _createSuccessAuthResult(
+        user: User,
+        backendUser: KioscoinUser,
+        provider: AuthProvider,
+        idToken: string
+    ): AuthResult {
+        const userData = UserData.create(
+            user.uid,
+            user.email || '',
+            backendUser.username || '',
+            user.emailVerified,
+            idToken
+        );
+        return AuthResult.success(backendUser, userData, provider);
+    }
+
+    // Backend integration methods
+    private async getUserFromBackend(userId: string, loginId: string): Promise<KioscoinUser | null> {
+        try {
+            const response = await this.client.getUser(userId, {
+                Authorization: `Bearer ${loginId}`,
+            });
+            return response.users[0];
+        } catch (error) {
+            console.error('Error getting user from backend:', error);
+            return null;
+        }
+    }
+
+    private async createUserInBackend(userId: string, username: string, idToken: string): Promise<KioscoinUser | null> {
+        try {
+            const createUserRequest: CreateUserRequest = {
+                id: userId,
+                username: username
+            }
+            const response = await this.client.createUser(createUserRequest, {
+                Authorization: `Bearer ${idToken}`
+            });
+            return response.users[0];
+        } catch (error) {
+            console.error('Error creating user in backend:', error);
+            return null;
+        }
+    }
+}

package/src/P2PMarketplaceAPIClient.ts

@@ -1,5 +1,5 @@
 import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
-import { CreateOrderRequest, CreateUserRequest, Order, OrderLockedEvent, OrderResponse, ReleaseOrderEvent as OrderReleasedEvent, TakeOrderRequest, TestEventParams, UpdateOrderRequest, TransactionStatusResponse, RateUserRequest, OrderEventsResponse, PushNotificationsRegisterRequest, ConfigResponse, DashboardMetricsResponse, KioscoinUser, UsersResponse, PaymentMethod, GetOrdersParams, CreateDisputeRequest, DisputesResponse, OrderOffersResponse, TransactionRequest } from './types';
+import { CreateOrderRequest, CreateUserRequest, Order, OrderLockedEvent, OrderResponse, ReleaseOrderEvent as OrderReleasedEvent, TakeOrderRequest, TestEventParams, UpdateOrderRequest, TransactionStatusResponse, RateUserRequest, OrderEventsResponse, PushNotificationsRegisterRequest, ConfigResponse, DashboardMetricsResponse, KioscoinUser, UsersResponse, PaymentMethod, GetOrdersParams, CreateDisputeRequest, DisputesResponse, OrderOffersResponse, TransactionRequest, KioscoinOperationResponse, UpdateUserSettingsRequest } from './types';
 import { isPlainObject, camelCase, snakeCase, transform } from 'lodash';
 
 class P2PMarketplaceAPIClient {
@@ -137,6 +137,11 @@ class P2PMarketplaceAPIClient {
         return this.post<any>(url, rateUserRequest, headers);
     }
 
+    public async updateUserSettings(request: UpdateUserSettingsRequest, headers?: Record<string, string>): Promise<UsersResponse> {
+        const url = '/api/users/settings';
+        return this.post<UsersResponse>(url, request, headers);
+    }
+
     public async registerPushToken(registerRequest: PushNotificationsRegisterRequest, headers?: Record<string, string>): Promise<any> {
         const url = `/api/notifications/register-push`;
         return this.post<PushNotificationsRegisterRequest>(url, registerRequest, headers);
@@ -162,9 +167,9 @@ class P2PMarketplaceAPIClient {
         return this.get<OrderOffersResponse>(url, headers);
     }
 
-    public async pointOfSaleTransact(request: TransactionRequest, headers?: Record<string, string>): Promise<any> {
+    public async pointOfSaleTransact(request: TransactionRequest, headers?: Record<string, string>): Promise<KioscoinOperationResponse> {
         const url = '/api/point_of_sale/transact';
-        return this.post<TransactionRequest>(url, request, headers);
+        return this.post<KioscoinOperationResponse>(url, request, headers);
     }