@explorins/pers-sdk 1.2.3 → 1.2.4

package/dist/index.js

@@ -1,7 +1,8 @@
+import { TransactionRole, AccountOwnerType } from '@explorins/pers-shared';
 import { jwtDecode } from 'jwt-decode';
 import Web3 from 'web3';
 import { FetchRequest, JsonRpcProvider } from 'ethers';
-import { getSmartContractInstance, getAddressTokenBalanceByContract, getTokenUri, getTokenOfOwnerByIndex } from '@explorins/web3-ts';
+import { getSmartContractInstance, getAccountTokenBalance, getTokenUri, getTokenOfOwnerByIndex } from '@explorins/web3-ts';
 
 /**
  * PERS SDK Configuration interfaces
@@ -501,13 +502,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
@@ -515,38 +518,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
@@ -561,20 +564,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();
@@ -589,23 +585,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
      *
@@ -635,18 +624,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);
     }
@@ -671,21 +657,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
     }
 }
 
@@ -821,6 +798,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
     // ==========================================
@@ -829,9 +815,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
      *
@@ -876,14 +862,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
      *
@@ -897,8 +875,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
@@ -906,14 +884,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
     // ==========================================
@@ -922,9 +901,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
     // ==========================================
@@ -933,8 +912,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
@@ -1013,16 +1001,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'] = 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'] = 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
@@ -1073,8 +1076,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
@@ -1085,33 +1094,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
      */
@@ -1165,15 +1174,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(),
@@ -1275,9 +1285,11 @@ 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: AccountOwnerType.TENANT
+        };
+        return this.apiClient.post(`${this.basePath}/token`, body);
     }
     /**
      * ADMIN: Refresh access token
@@ -1586,81 +1598,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');
+    }
+    /**
+     * BUSINESS: Get business claims for specific campaign
+     * Uses unified endpoint with business context and campaign filter
+     */
+    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}` : '';
     }
-    // ==========================================
-    // BACKWARD COMPATIBILITY (DEPRECATED)
-    // ==========================================
     /**
-     * @deprecated Use getCampaigns() instead
-     * LEGACY: Get campaigns with active filter
+     * Flexible admin claims query with multiple filters
      */
-    async getCampaignsLegacy(active) {
-        console.warn('CampaignApi.getCampaignsLegacy() is deprecated. Use getCampaigns() instead.');
-        return this.getCampaigns(active !== undefined ? { active } : undefined);
+    async getAdminClaims(filters) {
+        const queryString = this.buildQueryString(filters || {});
+        return this.apiClient.get(`/campaign-claims${queryString}`);
     }
 }
 
@@ -2171,20 +2204,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)
@@ -2219,7 +2253,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
@@ -2232,33 +2266,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)
@@ -2327,7 +2434,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)
@@ -4062,311 +4169,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 = getSmartContractInstance(request.contractAddress, request.abi, web3);
-        const balance = await 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 = getSmartContractInstance(request.contractAddress, request.abi, web3);
-        const tokenId = Number(request.tokenId);
-        const tokenUri = await 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 = getSmartContractInstance(request.contractAddress, request.abi, web3);
-        const tokenId = await 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;
     }
-    async fetchMetadata(uri, chainId) {
+}
+
+/**
+ * Web3InfrastructureApi - Infrastructure implementation for blockchain operations
+ * Uses @explorins/web3-ts for Web3 interactions
+ */
+class Web3InfrastructureApi {
+    constructor(web3ChainService) {
+        this.web3ChainService = web3ChainService;
+    }
+    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 = getSmartContractInstance(request.contractAddress, request.abi, web3);
+            return await 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 = getSmartContractInstance(request.contractAddress, request.abi, web3);
+            const tokenId = Number(request.tokenId);
+            const tokenUri = await 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 = getSmartContractInstance(request.contractAddress, request.abi, web3);
+            const tokenId = await 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);
@@ -4378,31 +4619,68 @@ 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
     };
 }
 
-export { AnalyticsApi, AnalyticsService, AuthAdminApi, AuthAdminService, BaseTokenService, BusinessApi, BusinessService, CampaignApi, CampaignService, ChainTypes, DEFAULT_PERS_CONFIG, DonationApi, DonationService, PurchaseApi as PaymentApi, PaymentService, PersApiClient, PersApiError, PersSDK, RedemptionApi, RedemptionService, SimpleCache, TenantApi, TenantService, TokenApi, TokenSDK, TokenService, TransactionAccountType, TransactionApi, TransactionService, UserApi, UserService, UserStatusApi, UserStatusService, Web3ChainApi, Web3ChainService, Web3ProviderService, buildApiRoot, createAnalyticsSDK, createAuthAdminSDK, createAuthProvider, createBusinessSDK, createCampaignSDK, createDonationSDK, createPaymentSDK, createPersSDK, createRedemptionSDK, createTenantSDK, createTransactionSDK, createUserSDK, createUserStatusSDK, createWeb3ChainSDK, createWeb3SDK, mergeWithDefaults };
+export { AnalyticsApi, AnalyticsService, AuthAdminApi, AuthAdminService, BaseTokenService, BusinessApi, BusinessService, CampaignApi, CampaignService, ChainTypes, DEFAULT_PERS_CONFIG, DonationApi, DonationService, IPFSInfrastructureApi, PurchaseApi as PaymentApi, PaymentService, PersApiClient, PersApiError, PersSDK, RedemptionApi, RedemptionService, TenantApi, TenantService, TokenApi, TokenSDK, TokenService, TransactionAccountType, TransactionApi, TransactionService, UserApi, UserService, UserStatusApi, UserStatusService, Web3ApplicationService, Web3ChainApi, Web3ChainService, Web3InfrastructureApi, Web3ProviderService, buildApiRoot, createAnalyticsSDK, createAuthAdminSDK, createAuthProvider, createBusinessSDK, createCampaignSDK, createDonationSDK, createPaymentSDK, createPersSDK, createRedemptionSDK, createTenantSDK, createTransactionSDK, createUserSDK, createUserStatusSDK, createWeb3ChainSDK, createWeb3SDK, mergeWithDefaults };
 //# sourceMappingURL=index.js.map