@explorins/pers-sdk 1.2.1 → 1.2.3

package/dist/index.js

@@ -1,7 +1,7 @@
 import { jwtDecode } from 'jwt-decode';
 import Web3 from 'web3';
-import { ChainTypes as ChainTypes$1, getSmartContractInstance, getAddressTokenBalanceByContract, getTokenUri, getTokenOfOwnerByIndex } from '@explorins/web3-ts';
 import { FetchRequest, JsonRpcProvider } from 'ethers';
+import { getSmartContractInstance, getAddressTokenBalanceByContract, getTokenUri, getTokenOfOwnerByIndex } from '@explorins/web3-ts';
 
 /**
  * PERS SDK Configuration interfaces
@@ -1276,7 +1276,8 @@ class AuthAdminApi {
      */
     async loginTenantAdmin(jwt) {
         // TODO: Implement proper JWT and bypass header handling when PersApiClient supports it
-        return this.apiClient.post(`${this.basePath}/token`, {});
+        const requestBody = { authToken: jwt };
+        return this.apiClient.post(`${this.basePath}/token`, requestBody);
     }
     /**
      * ADMIN: Refresh access token
@@ -1861,7 +1862,7 @@ class DonationApi {
      * ✅ ONLY method actually used by framework
      */
     async getAllDonationTypes() {
-        return this.apiClient.get('/purchase/donation/type');
+        return this.apiClient.get('/purchases/donation-types');
     }
 }
 
@@ -3673,79 +3674,197 @@ class Web3ChainService {
     }
 }
 
-//IMPORTANT//
-//This function is temporary so we install ethers just to make it work, once we delete this function we must uninstall Ethers
+// ✅ REVERT: Función síncrona como el código comentado que funciona
 const getWeb3ProviderFromChainData = (chainData, timeout = 15000, customUserAgentName = '', tokenRefresher) => {
-    // Fixed ethers provider setup for authenticated requests
+    console.log(`🔧 [getWeb3FCD] Creating provider for chain ${chainData.chainId || 'unknown'}`);
     let ethersProvider;
     if (chainData.authHeader) {
-        // For authenticated requests, create a custom FetchRequest
+        // ✅ AUTHENTICATED: For private chains
         const fetchRequest = new FetchRequest(chainData.rpcUrl);
         fetchRequest.timeout = timeout;
-        fetchRequest.setHeader('Authorization', chainData.authHeader);
+        // ✅ IMPROVED AUTH HEADER: Better handling
+        const authValue = chainData.authHeader.startsWith('Bearer ')
+            ? chainData.authHeader
+            : `Bearer ${chainData.authHeader}`;
+        fetchRequest.setHeader('Authorization', authValue);
         fetchRequest.setHeader('Content-Type', 'application/json');
+        fetchRequest.setHeader('Accept', 'application/json');
         if (customUserAgentName) {
             fetchRequest.setHeader('User-Agent', customUserAgentName);
         }
-        // Create provider with the configured FetchRequest
         ethersProvider = new JsonRpcProvider(fetchRequest, undefined, {
             staticNetwork: false,
-            polling: false, // Disable polling for better Lambda performance
+            polling: false,
+            batchMaxCount: 1, // ✅ DISABLE BATCHING: Better for private chains
         });
     }
     else {
-        // For public chains, use simple URL-based provider
+        // ✅ PUBLIC: For public chains
         ethersProvider = new JsonRpcProvider(chainData.rpcUrl, undefined, {
             staticNetwork: false,
             polling: false,
         });
     }
+    console.log(`✅ [getWeb3FCD] Provider created successfully`);
     return {
         web3Provider: null,
         ethersProvider: ethersProvider,
         isAuthenticated: !!chainData.authHeader,
     };
 };
