b5-api-client 0.0.25 → 0.0.27

package/dist/auth/LoginService.d.ts

@@ -17,5 +17,7 @@ export interface FirebaseLoginServiceConfig {
         url: string;
         handleCodeInApp: boolean;
     };
+    emailVerificationUrl?: string;
+    emailVerificationContinueUrl?: string;
 }
 export declare function createLoginService(config: LoginServiceConfig): LoginService;

package/dist/types.d.ts

@@ -53,13 +53,17 @@ export interface UsersResponse {
     users: KioscoinUser[];
 }
 export interface UserSettings {
-    preferredTokenCode?: string;
+    preferredTokenCode?: string | null;
     paymentMethods: PaymentMethod[];
+    hasVerified?: boolean;
 }
 export interface UpdateUserSettingsRequest {
     userId: string;
     settings: UserSettings;
 }
+export interface VerifyEmailRequest {
+    loginId: string;
+}
 export interface PaymentMethod {
     type: string;
     alias?: string;
@@ -339,3 +343,39 @@ export interface KioscoinOperationResponse {
     error?: OperationError;
     order?: Order;
 }
+export type MessageContentType = 'TEXT' | 'ACTION' | 'EVENT' | 'NOTIFICATION';
+export interface MessageContentBase {
+    type: MessageContentType;
+}
+export interface MessageContentText extends MessageContentBase {
+    type: 'TEXT';
+    text: string;
+}
+export interface MessageContentAction extends MessageContentBase {
+    type: 'ACTION';
+    content: string;
+}
+export interface MessageContentEvent extends MessageContentBase {
+    type: 'EVENT';
+    event: OrderEvent;
+}
+export interface MessageContentNotification extends MessageContentBase {
+    type: 'NOTIFICATION';
+    notification: NotificationDto;
+}
+export type MessageContent = MessageContentText | MessageContentAction | MessageContentEvent | MessageContentNotification;
+export interface Message {
+    sender: string;
+    timestamp: number;
+    content: MessageContent;
+}
+export interface NotificationDto {
+    id: string;
+    userId: string;
+    message: Message;
+    createdAt: string;
+    readAt?: string | null;
+}
+export interface NotificationsResponse {
+    notifications: NotificationDto[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "b5-api-client",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "Escrow Backend API client",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/P2PMarketplaceAPIClient.ts

@@ -1,10 +1,22 @@
-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, KioscoinOperationResponse, UpdateUserSettingsRequest } from './types';
+import axios, { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { CreateOrderRequest, CreateUserRequest, Order, OrderResponse, TakeOrderRequest, TestEventParams, UpdateOrderRequest, TransactionStatusResponse, RateUserRequest, OrderEventsResponse, PushNotificationsRegisterRequest, ConfigResponse, DashboardMetricsResponse, KioscoinUser, UsersResponse, PaymentMethod, GetOrdersParams, CreateDisputeRequest, DisputesResponse, OrderOffersResponse, TransactionRequest, KioscoinOperationResponse, UpdateUserSettingsRequest, NotificationsResponse, VerifyEmailRequest } from './types';
 import { isPlainObject, camelCase, snakeCase, transform } from 'lodash';
 
+interface RequestConfigWithRetry extends AxiosRequestConfig {
+    _retry?: boolean;
+}
+
+export interface AuthTokenProvider {
+    getToken(): Promise<string | null>;
+    refreshToken(): Promise<string | null>;
+    onRefreshFailure?(error: unknown): void;
+}
+
 class P2PMarketplaceAPIClient {
     private readonly client: AxiosInstance;
     private readonly defaultHeaders: Record<string, string>;
+    private authTokenProvider?: AuthTokenProvider;
+    private refreshTokenPromise?: Promise<string | null>;
 
     constructor(baseURL: string, timeout: number = 30000) {
         this.client = axios.create({
@@ -18,11 +30,28 @@ class P2PMarketplaceAPIClient {
         };
 
         // Add a request interceptor to transform request data to snake_case
-        this.client.interceptors.request.use((config) => {
+        this.client.interceptors.request.use(async (config) => {
             if (config.data) {
                 config.data = toSnakeCase(config.data);
             }
-            return config;
+            const provider = this.authTokenProvider;
+            if (!provider) {
+                return config;
+            }
+
+            return provider
+                .getToken()
+                .then((token) => {
+                    if (token) {
+                        config.headers = config.headers ?? {};
+                        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);
         });
@@ -33,11 +62,42 @@ class P2PMarketplaceAPIClient {
                 response.data = toCamelCase(response.data);
             }
             return response;
-        }, (error) => {
-            return Promise.reject(error);
+        }, async (error: AxiosError) => {
+            const { response, config } = error;
+            if (!this.authTokenProvider || response?.status !== 401 || !config) {
+                return Promise.reject(error);
+            }
+
+            const originalRequest = config as RequestConfigWithRetry;
+            if (originalRequest._retry) {
+                return Promise.reject(error);
+            }
+
+            originalRequest._retry = true;
+
+            try {
+                const newToken = await this.getRefreshedToken();
+                if (!newToken) {
+                    return Promise.reject(error);
+                }
+
+                originalRequest.headers = originalRequest.headers ?? {};
+                originalRequest.headers['Authorization'] = `Bearer ${newToken}`;
+                return this.client(originalRequest);
+            } catch (refreshError) {
+                if (this.authTokenProvider?.onRefreshFailure) {
+                    this.authTokenProvider.onRefreshFailure(refreshError);
+                }
+                return Promise.reject(error);
+            }
         });
     }
 
+    setAuthTokenProvider(provider?: AuthTokenProvider) {
+        this.authTokenProvider = provider;
+        this.refreshTokenPromise = undefined;
+    }
+
     private mergeHeaders(customHeaders?: Record<string, string>): Record<string, string> {
         return { ...this.defaultHeaders, ...customHeaders };
     }
@@ -48,6 +108,28 @@ class P2PMarketplaceAPIClient {
         };
     }
 
+    private async getRefreshedToken(): Promise<string | null> {
+        if (!this.authTokenProvider) {
+            return null;
+        }
+
+        if (!this.refreshTokenPromise) {
+            this.refreshTokenPromise = this.authTokenProvider
+                .refreshToken()
+                .catch((error) => {
+                    if (this.authTokenProvider?.onRefreshFailure) {
+                        this.authTokenProvider.onRefreshFailure(error);
+                    }
+                    throw error;
+                })
+                .finally(() => {
+                    this.refreshTokenPromise = undefined;
+                });
+        }
+
+        return this.refreshTokenPromise;
+    }
+
     async get<T>(url: string, headers?: Record<string, string>): Promise<T> {
         const config = this.createConfig(headers);
         try {
@@ -142,11 +224,26 @@ class P2PMarketplaceAPIClient {
         return this.post<UsersResponse>(url, request, headers);
     }
 
+    public async verifyUserEmail(request: VerifyEmailRequest, headers?: Record<string, string>): Promise<UsersResponse> {
+        const url = '/api/users/verify_email';
+        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);
     }
 
+    public async listNotifications(limit: number = 10, offset: number = 0, headers?: Record<string, string>): Promise<NotificationsResponse> {
+        const url = `/api/notifications?limit=${limit}&offset=${offset}`;
+        return this.get<NotificationsResponse>(url, headers);
+    }
+
+    public async markNotificationAsRead(notificationId: string, headers?: Record<string, string>): Promise<NotificationsResponse> {
+        const url = `/api/notifications/${notificationId}/read`;
+        return this.post<any>(url, {}, headers);
+    }
+
     public async getConfig<T>(): Promise<ConfigResponse<T>> {
         const url = '/api/configuration';
         return await this.get<ConfigResponse<T>>(url);
@@ -173,58 +270,6 @@ class P2PMarketplaceAPIClient {
     }
 
 
-
-    public async testLockFunds(order: Order, testParams?: TestEventParams, headers?: Record<string, string>) {
-        const orderEvent: OrderLockedEvent = {
-            type: "LOCKED",
-            orderId: order.id ?? "",
-            buyerAddress: order.buyerAddress ?? "",
-            amount: order.amount?.toString() ?? "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 {
-            await this.post<undefined>(url, orderEvent, headers);
-        } catch (error) {
-            console.error("Error locking funds:", error);
-            throw new Error("Failed to lock funds");
-        }
-    }
-
-    public async testReleaseFunds(order: Order, testParams?: TestEventParams, headers?: Record<string, string>) {
-        const releaseOrderEvent: OrderReleasedEvent = {
-            type: "RELEASED",
-            orderId: order.id ?? "",
-            buyerAddress: order.buyerAddress ?? "",
-            amount: order.amount?.toString() ?? "0",
-            transaction: {
-                hash: "0xeab4797bf0e13dff0bda481503a544698127c5f97dd826c465ebdb41bcfec3f5",
-            },
-            tokenContractAddress: "0xee5e8291b551603a19ef41eea69ae49592ed14f8",
-            adminAction: true,
-            timestamp: new Date().toISOString(),
-        };
-
-        const url = "api/events/simulate/release"
-        try {
-            await this.post<undefined>(url, releaseOrderEvent, headers);
-        } catch (error) {
-            console.error("Error releasing funds:", error);
-            throw new Error("Failed to release funds");
-        }
-    }
-
     public async releaseFunds(order: Order, testParams?: TestEventParams, headers?: Record<string, string>): Promise<string> {
         const body = {
             orderId: order.id ?? "",