@explorins/pers-sdk 1.2.3 → 1.2.5

package/dist/index.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+var persShared = require('@explorins/pers-shared');
 var jwtDecode = require('jwt-decode');
 var Web3 = require('web3');
 var ethers = require('ethers');
@@ -503,13 +504,15 @@ function createPersSDK(httpClient, config) {
 /**
  * Platform-Agnostic Business API Client
  *
- * Updated to match the new RESTful /businesses endpoints.
- * Uses @explorins/pers-shared DTOs for full type safety and consistency with backend.
+ * Updated to match the actual RESTful endpoints:
+ * - /businesses for business operations
+ * - /business-types for business type operations (separate controller)
  */
 class BusinessApi {
     constructor(apiClient) {
         this.apiClient = apiClient;
         this.basePath = '/businesses';
+        this.businessTypesPath = '/business-types'; // ✅ FIX: Separate controller
     }
     // ==========================================
     // 🌐 BUSINESS TYPES MANAGEMENT
@@ -517,38 +520,38 @@ class BusinessApi {
     /**
      * Get all business types (project key required)
      *
-     * Endpoint: GET /businesses/types
+     * Endpoint: GET /business-types
      * Auth: @ApiSecurity('projectKey')
      */
     async getAllBusinessTypes() {
-        return this.apiClient.get(`${this.basePath}/types`);
+        return this.apiClient.get(this.businessTypesPath); // ✅ FIX: Correct path
     }
     /**
      * ADMIN: Create business type
      *
-     * Endpoint: POST /businesses/types
+     * Endpoint: POST /business-types
      * Auth: @TenantAdmin()
      */
     async createBusinessType(dto) {
-        return this.apiClient.post(`${this.basePath}/types`, dto);
+        return this.apiClient.post(this.businessTypesPath, dto); // ✅ FIX: Correct path
     }
     /**
      * ADMIN: Update business type
      *
-     * Endpoint: PUT /businesses/types
+     * Endpoint: PUT /business-types
      * Auth: @TenantAdmin()
      */
     async updateBusinessType(dto) {
-        return this.apiClient.put(`${this.basePath}/types`, dto);
+        return this.apiClient.put(this.businessTypesPath, dto); // ✅ FIX: Correct path
     }
     /**
      * ADMIN: Delete business type
      *
-     * Endpoint: DELETE /businesses/types/{id}
+     * Endpoint: DELETE /business-types/{id}
      * Auth: @TenantAdmin()
      */
     async deleteBusinessType(id) {
-        return this.apiClient.delete(`${this.basePath}/types/${id}`);
+        return this.apiClient.delete(`${this.businessTypesPath}/${id}`); // ✅ FIX: Correct path
     }
     // ==========================================
     // 🏢 BUSINESS MANAGEMENT
@@ -563,20 +566,13 @@ class BusinessApi {
         return this.apiClient.get(`${this.basePath}/me`);
     }
     /**
-     * Get all active businesses (project key required)
-     *
-     * Endpoint: GET /businesses
-     * Auth: @ApiSecurity('projectKey')
-     * Note: Regular users automatically get active businesses only
-     */
-    async getActiveBusinesses() {
-        return this.apiClient.get(`${this.basePath}`);
-    }
-    /**
-     * Get all businesses with filtering (admin users can access inactive)
+     * Get all businesses with role-based filtering
      *
      * Endpoint: GET /businesses?active={boolean}&sanitize={mode}
      * Auth: @ApiSecurity('projectKey') (enhanced with role-based filtering)
+     * Note:
+     * - Project API Key users: Active businesses only (automatically filtered)
+     * - Admin JWT users: Full access with all query parameters
      */
     async getAllBusinesses(options) {
         const params = new URLSearchParams();
@@ -591,23 +587,16 @@ class BusinessApi {
         return this.apiClient.get(url);
     }
     /**
-     * ADMIN: Get all businesses (admin endpoint with full access)
+     * Get all active businesses (convenience method)
      *
-     * Endpoint: GET /businesses/admin
-     * Auth: @TenantAdmin()
+     * Endpoint: GET /businesses
+     * Auth: @ApiSecurity('projectKey')
      */
-    async getAllBusinessesAdmin(options) {
-        const params = new URLSearchParams();
-        if (options?.active !== undefined) {
-            params.append('active', String(options.active));
-        }
-        if (options?.sanitize) {
-            params.append('sanitize', options.sanitize);
-        }
-        const queryString = params.toString();
-        const url = queryString ? `${this.basePath}?${queryString}` : this.basePath;
-        return this.apiClient.get(url);
+    async getActiveBusinesses() {
+        return this.apiClient.get(this.basePath);
     }
+    // ✅ REMOVED: getAllBusinessesAdmin() - No separate /admin endpoint exists
+    // The unified endpoint handles role-based access automatically
     /**
      * Get business by ID
      *
@@ -637,18 +626,15 @@ class BusinessApi {
      * Returns: BusinessApiKeyDTO | BusinessTokenBalancesDTO
      */
     async createBusiness(dto) {
-        return this.apiClient.post(`${this.basePath}`, dto);
+        return this.apiClient.post(this.basePath, dto);
     }
     /**
      * ADMIN: Create business by display name (convenience method)
-     *
-     * This is a convenience wrapper that creates the proper DTO structure
      */
     async createBusinessByDisplayName(displayName) {
         const dto = {
             displayName,
             // Add other required fields based on BusinessCreateRequestDTO structure
-            // You may need to check the DTO definition for required fields
         };
         return this.createBusiness(dto);
     }
@@ -673,21 +659,12 @@ class BusinessApi {
     /**
      * ADMIN: Toggle business active status
      *
-     * Endpoint: PUT /businesses/{id}/activate
+     * Endpoint: PUT /businesses/{id}/status
      * Auth: @TenantAdmin()
      */
     async toggleBusinessActive(id, isActive) {
         const dto = { isActive };
-        return this.apiClient.put(`${this.basePath}/${id}/status`, dto);
-    }
-    /**
-     * ADMIN: Generate new business API key
-     *
-     * Endpoint: PUT /businesses/{id}/api-key
-     * Auth: @TenantAdmin()
-     */
-    async generateNewBusinessApiKey(id) {
-        return this.apiClient.put(`${this.basePath}/${id}/api-key`, {});
+        return this.apiClient.put(`${this.basePath}/${id}/status`, dto); // ✅ FIX: Correct endpoint
     }
 }
 
@@ -823,6 +800,15 @@ class TransactionApi {
     async getTransactionById(transactionId) {
         return this.apiClient.get(`${this.basePath}/${transactionId}`);
     }
+    /**
+     * Unique method to create a transaction
+     * @param request
+     * @returns
+     */
+    async createTransaction(request) {
+        return this.apiClient.post(`${this.basePath}`, request);
+        // return this.apiClient.post<TransactionDTO>(`${this.basePath}/system`, request);
+    }
     // ==========================================
     // AUTHENTICATED USER OPERATIONS
     // ==========================================
@@ -831,9 +817,9 @@ class TransactionApi {
      *
      * UPDATED: /transaction/auth/transaction → /transactions/user
      */
-    async createAuthTransaction(request) {
-        return this.apiClient.post(`${this.basePath}/user`, request);
-    }
+    /* async createAuthTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
+      return this.apiClient.post<TransactionRequestResponseDTO>(`${this.basePath}`, request);
+    } */
     /**
      * AUTH: Get user's sent transactions
      *
@@ -878,14 +864,6 @@ class TransactionApi {
                 return this.apiClient.get(`${this.basePath}/me/sent?${params.toString()}`);
         }
     }
-    /**
-     * AUTH: Prepare client signed transaction
-     *
-     * UPDATED: /transaction/auth/prepare-signing → /transactions/prepare
-     */
-    async prepareClientSignedTransaction(request) {
-        return this.apiClient.post(`${this.basePath}/prepare`, request);
-    }
     /**
      * AUTH: Prepare existing transaction for client-side signing
      *
@@ -899,8 +877,8 @@ class TransactionApi {
      *
      * NEW ENDPOINT: POST /transactions/{id}/submit
      */
-    async submitSignedTransaction(transactionId, signedData) {
-        return this.apiClient.post(`${this.basePath}/${transactionId}/submit`, signedData);
+    async submitSignedTransaction(signedTxData) {
+        return this.apiClient.post(`${this.basePath}/submit`, signedTxData);
     }
     /**
      * AUTH: Burn user tokens
@@ -908,14 +886,15 @@ class TransactionApi {
      * UPDATED: Uses new user transaction endpoint with burn-specific parameters
      * Note: This might need backend confirmation on burn functionality implementation
      */
-    async burnUserTokens(request) {
-        // Map burn request to TransactionRequestDTO format for new endpoint
-        const transactionRequest = {
-            ...request,
-            // Add any specific burn transaction parameters here
-        };
-        return this.apiClient.post(`${this.basePath}/user`, transactionRequest);
-    }
+    /* async burnUserTokens(request: UserBurnTokenRequestDTO): Promise<TransactionRequestResponseDTO> {
+      // Map burn request to TransactionRequestDTO format for new endpoint
+      const transactionRequest: TransactionRequestDTO = {
+        ...request,
+        // Add any specific burn transaction parameters here
+      } as any;
+  
+      return this.apiClient.post<TransactionRequestResponseDTO>(`${this.basePath}`, transactionRequest);
+    } */
     // ==========================================
     // BUSINESS OPERATIONS
     // ==========================================
@@ -924,9 +903,9 @@ class TransactionApi {
      *
      * UPDATED: /transaction/business/transaction → /transactions/business
      */
-    async createBusinessTransaction(request) {
-        return this.apiClient.post(`${this.basePath}/business`, request);
-    }
+    /* async createBusinessTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
+      return this.apiClient.post<TransactionRequestResponseDTO>(`${this.basePath}`, request);
+    } */
     // ==========================================
     // ADMIN OPERATIONS
     // ==========================================
@@ -935,8 +914,17 @@ class TransactionApi {
      *
      * UPDATED: /transaction/admin/transaction → /transactions/admin
      */
-    async createAdminTransaction(request) {
-        return this.apiClient.post(`${this.basePath}/system`, request);
+    /* async createAdminTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
+      // return this.apiClient.post<TransactionRequestResponseDTO>(`${this.basePath}`, request);
+      return this.apiClient.post<TransactionDTO>(`${this.basePath}/system`, request);
+    } */
+    /**
+     * AUTH: Prepare client signed transaction
+     *
+     * UPDATED: /transaction/auth/prepare-signing → /transactions/prepare
+     */
+    async prepareClientSignedTransaction(request) {
+        return this.apiClient.post(`${this.basePath}`, request);
     }
     /**
      * ADMIN: Get all tenant transactions
@@ -1015,16 +1003,31 @@ class TransactionApi {
      *
      * NEW ENDPOINT: POST /transactions/query-sender
      */
+    /**
+   * Query transactions by sender using unified endpoint
+   */
     async queryTransactionsBySender(accountSelector) {
-        return this.apiClient.post(`${this.basePath}/query-sender`, accountSelector);
+        // Build query parameters safely
+        const queryParams = {};
+        if (accountSelector.accountId) {
+            queryParams['participantId'] = accountSelector.accountId;
+        }
+        queryParams['role'] = persShared.TransactionRole.SENDER.toString();
+        const params = new URLSearchParams(queryParams);
+        return this.apiClient.get(`${this.basePath}?${params.toString()}`).then(response => response); // Extract items from paginated response
     }
     /**
-     * ADMIN: Query transactions by recipient
-     *
-     * NEW ENDPOINT: POST /transactions/query-recipient
+     * Query transactions by recipient using unified endpoint
      */
     async queryTransactionsByRecipient(accountSelector) {
-        return this.apiClient.post(`${this.basePath}/query-recipient`, accountSelector);
+        // Build query parameters safely
+        const queryParams = {};
+        if (accountSelector.accountId) {
+            queryParams['participantId'] = accountSelector.accountId;
+        }
+        queryParams['role'] = persShared.TransactionRole.RECIPIENT.toString();
+        const params = new URLSearchParams(queryParams);
+        return this.apiClient.get(`${this.basePath}?${params.toString()}`).then(response => response); // Extract items from paginated response
     }
     /**
      * ADMIN: Get transaction analytics
@@ -1075,8 +1078,14 @@ class TransactionService {
     /**
      * AUTH: Create authenticated transaction
      */
-    async createAuthTransaction(request) {
-        return this.transactionApi.createAuthTransaction(request);
+    /* async createAuthTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
+      return this.transactionApi.createAuthTransaction(request);
+    } */
+    async createTransaction(request) {
+        return this.transactionApi.createTransaction(request);
+    }
+    async submitSignedTransaction(signedTxData) {
+        return this.transactionApi.submitSignedTransaction(signedTxData);
     }
     /**
      * AUTH: Get user transaction history by type
@@ -1087,33 +1096,33 @@ class TransactionService {
     /**
      * AUTH: Prepare client signed transaction
      */
-    async prepareClientSignedTransaction(request) {
-        return this.transactionApi.prepareClientSignedTransaction(request);
-    }
+    /* async prepareClientSignedTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
+      return this.transactionApi.prepareClientSignedTransaction(request);
+    } */
     /**
      * AUTH: Burn user tokens
      */
-    async burnUserTokens(request) {
-        return this.transactionApi.burnUserTokens(request);
-    }
+    /* async burnUserTokens(request: UserBurnTokenRequestDTO): Promise<TransactionRequestResponseDTO> {
+      return this.transactionApi.burnUserTokens(request);
+    } */
     // ==========================================
     // BUSINESS OPERATIONS
     // ==========================================
     /**
      * BUSINESS: Create business transaction
      */
-    async createBusinessTransaction(request) {
-        return this.transactionApi.createBusinessTransaction(request);
-    }
+    /* async createBusinessTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
+      return this.transactionApi.createBusinessTransaction(request);
+    } */
     // ==========================================
     // ADMIN OPERATIONS
     // ==========================================
     /**
      * ADMIN: Create admin transaction
      */
-    async createAdminTransaction(request) {
-        return this.transactionApi.createAdminTransaction(request);
-    }
+    /* async createAdminTransaction(request: TransactionRequestDTO): Promise<TransactionRequestResponseDTO> {
+      return this.transactionApi.createAdminTransaction(request);
+    } */
     /**
      * ADMIN: Get all tenant transactions
      */
@@ -1167,15 +1176,16 @@ function createTransactionSDK(apiClient) {
         // Direct access to service methods (primary interface)
         // Public methods
         getTransactionById: (transactionId) => transactionService.getTransactionById(transactionId),
+        createTransaction: (request) => transactionService.createTransaction(request),
         // Auth methods
-        createAuthTransaction: (request) => transactionService.createAuthTransaction(request),
+        // createAuthTransaction: (request: TransactionRequestDTO) => transactionService.createAuthTransaction(request),
         getUserTransactionHistory: (type) => transactionService.getUserTransactionHistory(type),
-        prepareClientSignedTransaction: (request) => transactionService.prepareClientSignedTransaction(request),
-        burnUserTokens: (request) => transactionService.burnUserTokens(request),
+        //prepareClientSignedTransaction: (request: TransactionRequestDTO) => transactionService.prepareClientSignedTransaction(request),
+        // burnUserTokens: (request: UserBurnTokenRequestDTO) => transactionService.burnUserTokens(request),
         // Business methods
-        createBusinessTransaction: (request) => transactionService.createBusinessTransaction(request),
+        // createBusinessTransaction: (request: TransactionRequestDTO) => transactionService.createBusinessTransaction(request),
         // Admin methods
-        createAdminTransaction: (request) => transactionService.createAdminTransaction(request),
+        // createAdminTransaction: (request: TransactionRequestDTO) => transactionService.createAdminTransaction(request),
         getTenantTransactions: () => transactionService.getTenantTransactions(),
         getPaginatedTransactions: (params) => transactionService.getPaginatedTransactions(params),
         exportTransactionsCSV: () => transactionService.exportTransactionsCSV(),
@@ -1277,9 +1287,18 @@ class AuthAdminApi {
      * Note: JWT handling and auth bypass headers may need special implementation
      */
     async loginTenantAdmin(jwt) {
-        // TODO: Implement proper JWT and bypass header handling when PersApiClient supports it
-        const requestBody = { authToken: jwt };
-        return this.apiClient.post(`${this.basePath}/token`, requestBody);
+        const body = {
+            authToken: jwt,
+            authType: persShared.AccountOwnerType.TENANT
+        };
+        return this.apiClient.post(`${this.basePath}/token`, body);
+    }
+    async loginUser(jwt) {
+        const body = {
+            authToken: jwt,
+            authType: persShared.AccountOwnerType.USER
+        };
+        return this.apiClient.post(`${this.basePath}/token`, body);
     }
     /**
      * ADMIN: Refresh access token
@@ -1311,6 +1330,12 @@ class AuthAdminService {
     async loginTenantAdmin(jwt) {
         return this.authAdminApi.loginTenantAdmin(jwt);
     }
+    /**
+     * ADMIN: Login user with JWT
+     */
+    async loginUser(jwt) {
+        return this.authAdminApi.loginUser(jwt);
+    }
     /**
      * ADMIN: Refresh access token
      */
@@ -1339,6 +1364,7 @@ function createAuthAdminSDK(apiClient) {
         // Direct access to service methods (primary interface)
         // Admin authentication methods
         loginTenantAdmin: (jwt) => authAdminService.loginTenantAdmin(jwt),
+        loginUser: (jwt) => authAdminService.loginUser(jwt),
         refreshAccessToken: (refreshToken) => authAdminService.refreshAccessToken(refreshToken),
         // Advanced access for edge cases
         api: authAdminApi,
@@ -1588,81 +1614,102 @@ class CampaignApi {
      * NEW: POST /campaign-claims/user
      */
     async claimCampaign(request) {
-        return this.apiClient.post('/campaign-claims/user', request);
+        return this.apiClient.post('/campaign-claims', request);
     }
     /**
      * USER: Get claims for logged user
      * NEW: GET /campaign-claims/users/me
      */
     async getClaimsForLoggedUser() {
-        return this.apiClient.get('/campaign-claims/users/me');
+        return this.apiClient.get('/campaign-claims/me');
     }
     /**
-     * BUSINESS: Claim campaign reward for customer
-     * NEW: POST /campaign-claims/business
-     */
-    async businessClaimCampaign(request) {
-        return this.apiClient.post('/campaign-claims/business', request);
+   * ADMIN: Get all campaign claims
+   * Updated to use unified endpoint
+   */
+    async getCampaignClaims() {
+        // Admin context - no parameters needed for all claims
+        return this.apiClient.get('/campaign-claims');
     }
     /**
-     * SYSTEM: Process automated claim
-     * NEW: POST /campaign-claims/system
+     * ADMIN: Get campaign claims by campaign ID
+     * Updated to use query parameters
      */
-    async systemClaimCampaign(request) {
-        return this.apiClient.post('/campaign-claims/system', request);
+    async getCampaignClaimsByCampaignId(campaignId) {
+        return this.apiClient.get(`/campaign-claims?campaignId=${campaignId}`);
     }
     /**
-     * ADMIN: Manual claim processing
-     * NEW: POST /campaign-claims/admin
+     * ADMIN: Get campaign claims by user ID
+     * Updated to use query parameters
      */
-    async adminClaimCampaign(request) {
-        return this.apiClient.post('/campaign-claims/admin', request);
+    async getCampaignClaimsByUserId(userId) {
+        return this.apiClient.get(`/campaign-claims?userId=${userId}`);
     }
     /**
-     * ADMIN: Get all campaign claims
-     * NEW: GET /campaign-claims/admin
+     * ADMIN: Get campaign claims by business ID
+     * Updated to use query parameters
      */
-    async getCampaignClaims() {
-        return this.apiClient.get('/campaign-claims/admin');
+    async getCampaignClaimsByBusinessId(businessId) {
+        return this.apiClient.get(`/campaign-claims?businessId=${businessId}`);
     }
     /**
-     * ADMIN: Get campaign claims by campaign ID
-     * NEW: GET /campaign-claims/admin/{campaignId}
+     * ADMIN: Get campaign claims by user ID for specific campaign
+     * Combined filtering using query parameters
      */
-    async getCampaignClaimsByCampaignId(campaignId) {
-        return this.apiClient.get(`/campaign-claims/admin/${campaignId}`);
+    async getCampaignClaimsByUserAndCampaign(userId, campaignId) {
+        return this.apiClient.get(`/campaign-claims?userId=${userId}&campaignId=${campaignId}`);
     }
     /**
-     * ADMIN: Get campaign claims by user ID
-     * NEW: GET /campaign-claims/admin/users/{userId}
+     * ADMIN: Get campaign claims by business ID for specific campaign
+     * Combined filtering using query parameters
      */
-    async getCampaignClaimsByUserId(userId) {
-        return this.apiClient.get(`/campaign-claims/admin/users/${userId}`);
+    async getCampaignClaimsByBusinessAndCampaign(businessId, campaignId) {
+        return this.apiClient.get(`/campaign-claims?businessId=${businessId}&campaignId=${campaignId}`);
     }
     /**
-     * ADMIN: Get campaign claims by business ID
-     * NEW: GET /campaign-claims/admin/businesses/{businessId}
+     * USER: Get user's own claims (all campaigns)
+     * Use convenience endpoint
      */
-    async getCampaignClaimsByBusinessId(businessId) {
-        return this.apiClient.get(`/campaign-claims/admin/businesses/${businessId}`);
+    async getUserClaims() {
+        return this.apiClient.get('/campaign-claims/me');
     }
     /**
      * USER: Get user's claims for specific campaign
-     * NEW: GET /campaign-claims/campaigns/{campaignId}/users/me
+     * Use convenience endpoint with query parameter
      */
     async getUserClaimsForCampaign(campaignId) {
-        return this.apiClient.get(`/campaign-claims/campaigns/${campaignId}/users/me`);
+        return this.apiClient.get(`/campaign-claims/me?campaignId=${campaignId}`);
+    }
+    /**
+     * BUSINESS: Get business claims (all campaigns)
+     * Uses unified endpoint with business context
+     */
+    async getBusinessClaims() {
+        return this.apiClient.get('/campaign-claims');
     }
-    // ==========================================
-    // BACKWARD COMPATIBILITY (DEPRECATED)
-    // ==========================================
     /**
-     * @deprecated Use getCampaigns() instead
-     * LEGACY: Get campaigns with active filter
+     * BUSINESS: Get business claims for specific campaign
+     * Uses unified endpoint with business context and campaign filter
      */
-    async getCampaignsLegacy(active) {
-        console.warn('CampaignApi.getCampaignsLegacy() is deprecated. Use getCampaigns() instead.');
-        return this.getCampaigns(active !== undefined ? { active } : undefined);
+    async getBusinessClaimsForCampaign(campaignId) {
+        return this.apiClient.get(`/campaign-claims?campaignId=${campaignId}`);
+    }
+    /**
+   * Helper: Build query string from parameters
+   */
+    buildQueryString(params) {
+        const validParams = Object.entries(params)
+            .filter(([_, value]) => value !== undefined)
+            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+            .join('&');
+        return validParams ? `?${validParams}` : '';
+    }
+    /**
+     * Flexible admin claims query with multiple filters
+     */
+    async getAdminClaims(filters) {
+        const queryString = this.buildQueryString(filters || {});
+        return this.apiClient.get(`/campaign-claims${queryString}`);
     }
 }
 
@@ -2173,20 +2220,21 @@ function createPaymentSDK(apiClient) {
 /**
  * Platform-Agnostic Redemption API Client (UPDATED - RESTful Design)
  *
- * Updated to work with the new RESTful /redemptions endpoints.
+ * Updated to work with the new RESTful /redemptions and /redemption-redeems endpoints.
  * Handles redemption operations using the PERS backend with intelligent access detection.
  * Uses @explorins/pers-shared DTOs for consistency with backend.
  *
- * Migration Update: Updated all endpoints from /redemption to /redemptions
+ * Migration Update: Updated all endpoints for unified controller pattern
  * - Removed role revelation from URLs (no more /admin, /auth paths)
  * - Added intelligent access detection for unified endpoints
- * - Updated toggle endpoint to follow /status pattern
- * - Enhanced redemption process with path-based IDs
+ * - Added new /redemption-redeems endpoints for redeem processing
+ * - Enhanced redemption process with role-based access control
  */
 class RedemptionApi {
     constructor(apiClient) {
         this.apiClient = apiClient;
         this.basePath = '/redemptions';
+        this.redeemsPath = '/redemption-redeems';
     }
     // ==========================================
     // PUBLIC OPERATIONS (Project Key)
@@ -2221,7 +2269,7 @@ class RedemptionApi {
      * Updated: /redemption/type → /redemptions/types
      */
     async getRedemptionTypes() {
-        return this.apiClient.get(`${this.basePath}/types`);
+        return this.apiClient.get(`/redemption-types`);
     }
     /**
      * PUBLIC: Get redemption by ID
@@ -2234,33 +2282,106 @@ class RedemptionApi {
     /**
      * PUBLIC: Get available supply for redemption
      *
-     * Updated: /redemption/:id/available-supply → /redemptions/:id/available-supply
+     * Updated: /redemption/:id/available-supply → /redemptions/:id/supply
      */
     async getRedemptionAvailableSupply(id) {
-        return this.apiClient.get(`${this.basePath}/${id}/available-supply`);
+        return this.apiClient.get(`${this.basePath}/${id}/supply`);
     }
     // ==========================================
-    // USER OPERATIONS (JWT + Project Key)
+    // REDEMPTION EXECUTION (NEW UNIFIED ENDPOINT)
     // ==========================================
     /**
-     * USER: Redeem a redemption
+     * Execute redemption (unified endpoint)
      *
-     * Updated: /redemption/auth/redeem → /redemptions/:id/redeem
-     * Enhanced: Path-based redemption ID for better RESTful design
+     * NEW: POST /redemption-redeems - Role-based processing
+     * - USER: Direct user redemption processing
+     * - ADMIN: Can process redemptions for any account type
+     * - BUSINESS: Process redemptions for customers
      */
     async redeemRedemption(redemptionId) {
         const body = {
             redemptionId: redemptionId,
         };
-        return this.apiClient.post(`${this.basePath}/${redemptionId}/redeem`, body);
+        return this.apiClient.post(this.redeemsPath, body);
+    }
+    // ==========================================
+    // REDEMPTION REDEEMS QUERIES (NEW ENDPOINTS)
+    // ==========================================
+    /**
+     * Get redemption redeems with filtering (unified endpoint)
+     *
+     * NEW: GET /redemption-redeems with query parameters
+     * Role-based access: Users see only their own, admins can filter by userId/businessId
+     */
+    async getRedemptionRedeems(filters) {
+        let url = this.redeemsPath;
+        const params = new URLSearchParams();
+        if (filters?.redemptionId)
+            params.append('redemptionId', filters.redemptionId);
+        if (filters?.userId)
+            params.append('userId', filters.userId);
+        if (filters?.businessId)
+            params.append('businessId', filters.businessId);
+        const queryString = params.toString();
+        if (queryString) {
+            url += `?${queryString}`;
+        }
+        return this.apiClient.get(url);
+    }
+    /**
+     * Get specific redemption redeem by ID
+     *
+     * NEW: GET /redemption-redeems/:id
+     */
+    async getRedemptionRedeemById(id) {
+        return this.apiClient.get(`${this.redeemsPath}/${id}`);
+    }
+    /**
+     * USER: Get my redemption redeems (convenience endpoint)
+     *
+     * NEW: GET /redemption-redeems/me with optional filtering
+     */
+    async getMyRedemptionRedeems(redemptionId) {
+        let url = `${this.redeemsPath}/me`;
+        if (redemptionId) {
+            url += `?redemptionId=${redemptionId}`;
+        }
+        return this.apiClient.get(url);
     }
+    /**
+     * ADMIN: Get redemption redeems by user ID
+     *
+     * NEW: GET /redemption-redeems?userId=X
+     */
+    async getRedemptionRedeemsByUserId(userId, redemptionId) {
+        return this.getRedemptionRedeems({ userId, redemptionId });
+    }
+    /**
+     * ADMIN: Get redemption redeems by business ID
+     *
+     * NEW: GET /redemption-redeems?businessId=X
+     */
+    async getRedemptionRedeemsByBusinessId(businessId, redemptionId) {
+        return this.getRedemptionRedeems({ businessId, redemptionId });
+    }
+    /**
+     * ADMIN: Get redemption redeems by redemption ID
+     *
+     * NEW: GET /redemption-redeems?redemptionId=X
+     */
+    async getRedemptionRedeemsByRedemptionId(redemptionId) {
+        return this.getRedemptionRedeems({ redemptionId });
+    }
+    // ==========================================
+    // USER OPERATIONS (JWT + Project Key)
+    // ==========================================
     /**
      * USER: Get user redemption history
      *
-     * Updated: /redemption/auth/redeem → /redemptions/me/history
+     * Updated: Uses new convenience endpoint /redemption-redeems/me
      */
     async getUserRedemptionHistory() {
-        return this.apiClient.get(`${this.basePath}/me/history`);
+        return this.getMyRedemptionRedeems();
     }
     /**
      * USER: Get user redemptions (backward compatibility)
@@ -2329,7 +2450,7 @@ class RedemptionApi {
      * Updated: /redemption/admin/type → /redemptions/types
      */
     async createRedemptionType(redemptionType) {
-        return this.apiClient.post(`${this.basePath}/types`, redemptionType);
+        return this.apiClient.post(`${this.basePath}/redemption-types`, redemptionType);
     }
     // ==========================================
     // TOKEN UNIT MANAGEMENT (Admin)
@@ -4064,311 +4185,445 @@ function createWeb3ChainSDK(apiClient, providerService) {
     };
 }
 
-class Web3Api {
-    constructor(web3ChainService) {
-        this.web3ChainService = web3ChainService;
+/**
+ * TokenDomainService - Domain service for token operations
+ * Implements business logic for token balance, metadata, and collection operations
+ */
+class TokenDomainService {
+    constructor(web3Api, metadataService, contractService) {
+        this.web3Api = web3Api;
+        this.metadataService = metadataService;
+        this.contractService = contractService;
     }
     async getTokenBalance(request) {
-        const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
-        const tokenContract = web3Ts.getSmartContractInstance(request.contractAddress, request.abi, web3);
-        const balance = await web3Ts.getAddressTokenBalanceByContract(tokenContract, request.accountAddress, request.tokenId);
-        return Number(balance);
-    }
-    async getTokenUri(request) {
-        const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
-        // ✅ DIRECT: Use web3-ts functions directly
-        const tokenContract = web3Ts.getSmartContractInstance(request.contractAddress, request.abi, web3);
-        const tokenId = Number(request.tokenId);
-        const tokenUri = await web3Ts.getTokenUri(tokenContract, tokenId);
-        return String(tokenUri);
-    }
-    async getTokenOfOwnerByIndex(request) {
-        const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
-        // ✅ DIRECT: Use web3-ts functions directly
-        const tokenContract = web3Ts.getSmartContractInstance(request.contractAddress, request.abi, web3);
-        const tokenId = await web3Ts.getTokenOfOwnerByIndex(tokenContract, request.accountAddress, request.tokenIndex);
-        return String(tokenId);
-    }
-}
-
-class SimpleCache {
-    constructor() {
-        this.storage = {};
-        this.defaultTTL = 10 * 1000; // 10 seconds
-    }
-    set(key, data, ttl) {
-        this.storage[key] = {
-            data,
-            timestamp: Date.now(),
-            ttl: ttl ?? this.defaultTTL
-        };
-    }
-    get(key) {
-        const entry = this.storage[key];
-        if (!entry) {
-            return null;
-        }
-        const now = Date.now();
-        const isExpired = (now - entry.timestamp) > entry.ttl;
-        if (isExpired) {
-            delete this.storage[key];
-            return null;
-        }
-        return entry.data;
-    }
-    clear() {
-        this.storage = {};
-    }
-    cleanup() {
-        const now = Date.now();
-        Object.keys(this.storage).forEach(key => {
-            const entry = this.storage[key];
-            if ((now - entry.timestamp) > entry.ttl) {
-                delete this.storage[key];
-            }
-        });
-    }
-}
-
-class Web3Service {
-    constructor(web3Api, web3ChainService) {
-        this.web3Api = web3Api;
-        this.web3ChainService = web3ChainService;
-        //temporary fix, remove when the backend supports custom gateways
-        this.defaultIpfsGatewayDomain = 'pers.mypinata.cloud';
-        // ✅ CACHE: Simple 10-second cache instance
-        this.cache = new SimpleCache();
-        this.cleanupInterval = null;
-        this.cleanupInterval = setInterval(() => {
-            this.cache.cleanup();
-        }, 30 * 1000);
-    }
-    destroy() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = null;
-        }
-        this.cache.clear();
-    }
-    async getERC20Balance(request) {
-        const cacheKey = `erc20_balance_${request.accountAddress}_${request.token.contractAddress}_${request.token.chainId}`;
-        // ✅ CACHE CHECK: Try to get from cache first
-        const cached = this.cache.get(cacheKey);
-        if (cached) {
-            console.debug(`💾 [Web3Service] Using cached ERC20 balance for ${request.token.symbol}`);
-            return cached;
-        }
-        console.debug(`🔄 [Web3Service] Fetching fresh ERC20 balance for ${request.token.symbol}`);
-        const rawBalance = await this.web3Api.getTokenBalance({
+        const balance = await this.web3Api.getTokenBalance({
             accountAddress: request.accountAddress,
-            contractAddress: request.token.contractAddress,
-            abi: request.token.abi,
-            tokenId: null, // Always null for ERC20
-            chainId: request.token.chainId
+            contractAddress: request.contractAddress,
+            abi: request.abi,
+            tokenId: request.tokenId,
+            chainId: request.chainId
         });
-        const decimals = request.token.decimals ?? 18;
-        const symbol = request.token.symbol ?? 'UNKNOWN';
-        const response = {
-            rawBalance,
-            formattedBalance: this.formatBalance(rawBalance, decimals),
-            decimals,
-            symbol,
-            hasBalance: rawBalance > 0
+        return {
+            tokenId: request.tokenId,
+            balance,
+            hasBalance: balance > 0,
+            metadata: null
         };
-        // ✅ CACHE SET: Store result in cache
-        this.cache.set(cacheKey, response);
-        return response;
-    }
-    async getERC1155Collection(request) {
-        // ✅ CACHE KEY: Create unique cache key for collection request
-        const contractAddresses = request.tokens.map(t => t.contractAddress).sort().join(',');
-        const cacheKey = `erc1155_collection_${request.accountAddress}_${contractAddresses}`;
-        // ✅ CACHE CHECK: Try to get from cache first
-        const cached = this.cache.get(cacheKey);
-        if (cached) {
-            console.debug(`💾 [Web3Service] Using cached ERC1155 collection for ${request.accountAddress}`);
-            return cached;
-        }
-        console.debug(`🔄 [Web3Service] Fetching fresh ERC1155 collection for ${request.accountAddress}`);
-        const tokenResults = await Promise.all(request.tokens.map(async (token) => {
-            // ✅ FIXED: Handle null metadata properly
-            const tokenIds = token.metadata?.map(m => m.tokenMetadataIncrementalId?.toString()).filter((id) => id !== undefined) ?? [];
-            // Check balance for each known tokenId
-            const balanceResults = await Promise.allSettled(tokenIds.map(async (tokenId) => {
-                try {
-                    const rawBalance = await this.web3Api.getTokenBalance({
-                        accountAddress: request.accountAddress,
-                        contractAddress: token.contractAddress,
-                        abi: token.abi,
-                        tokenId,
-                        chainId: token.chainId
-                    });
-                    const decimals = token.decimals ?? 0; // ERC1155 usually no decimals
-                    return {
-                        tokenId,
-                        balance: rawBalance,
-                        formattedBalance: this.formatBalance(rawBalance, decimals),
-                        hasBalance: rawBalance > 0,
-                        // ✅ FIXED: Convert null to undefined for findMetadata
-                        metadata: this.findMetadata(token.metadata ?? undefined, tokenId)
-                    };
-                }
-                catch (error) {
-                    console.warn(`Failed to get balance for token ${token.contractAddress}:${tokenId}`, error);
-                    return null; // Skip failed tokens
-                }
-            }));
-            // Filter successful results with balance > 0
-            const successfulResults = [];
-            for (const result of balanceResults) {
-                if (result.status === 'fulfilled' && result.value !== null && result.value.hasBalance) {
-                    successfulResults.push(result.value);
+    }
+    async getTokenWithMetadata(params) {
+        try {
+            const balance = await this.web3Api.getTokenBalance({
+                accountAddress: params.accountAddress,
+                contractAddress: params.contractAddress,
+                abi: params.abi,
+                tokenId: params.tokenId,
+                chainId: params.chainId
+            });
+            let metadata = null;
+            if (balance > 0) {
+                const tokenUri = await this.web3Api.getTokenUri({
+                    contractAddress: params.contractAddress,
+                    abi: params.abi,
+                    tokenId: params.tokenId,
+                    chainId: params.chainId
+                });
+                if (tokenUri) {
+                    metadata = await this.metadataService.fetchAndProcessMetadata(tokenUri, params.chainId);
                 }
             }
             return {
-                token,
-                results: successfulResults
+                tokenId: params.tokenId,
+                balance,
+                hasBalance: balance > 0,
+                metadata
             };
-        }));
-        const response = {
-            accountAddress: request.accountAddress,
-            tokens: tokenResults.filter(t => t.results.length > 0)
-        };
-        // ✅ CACHE SET: Store complete collection result
-        this.cache.set(cacheKey, response);
-        return response;
-    }
-    async getERC721Collection(request) {
-        // ✅ CACHE KEY: Create unique cache key for NFT collection
-        const contractAddresses = request.nftContracts.map(t => t.contractAddress).sort().join(',');
-        const maxNFTs = request.maxNFTsPerContract || 50;
-        const cacheKey = `erc721_collection_${request.accountAddress}_${contractAddresses}_${maxNFTs}`;
-        // ✅ CACHE CHECK: Try to get from cache first
-        const cached = this.cache.get(cacheKey);
-        if (cached) {
-            console.debug(`💾 [Web3Service] Using cached ERC721 collection for ${request.accountAddress}`);
-            return cached;
         }
-        console.debug(`🔄 [Web3Service] Fetching fresh ERC721 collection for ${request.accountAddress}`);
-        const startTime = Date.now();
-        const contractResults = await Promise.all(request.nftContracts.map(async (token) => {
-            try {
-                const totalBalance = await this.web3Api.getTokenBalance({
-                    accountAddress: request.accountAddress,
-                    contractAddress: token.contractAddress,
-                    abi: token.abi,
-                    tokenId: null,
-                    chainId: token.chainId
+        catch (error) {
+            console.error('Error getting token with metadata:', error);
+            return {
+                tokenId: params.tokenId,
+                balance: 0,
+                hasBalance: false,
+                metadata: null
+            };
+        }
+    }
+    async getTokenCollection(params) {
+        try {
+            const contractAnalysis = this.contractService.analyzeContract(params.abi);
+            const tokens = [];
+            if (!contractAnalysis.hasEnumeration && !contractAnalysis.isERC1155) {
+                console.warn('Contract does not support enumeration, cannot retrieve full collection');
+                return {
+                    accountAddress: params.accountAddress,
+                    contractAddress: params.contractAddress,
+                    totalBalance: 0,
+                    tokensRetrieved: 0,
+                    tokens: [],
+                    note: 'Contract does not support enumeration'
+                };
+            }
+            else if (contractAnalysis.isERC1155) {
+                const tokenIdsToProcess = params.tokenIds || [];
+                if (tokenIdsToProcess.length > 0) {
+                    for (const tokenId of tokenIdsToProcess) {
+                        const tokenBalance = await this.getTokenWithMetadata({
+                            accountAddress: params.accountAddress,
+                            contractAddress: params.contractAddress,
+                            abi: params.abi,
+                            tokenId,
+                            chainId: params.chainId
+                        });
+                        tokens.push(tokenBalance);
+                    }
+                }
+                console.log('ERC-1155 User balances:', tokens);
+                // ERC-1155: Cannot enumerate without knowing token IDs
+                // Would need to use events or provide specific token IDs
+                console.warn('ERC-1155 collection retrieval requires specific token IDs or event analysis');
+                return {
+                    accountAddress: params.accountAddress,
+                    contractAddress: params.contractAddress,
+                    totalBalance: 0,
+                    tokensRetrieved: 0,
+                    tokens: tokens,
+                    note: 'ERC-1155 collection retrieval requires specific token IDs. Use getTokenWithMetadata() for individual tokens.'
+                };
+            }
+            // Handle different token standards
+            if (contractAnalysis.isERC721) {
+                // ERC-721: Get user's total balance and enumerate through tokens
+                const userBalance = await this.web3Api.getTokenBalance({
+                    accountAddress: params.accountAddress,
+                    contractAddress: params.contractAddress,
+                    abi: params.abi,
+                    tokenId: null, // null for ERC-721 total balance
+                    chainId: params.chainId
                 });
-                if (totalBalance === 0) {
+                console.log(`ERC-721 User balance for ${params.accountAddress}:`, userBalance);
+                if (userBalance === 0) {
                     return {
-                        token,
-                        totalNFTs: 0,
-                        nfts: [],
-                        hasMore: false
+                        accountAddress: params.accountAddress,
+                        contractAddress: params.contractAddress,
+                        totalBalance: 0,
+                        tokensRetrieved: 0,
+                        tokens: []
                     };
                 }
-                const nftsToLoad = Math.min(totalBalance, maxNFTs);
-                const nftResults = await Promise.allSettled(Array.from({ length: nftsToLoad }, async (_, index) => {
+                // Enumerate through user's tokens
+                const maxTokens = params.maxTokens || userBalance;
+                const tokensToRetrieve = Math.min(maxTokens, userBalance);
+                for (let i = 0; i < tokensToRetrieve; i++) {
                     try {
                         const tokenId = await this.web3Api.getTokenOfOwnerByIndex({
-                            contractAddress: token.contractAddress,
-                            abi: token.abi,
-                            accountAddress: request.accountAddress,
-                            tokenIndex: index,
-                            chainId: token.chainId
+                            contractAddress: params.contractAddress,
+                            abi: params.abi,
+                            accountAddress: params.accountAddress,
+                            tokenIndex: i,
+                            chainId: params.chainId
                         });
-                        const tokenUri = await this.web3Api.getTokenUri({
-                            contractAddress: token.contractAddress,
-                            abi: token.abi,
+                        const tokenWithMetadata = await this.getTokenWithMetadata({
+                            accountAddress: params.accountAddress,
+                            contractAddress: params.contractAddress,
+                            abi: params.abi,
                             tokenId,
-                            chainId: token.chainId
+                            chainId: params.chainId
                         });
-                        const metadata = await this.fetchMetadata(tokenUri, token.chainId);
-                        const nftItem = {
-                            tokenId,
-                            name: metadata?.name || `Token #${tokenId}`,
-                            description: metadata?.description || '',
-                            imageUrl: await this.resolveIPFSUrl(metadata?.image || '', token.chainId),
-                            rawBalance: 1,
-                            formattedBalance: '1',
-                            hasBalance: true,
-                            metadata,
-                            tokenIndex: index
-                        };
-                        return nftItem;
+                        if (tokenWithMetadata.hasBalance) {
+                            tokens.push(tokenWithMetadata);
+                        }
                     }
                     catch (error) {
-                        console.warn(`Failed to load NFT at index ${index} for ${token.symbol}:`, error);
-                        return null;
+                        console.warn(`Error retrieving ERC-721 token at index ${i}:`, error);
+                        continue;
                     }
-                }));
-                // ✅ FIXED: Usar tipo específico NFTItem
-                const successfulNFTs = nftResults
-                    .filter((result) => result.status === 'fulfilled' && result.value !== null)
-                    .map(result => result.value);
-                return {
-                    token,
-                    totalNFTs: totalBalance,
-                    nfts: successfulNFTs,
-                    hasMore: totalBalance > maxNFTs
-                };
+                }
             }
-            catch (error) {
-                console.error(`Failed to load NFT collection for ${token.symbol}:`, error);
+            else {
+                // Unknown standard
                 return {
-                    token,
-                    totalNFTs: 0,
-                    nfts: [],
-                    hasMore: false
+                    accountAddress: params.accountAddress,
+                    contractAddress: params.contractAddress,
+                    totalBalance: 0,
+                    tokensRetrieved: 0,
+                    tokens: [],
+                    note: 'Unsupported token standard for collection retrieval'
                 };
             }
-        }));
-        const totalNFTs = contractResults.reduce((sum, contract) => sum + contract.nfts.length, 0);
-        const loadingTime = Date.now() - startTime;
-        const response = {
-            accountAddress: request.accountAddress,
-            contracts: contractResults,
-            summary: {
-                totalContracts: request.nftContracts.length,
-                totalNFTs,
-                loadingTime
+            // Calculate total balance based on retrieved tokens
+            let totalBalance = 0;
+            if (contractAnalysis.isERC721) {
+                // For ERC-721, total balance is the number of unique tokens owned
+                totalBalance = tokens.length;
+            }
+            else {
+                // For other standards, sum up individual token balances
+                totalBalance = tokens.reduce((sum, token) => sum + token.balance, 0);
+            }
+            return {
+                accountAddress: params.accountAddress,
+                contractAddress: params.contractAddress,
+                totalBalance,
+                tokensRetrieved: tokens.length,
+                tokens
+            };
+        }
+        catch (error) {
+            console.error('Error getting token collection:', error);
+            return {
+                accountAddress: params.accountAddress,
+                contractAddress: params.contractAddress,
+                totalBalance: 0,
+                tokensRetrieved: 0,
+                tokens: [],
+                note: 'Error retrieving collection'
+            };
+        }
+    }
+    async getTokenMetadata(params) {
+        try {
+            const tokenUri = await this.web3Api.getTokenUri({
+                contractAddress: params.contractAddress,
+                abi: params.abi,
+                tokenId: params.tokenId,
+                chainId: params.chainId
+            });
+            let metadata = null;
+            if (tokenUri) {
+                metadata = await this.metadataService.fetchAndProcessMetadata(tokenUri, params.chainId);
             }
+            return {
+                tokenId: params.tokenId,
+                tokenUri,
+                metadata
+            };
+        }
+        catch (error) {
+            console.error('Error getting token metadata:', error);
+            return {
+                tokenId: params.tokenId,
+                tokenUri: null,
+                metadata: null
+            };
+        }
+    }
+}
+
+/**
+ * MetadataDomainService - Clean IPFS metadata resolution
+ */
+class MetadataDomainService {
+    constructor(ipfsApi) {
+        this.ipfsApi = ipfsApi;
+    }
+    async fetchAndProcessMetadata(tokenUri, chainId) {
+        return this.ipfsApi.fetchAndProcessMetadata(tokenUri, chainId);
+    }
+    async resolveIPFSUrl(url, chainId) {
+        return this.ipfsApi.resolveIPFSUrl(url, chainId);
+    }
+}
+
+/**
+ * ContractDomainService - Clean contract analysis without external dependencies
+ */
+class ContractDomainService {
+    constructor() { }
+    analyzeContract(abi) {
+        const methods = abi.filter(item => item.type === 'function').map(item => item.name);
+        // ERC-721 detection
+        const hasOwnerOf = methods.includes('ownerOf');
+        const hasTokenURI = methods.includes('tokenURI');
+        const hasTransferFrom = methods.includes('transferFrom');
+        const isERC721 = hasOwnerOf && hasTokenURI && hasTransferFrom;
+        // ERC-1155 detection
+        const hasBalanceOfBatch = methods.includes('balanceOfBatch');
+        const hasSafeBatchTransferFrom = methods.includes('safeBatchTransferFrom');
+        const hasURI = methods.includes('uri');
+        const isERC1155 = hasBalanceOfBatch && hasSafeBatchTransferFrom && hasURI;
+        return {
+            hasEnumeration: methods.includes('tokenByIndex') && methods.includes('totalSupply'),
+            hasOwnerOf,
+            hasBalanceOf: methods.includes('balanceOf'),
+            hasTokenURI,
+            hasTransfer: methods.includes('transfer') || methods.includes('transferFrom'),
+            hasApprove: methods.includes('approve'),
+            isERC721,
+            isERC1155
         };
-        // ✅ CACHE SET: Store complete collection response
-        this.cache.set(cacheKey, response);
-        return response;
     }
-    // ==========================================
-    // HELPER METHODS
-    // ==========================================
-    formatBalance(rawBalance, decimals) {
-        const balance = rawBalance / Math.pow(10, decimals);
-        return balance.toLocaleString('en-US', {
-            minimumFractionDigits: 0,
-            maximumFractionDigits: decimals > 0 ? 2 : 0
+    supportsEnumeration(abi) {
+        return this.analyzeContract(abi).hasEnumeration;
+    }
+    supportsMethod(abi, methodName) {
+        const methods = abi.filter(item => item.type === 'function').map(item => item.name);
+        return methods.includes(methodName);
+    }
+}
+
+/**
+ * Web3ApplicationService - Application layer entrance point
+ * Orchestrates domain services and provides clean public interface
+ * Simplified architecture with concrete classes
+ */
+class Web3ApplicationService {
+    constructor(web3Api, ipfsApi) {
+        // Type-safe metadata conversion methods for ERC-721/ERC-1155 standards
+        this.metadataMapper = {
+            fromERCStandard: (ercMetadata) => ({
+                name: ercMetadata.name || '',
+                description: ercMetadata.description || '',
+                imageUrl: ercMetadata.image || '',
+                externalUrl: ercMetadata.external_url,
+                animationUrl: ercMetadata.animation_url,
+                animationUrlConverted: undefined, // Will be set by IPFS conversion
+                attributes: ercMetadata.attributes || [],
+                ...ercMetadata
+            }),
+            toERCStandard: (metadata) => ({
+                name: metadata.name,
+                description: metadata.description,
+                image: metadata.imageUrl,
+                animation_url: metadata.animationUrl,
+                external_url: metadata.externalUrl,
+                attributes: metadata.attributes,
+                ...Object.fromEntries(Object.entries(metadata).filter(([key]) => !['name', 'description', 'imageUrl', 'animationUrl', 'externalUrl', 'attributes', 'animationUrlConverted'].includes(key)))
+            })
+        };
+        // Create domain services with injected infrastructure dependencies
+        this.contractDomainService = new ContractDomainService();
+        this.metadataDomainService = new MetadataDomainService(ipfsApi);
+        this.tokenDomainService = new TokenDomainService(web3Api, this.metadataDomainService, this.contractDomainService);
+    }
+    /**
+     * Get balance and metadata for a specific token
+     */
+    async getSpecificTokenBalance(request) {
+        if (!request.tokenId) {
+            return this.tokenDomainService.getTokenBalance({
+                accountAddress: request.accountAddress || '',
+                contractAddress: request.contractAddress,
+                abi: request.abi,
+                tokenId: '',
+                chainId: request.chainId
+            });
+        }
+        return this.tokenDomainService.getTokenWithMetadata({
+            accountAddress: request.accountAddress || '',
+            contractAddress: request.contractAddress,
+            abi: request.abi,
+            tokenId: request.tokenId || '',
+            chainId: request.chainId
+        });
+    }
+    /**
+     * Get metadata for a specific token from on-chain
+     */
+    async getTokenMetadata(request) {
+        const domainResult = await this.tokenDomainService.getTokenMetadata({
+            contractAddress: request.contractAddress,
+            abi: request.abi,
+            tokenId: request.tokenId || '',
+            chainId: request.chainId
+        });
+        return domainResult.metadata;
+    }
+    /**
+     * Retrieve entire collection of tokens with balance and metadata
+     */
+    async getTokenCollection(request) {
+        return this.tokenDomainService.getTokenCollection({
+            accountAddress: request.accountAddress || '',
+            contractAddress: request.contractAddress,
+            abi: request.abi,
+            chainId: request.chainId,
+            maxTokens: request.maxTokens,
+            tokenIds: request.tokenIds
         });
     }
-    // ✅ FIXED: Update method signature to handle null properly
-    findMetadata(metadata, tokenId) {
-        if (!metadata || tokenId === null)
+    /**
+     * Resolve IPFS URLs to HTTPS if needed
+     */
+    async resolveIPFSUrl(url, chainId) {
+        return this.metadataDomainService.resolveIPFSUrl(url, chainId);
+    }
+    /**
+     * Fetch and process metadata from URI with IPFS conversion
+     */
+    async fetchAndProcessMetadata(tokenUri, chainId) {
+        const domainMetadata = await this.metadataDomainService.fetchAndProcessMetadata(tokenUri, chainId);
+        if (!domainMetadata)
             return null;
-        return metadata.find(m => m.tokenMetadataIncrementalId?.toString() === tokenId) || null;
+        // Convert from ERC token standard to our clean interface
+        const cleanMetadata = this.metadataMapper.fromERCStandard(domainMetadata);
+        // Add IPFS conversion if needed
+        if (cleanMetadata.animationUrl?.startsWith('ipfs://')) {
+            return {
+                ...cleanMetadata,
+                animationUrlConverted: await this.resolveIPFSUrl(cleanMetadata.animationUrl, chainId)
+            };
+        }
+        return cleanMetadata;
+    }
+}
+
+/**
+ * Web3InfrastructureApi - Infrastructure implementation for blockchain operations
+ * Uses @explorins/web3-ts for Web3 interactions
+ */
+class Web3InfrastructureApi {
+    constructor(web3ChainService) {
+        this.web3ChainService = web3ChainService;
     }
-    async fetchMetadata(uri, chainId) {
+    async getTokenBalance(request) {
         try {
-            const httpUrl = await this.resolveIPFSUrl(uri, chainId);
-            const response = await fetch(httpUrl);
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            return await response.json();
+            if (request.tokenId !== null)
+                request.tokenId = request.tokenId.toString();
+            const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
+            const contract = web3Ts.getSmartContractInstance(request.contractAddress, request.abi, web3);
+            return await web3Ts.getAccountTokenBalance(contract, request.accountAddress, request.tokenId);
         }
         catch (error) {
-            console.warn('Failed to fetch NFT metadata:', error);
-            return null;
+            console.error(`Failed to get token balance for ${request.accountAddress} for ${request.contractAddress} and tokenId ${request.tokenId}, return 0 instead:`, error);
+            return 0;
         }
     }
+    async getTokenUri(request) {
+        try {
+            const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
+            const contract = web3Ts.getSmartContractInstance(request.contractAddress, request.abi, web3);
+            const tokenId = Number(request.tokenId);
+            const tokenUri = await web3Ts.getTokenUri(contract, tokenId);
+            return String(tokenUri);
+        }
+        catch (error) {
+            console.error(`Failed to get token URI for tokenId ${request.tokenId}:`, error);
+            throw error;
+        }
+    }
+    async getTokenOfOwnerByIndex(request) {
+        try {
+            const web3 = await this.web3ChainService.getWeb3ByChainId(request.chainId);
+            const tokenContract = web3Ts.getSmartContractInstance(request.contractAddress, request.abi, web3);
+            const tokenId = await web3Ts.getTokenOfOwnerByIndex(tokenContract, request.accountAddress, request.tokenIndex);
+            return String(tokenId);
+        }
+        catch (error) {
+            console.error(`Failed to get token by index ${request.tokenIndex} for ${request.accountAddress}:`, error);
+            throw error;
+        }
+    }
+}
+
+/**
+ * IPFSInfrastructureApi - Infrastructure implementation for IPFS operations
+ * Uses Web3ChainService for IPFS gateway resolution
+ */
+class IPFSInfrastructureApi {
+    constructor(web3ChainService) {
+        this.web3ChainService = web3ChainService;
+        this.defaultIpfsGatewayDomain = 'pers.mypinata.cloud';
+    }
     async getIpfsGatewayDomain(chainId) {
         try {
             const chainData = await this.web3ChainService.getChainDataWithCache(chainId);
@@ -4380,29 +4635,66 @@ class Web3Service {
         }
     }
     async resolveIPFSUrl(url, chainId) {
-        if (!url)
-            return '';
         if (url.startsWith('ipfs://')) {
-            const gatewayDomain = await this.getIpfsGatewayDomain(chainId);
-            return `https://${gatewayDomain}/ipfs/${url.slice(7)}`;
+            const gateway = await this.getIpfsGatewayDomain(chainId);
+            return url.replace('ipfs://', `https://${gateway}/ipfs/`);
         }
         return url;
     }
+    async fetchAndProcessMetadata(tokenUri, chainId) {
+        try {
+            const resolvedUri = await this.resolveIPFSUrl(tokenUri, chainId);
+            const response = await fetch(resolvedUri);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const metadata = await response.json();
+            // Process and return clean metadata
+            return {
+                name: metadata.name || '',
+                description: metadata.description || '',
+                image: metadata.image ? await this.resolveIPFSUrl(metadata.image, chainId) : '',
+                attributes: metadata.attributes || [],
+                animation_url: metadata.animation_url ? await this.resolveIPFSUrl(metadata.animation_url, chainId) : undefined,
+                external_url: metadata.external_url || undefined
+            };
+        }
+        catch (error) {
+            console.error('Error fetching metadata:', error);
+            return null;
+        }
+    }
+    async fetchFromUrl(url) {
+        try {
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch from ${url}: ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            console.error(`Error fetching from URL ${url}:`, error);
+            throw error;
+        }
+    }
 }
 
-//import { PublicHttpProviderService } from '../web3-chain/services/public-http-provider.service';
 function createWeb3SDK(apiClient) {
     // TODO: FIX LATER - TEMPORARY CONSTRUCTION
     const web3ProviderService = new Web3ProviderService();
     const web3ChainSDK = createWeb3ChainSDK(apiClient, web3ProviderService);
-    const web3Api = new Web3Api(web3ChainSDK.service);
-    const web3Service = new Web3Service(web3Api, web3ChainSDK.service);
+    // Create Web3ApplicationService - main entry point for all Web3 operations
+    const web3InfrastructureApi = new Web3InfrastructureApi(web3ChainSDK.service);
+    const ipfsInfrastructureApi = new IPFSInfrastructureApi(web3ChainSDK.service);
+    const web3ApplicationService = new Web3ApplicationService(web3InfrastructureApi, ipfsInfrastructureApi);
+    // Clean SDK - all functions route through Web3ApplicationService
     return {
-        getCreditsBalance: (request) => web3Service.getERC20Balance(request),
-        getRewardsCollection: (request) => web3Service.getERC1155Collection(request),
-        getStampsCollection: (request) => web3Service.getERC721Collection(request),
-        api: web3Api,
-        service: web3Service
+        getTokenBalance: (request) => web3ApplicationService.getSpecificTokenBalance(request),
+        getTokenMetadata: (request) => web3ApplicationService.getTokenMetadata(request),
+        getTokenCollection: (request) => web3ApplicationService.getTokenCollection(request),
+        resolveIPFSUrl: (url, chainId) => web3ApplicationService.resolveIPFSUrl(url, chainId),
+        fetchAndProcessMetadata: (tokenUri, chainId) => web3ApplicationService.fetchAndProcessMetadata(tokenUri, chainId),
+        applicationService: web3ApplicationService
     };
 }
 
@@ -4419,6 +4711,7 @@ exports.ChainTypes = ChainTypes;
 exports.DEFAULT_PERS_CONFIG = DEFAULT_PERS_CONFIG;
 exports.DonationApi = DonationApi;
 exports.DonationService = DonationService;
+exports.IPFSInfrastructureApi = IPFSInfrastructureApi;
 exports.PaymentApi = PurchaseApi;
 exports.PaymentService = PaymentService;
 exports.PersApiClient = PersApiClient;
@@ -4426,7 +4719,6 @@ exports.PersApiError = PersApiError;
 exports.PersSDK = PersSDK;
 exports.RedemptionApi = RedemptionApi;
 exports.RedemptionService = RedemptionService;
-exports.SimpleCache = SimpleCache;
 exports.TenantApi = TenantApi;
 exports.TenantService = TenantService;
 exports.TokenApi = TokenApi;
@@ -4438,8 +4730,10 @@ exports.UserApi = UserApi;
 exports.UserService = UserService;
 exports.UserStatusApi = UserStatusApi;
 exports.UserStatusService = UserStatusService;
+exports.Web3ApplicationService = Web3ApplicationService;
 exports.Web3ChainApi = Web3ChainApi;
 exports.Web3ChainService = Web3ChainService;
+exports.Web3InfrastructureApi = Web3InfrastructureApi;
 exports.Web3ProviderService = Web3ProviderService;
 exports.buildApiRoot = buildApiRoot;
 exports.createAnalyticsSDK = createAnalyticsSDK;