+// ✅ NEW: Async wrapper with retry for higher-level usage
+const getWeb3ProviderWithRetry = async (chainData, timeout = 15000, customUserAgentName = '', tokenRefresher, retryConfig = { maxAttempts: 3, baseDelay: 1000, maxDelay: 8000 }) => {
+    let lastError = null;
+    for (let attempt = 1; attempt <= retryConfig.maxAttempts; attempt++) {
+        try {
+            console.log(`🔄 [Web3Provider] Attempt ${attempt}/${retryConfig.maxAttempts} for chain ${chainData.chainId || 'unknown'}`);
+            // ✅ SYNC CALL: Use the original sync function
+            const provider = getWeb3ProviderFromChainData(chainData, timeout, customUserAgentName, tokenRefresher);
+            await validateChainConnection(provider.ethersProvider, chainData.authHeader ? 'private' : 'public');
+            console.log(`✅ [Web3Provider] Successfully connected on attempt ${attempt}`);
+            return provider;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            console.warn(`⚠️ [Web3Provider] Attempt ${attempt} failed:`, lastError.message);
+            // ✅ NO RETRY: if auth error, no retry
+            if (isAuthError(lastError) && chainData.authHeader) {
+                console.error(`❌ [Web3Provider] Auth error, stopping retries`);
+                break;
+            }
+            if (attempt === retryConfig.maxAttempts)
+                break;
+            const delay = Math.min(retryConfig.baseDelay * Math.pow(2, attempt - 1), retryConfig.maxDelay);
+            console.log(`⏳ [Web3Provider] Retrying in ${delay}ms...`);
+            await sleep(delay);
+        }
+    }
+    throw new Error(`Failed to create Web3 provider after ${retryConfig.maxAttempts} attempts. Last error: ${lastError?.message}`);
+};
+async function validateChainConnection(provider, chainType) {
+    try {
+        console.log(`🔍 [Validation] Testing ${chainType} chain connection...`);
+        // ✅ LIGHTWEIGHT TEST: Use eth_chainId (works for both public and private)
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(`${chainType} chain validation timeout`)), 3000);
+        });
+        // Try chainId first (fast, lightweight, universal)
+        const chainIdPromise = provider.send('eth_chainId', []);
+        const result = await Promise.race([chainIdPromise, timeoutPromise]);
+        console.log(`✅ [Validation] ${chainType} chain connection validated - Chain ID: ${result}`);
+    }
+    catch (error) {
+        // ✅ FALLBACK: Try net_version if chainId fails
+        try {
+            console.log(`🔄 [Validation] Trying fallback validation for ${chainType} chain...`);
+            const timeoutPromise = new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`${chainType} chain fallback validation timeout`)), 3000);
+            });
+            const versionPromise = provider.send('net_version', []);
+            const result = await Promise.race([versionPromise, timeoutPromise]);
+            console.log(`✅ [Validation] ${chainType} chain connection validated via fallback - Network Version: ${result}`);
+        }
+        catch (fallbackError) {
+            throw new Error(`${chainType} chain validation failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+// ✅ HELPER: Auth error detection
+function isAuthError(error) {
+    const message = error.message.toLowerCase();
+    return (message.includes('unauthorized') ||
+        message.includes('401') ||
+        message.includes('token expired') ||
+        message.includes('-40100'));
+}
+// ✅ HELPER: Sleep utility
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/*
+//IMPORTANT//
+//This function is temporary so we install ethers just to make it work, once we delete this function we must uninstall Ethers
+
+import { ChainData } from "@explorins/web3-ts";
+import { FetchRequest, JsonRpcProvider } from "ethers";
+
+export const getWeb3ProviderFromChainData = (
+  chainData: ChainData,
+  timeout = 15000,
+  customUserAgentName = '',
+  tokenRefresher?: () => Promise<string>
+) => {
+
+  // Fixed ethers provider setup for authenticated requests
+  let ethersProvider: JsonRpcProvider;
+
+  if (chainData.authHeader) {
+    // For authenticated requests, create a custom FetchRequest
+    const fetchRequest = new FetchRequest(chainData.rpcUrl);
+    fetchRequest.timeout = timeout;
+    fetchRequest.setHeader('Authorization', chainData.authHeader);
+    fetchRequest.setHeader('Content-Type', 'application/json');
+
+    if (customUserAgentName) {
+      fetchRequest.setHeader('User-Agent', customUserAgentName);
+    }
+
+    // Create provider with the configured FetchRequest
+    ethersProvider = new JsonRpcProvider(fetchRequest, undefined, {
+      staticNetwork: false,
+      polling: false, // Disable polling for better Lambda performance
+    });
+  } else {
+    // For public chains, use simple URL-based provider
+    ethersProvider = new JsonRpcProvider(chainData.rpcUrl, undefined, {
+      staticNetwork: false,
+      polling: false,
+    });
+  }
+
+  return {
+    web3Provider: null,
+    ethersProvider: ethersProvider,
+    isAuthenticated: !!chainData.authHeader,
+  };
+}; */
 
 class Web3ProviderService {
-    constructor(publicHttpProviderService) {
-        this.publicHttpProviderService = publicHttpProviderService;
+    constructor() {
         this._web3 = null;
         this._currentChainId = null;
+        this._creationPromise = null;
     }
-    async getWeb3(chainId, chainType, privateChainData = null) {
-        if (!this._web3 || this._currentChainId !== chainId) {
-            if (!chainId)
-                throw new Error('ChainId not found');
-            try {
-                this._currentChainId = chainId;
-                const provider = await this.getWeb3ByChainId(chainId, chainType, privateChainData);
-                this._web3 = this.convertToWeb3(provider);
-            }
-            catch (error) {
-                console.error('Error getting web3 connection from chain id ' + chainId, error);
-                throw new Error('Error getting web3 connection from chain id ' + chainId);
-            }
+    async getWeb3(chainId, chainType, chainData) {
+        // ✅ EARLY RETURN: Reuse existing provider
+        if (this._web3 && this._currentChainId === chainId) {
+            return this._web3;
         }
-        return this._web3;
-    }
-    // Keep return type as 'any' to avoid TypeScript errors while still being adapted later
-    getWeb3ByChainId(chainId, chainType, privateChainData = null) {
-        // Rest of the method remains the same
-        if (chainType === ChainTypes$1.PRIVATE && privateChainData) {
-            //const privateProvider = this.privateChainProviderService.getProviderFromChainData(privateChainData)
-            const privateProvider = getWeb3ProviderFromChainData(privateChainData);
-            if (!privateProvider || privateProvider instanceof Error)
-                throw new Error('Error getting web3 provider');
-            return privateProvider;
+        // ✅ PREVENT RACE CONDITION: Wait for ongoing creation
+        if (this._creationPromise) {
+            return await this._creationPromise;
         }
-        else {
-            const publicProvider = this.publicHttpProviderService.getProvider(chainId);
-            if (!publicProvider || publicProvider instanceof Error)
-                throw new Error('Error getting web3 provider');
-            return publicProvider;
+        if (!chainId)
+            throw new Error('ChainId not found');
+        if (!chainData)
+            throw new Error('ChainData not found');
+        // ✅ CREATE AND CACHE: Single promise for concurrent calls
+        this._creationPromise = this.createProvider(chainId, chainType, chainData);
+        try {
+            const web3Instance = await this._creationPromise;
+            this._web3 = web3Instance;
+            this._currentChainId = chainId;
+            return web3Instance;
+        }
+        finally {
+            // ✅ CLEANUP: Always reset promise after completion
+            this._creationPromise = null;
         }
     }
+    async createProvider(chainId, chainType, chainData) {
+        const provider = await getWeb3ProviderWithRetry(chainData);
+        return this.convertToWeb3(provider);
+    }
     convertToWeb3(provider) {
         if (provider instanceof Web3) {
             return provider;
@@ -3797,6 +3916,128 @@ class Web3ProviderService {
             {};
     }
 }
+/* import Web3 from "web3";
+import { ChainData, ChainType, ChainTypes } from "@explorins/web3-ts";
+import { PublicHttpProviderService } from "./public-http-provider.service";
+import { getWeb3ProviderFromChainData } from "./getWeb3FCD.service";
+
+
+export class Web3ProviderService {
+  
+    private _web3: Web3 | null = null;
+    private _currentChainId: number | null = null;
+  
+    constructor(
+        private readonly publicHttpProviderService: PublicHttpProviderService,
+    ) {
+    }
+  
+    public async getWeb3(chainId: number, chainType: ChainType, privateChainData: ChainData | null = null) {
+        if (!this._web3 || this._currentChainId !== chainId) {
+              
+            if(!chainId) throw new Error('ChainId not found')
+  
+            try {
+                this._currentChainId = chainId;
+                const provider = await this.getWeb3ByChainId(chainId, chainType, privateChainData);
+                this._web3 = this.convertToWeb3(provider);
+            } catch (error) {
+                console.error('Error getting web3 connection from chain id ' + chainId , error)
+                throw new Error('Error getting web3 connection from chain id ' + chainId)
+            }
+        }
+        return this._web3 as Web3;
+    }
+  
+    // Keep return type as 'any' to avoid TypeScript errors while still being adapted later
+    private getWeb3ByChainId(chainId: number, chainType: ChainType, privateChainData: ChainData | null = null): any {
+        // Rest of the method remains the same
+        if(chainType === ChainTypes.PRIVATE && privateChainData) {
+            //const privateProvider = this.privateChainProviderService.getProviderFromChainData(privateChainData)
+            const privateProvider = getWeb3ProviderFromChainData(privateChainData);
+            
+            if(!privateProvider || privateProvider instanceof Error) throw new Error('Error getting web3 provider');
+              
+            
+            return privateProvider;
+  
+        } else {
+            
+            const publicProvider = this.publicHttpProviderService.getProvider(chainId)
+            if(!publicProvider || publicProvider instanceof Error) throw new Error('Error getting web3 provider');
+              
+            return publicProvider;
+        }
+    }
+
+    private convertToWeb3(provider: unknown): Web3 {
+        if (provider instanceof Web3) {
+            return provider as Web3;
+        }
+
+        if (provider && typeof provider === 'object' && 'web3Provider' in provider) {
+            const providerObj = provider as {
+                web3Provider?: unknown;
+                ethersProvider?: any;
+                isAuthenticated?: boolean;
+            };
+            
+            // If we want to user the web3Provider directly:
+            /*if (providerObj.web3Provider) {
+                return new Web3(providerObj.web3Provider as never);
+            }*/
+/*if (providerObj.ethersProvider) {
+
+    const url = this.extractUrlFromEthersProvider(providerObj.ethersProvider);
+    const headers = this.extractHeadersFromEthersProvider(providerObj.ethersProvider);
+    
+    const web3 = new Web3(url);
+    const currentProvider = web3.currentProvider as unknown as Record<string, unknown>;
+
+    if (currentProvider) {
+        currentProvider['url'] = url;
+        
+        if (headers && Object.keys(headers).length > 0) {
+            currentProvider['request'] = async (payload: Record<string, unknown>): Promise<Record<string, unknown>> => {
+                const response = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...headers
+                    },
+                    body: JSON.stringify(payload)
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                
+                return await response.json() as Record<string, unknown>;
+            };
+        }
+    }
+
+    return web3;
+}
+}
+
+return new Web3(provider as never);
+}
+
+
+private extractUrlFromEthersProvider(ethersProvider: any): string {
+return ethersProvider.connection?.url ||
+   ethersProvider._getConnection?.()?.url ||
+   ethersProvider.url ||
+   '';
+}
+
+private extractHeadersFromEthersProvider(ethersProvider: any): Record<string, string> {
+return ethersProvider.connection?.headers ||
+   ethersProvider._getConnection?.()?.headers ||
+   {};
+}
+} */
 
 /**
  * Web3 Chain Domain Models
@@ -4147,7 +4388,10 @@ class Web3Service {
     }
 }
 
-function createWeb3SDK(apiClient, web3ProviderService) {
+//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);