@explorins/pers-sdk 1.1.2 → 1.2.0

package/src/web3-chain/services/provider.service.ts

@@ -1,123 +0,0 @@
-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 || 
-               {};
-    }
-}

package/src/web3-chain/services/public-http-provider.service.ts

@@ -1,26 +0,0 @@
-import type { PublicWeb3ProviderData } from "@explorins/web3/types";
-import type Web3 from "web3";
-
-import { adaptToWeb3, getPublicWeb3ConnectionFromChainId } from "@explorins/web3-ts";
-
-export class PublicHttpProviderService {
-    private $providerData: PublicWeb3ProviderData | null;
-
-    constructor(providerData: PublicWeb3ProviderData | null = null) {
-        this.$providerData = providerData;
-    }
-
-    public getProvider(chainId: number): Web3 {
-        const providerApiKey = this.$providerData ? this.$providerData?.apiKey || null : null;
-        if (!providerApiKey) throw new Error('Provider API key not found');
-        
-        try {
-            // Use the adapter function instead of unsafe type casting
-            const provider = getPublicWeb3ConnectionFromChainId(chainId, 'infuraHttp', providerApiKey);
-            return adaptToWeb3(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);
-        }
-    }
-}

package/src/web3-chain/services/web3-chain-service.ts

@@ -1,131 +0,0 @@
-import { Web3ChainApi } from '../api/web3-chain-api';
-import { ChainData, CachedChainInstance } from '../models';
-import type { Web3 } from 'web3';
-import { isTokenExpired } from '../../core/utils/jwt.function';
-import { Web3ProviderService } from './provider.service';
-
-export class Web3ChainService {
-
-  private web3InstanceCache = new Map<number, CachedChainInstance>();
-  
-  constructor(
-    private web3ChainApi: Web3ChainApi,
-    private providerService: Web3ProviderService
-  ) {}
-
-  async getWeb3ByChainId(chainId: number): Promise<Web3> {
-    const cached = this.web3InstanceCache.get(chainId);
-
-    // ✅ SMART CACHE: Check if cache is valid based on token expiration
-    if (cached && !this.checkIsTokenExpired(cached.chainData.authHeader)) {
-      console.log(`♻️ [Web3ChainService] Using cached Web3 instance for chain ${chainId}`);
-      return cached.web3Instance;
-    }
-
-    // ✅ CREATE WITH ERROR RECOVERY: Handle auth errors gracefully
-    try {
-      console.log(`🔧 [Web3ChainService] Creating new Web3 instance for chain ${chainId}`);
-      const { web3, chainData } = await this.createWeb3Instance(chainId);
-      
-      // ✅ CACHE NEW INSTANCE
-      this.web3InstanceCache.set(chainId, {
-        web3Instance: web3,
-        chainData: chainData,
-        createdAt: Date.now(),
-        chainId
-      });
-      
-      return web3;
-    } catch (error) {
-      // ✅ AUTH ERROR RECOVERY: Clear cache and retry once
-      if (this.isAuthError(error)) {
-        console.warn(`🔄 [Web3ChainService] Auth error detected, clearing cache and retrying...`);
-        this.web3InstanceCache.delete(chainId);
-        
-        // Retry once with fresh instance
-        const { web3, chainData } = await this.createWeb3Instance(chainId);
-        
-        this.web3InstanceCache.set(chainId, {
-          web3Instance: web3,
-          chainData: chainData,
-          createdAt: Date.now(),
-          chainId
-        });
-        
-        return web3;
-      }
-      
-      throw error;
-    }
-  }
-
-  async getChainDataWithCache(chainId: number): Promise<ChainData> {
-    const cached = this.web3InstanceCache.get(chainId);
-    //const now = Date.now();
-
-    if (cached && !this.checkIsTokenExpired(cached.chainData.authHeader)) {
-      console.log(`♻️ [Web3ChainService] Using cached ChainData for chain ${chainId}`);
-      return cached.chainData;
-    }
-
-    // If not cached, fetch fresh data
-    const chainData = await this.getChainDataById(chainId);
-    if (!chainData) {
-      throw new Error(`Chain data not found for chainId: ${chainId}`);
-    }
-
-    return chainData;
-  }
-
-  private checkIsTokenExpired(authHeader?: string): boolean {
-    // ✅ NULL CHECK: Handle undefined case
-    if (!authHeader) {
-      return false; // No token means no expiration (public chains)
-    }
-    
-    // ✅ FUNCTION CALL: Use imported function, not method
-    return isTokenExpired(authHeader);
-  }
-
-  private async createWeb3Instance(chainId: number): Promise<{ web3: Web3; chainData: ChainData }> {
-    const chainData = await this.getChainDataById(chainId);
-
-    if (!chainData) {
-      throw new Error(`Chain data not found for chainId: ${chainId}`);
-    }
-
-    // ✅ CRITICAL CHECK: Ensure authHeader is present for private chains
-    if (chainData.chainType === 'PRIVATE' && !chainData.authHeader) {
-      console.error('❌ [Web3ChainService] CRITICAL: Private chain missing authHeader!');
-      throw new Error(`Private chain ${chainId} missing authentication header`);
-    }
-
-    const web3 = await this.providerService.getWeb3(
-      chainId, 
-      chainData.chainType || 'PUBLIC', 
-      chainData
-    );
-
-    return { web3, chainData };
-  }
-
-  // ✅ HELPER: Type-safe error checking
-  private isAuthError(error: unknown): boolean {
-    const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
-    return (
-      message.includes('unauthorized') ||
-      message.includes('401') ||
-      message.includes('token expired') ||
-      message.includes('invalid token')
-    );
-  }
-
-  async getChainDataById(chainId: number): Promise<ChainData | null> {
-    try {
-      return await this.web3ChainApi.getChainData(chainId);
-    } catch (error) {
-      console.error('❌ [SDK Web3ChainService] Error getting chain data for chainId:', chainId, error);
-      return null;
-    }
-  }
-}

package/tsconfig.json

@@ -1,28 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext", 
-    "moduleResolution": "node",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "./dist",
-    "baseUrl": ".",
-    "paths": {
-      "@explorins/pers-shared": ["../../framework/entities"]
-    }
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "**/*.test.ts",
-    "**/*.spec.ts"
-  ]
-}