@explorins/pers-sdk 1.1.2 → 1.2.0

package/src/web3/models/index.ts

@@ -1,150 +0,0 @@
-import type { ContractAbi, Web3 } from 'web3';
-import type { TokenDTO } from '../../shared/interfaces/pers-shared-lib.interfaces';
-
-// ✅ REMOVE: Custom Web3ContractAbi type (no longer needed)
-// export type Web3ContractAbi = readonly AbiFragment[] | AbiFragment[];
-
-export interface Web3BalanceRequest {
-  accountAddress: string;
-  token: TokenDTO;
-  tokenId: string | null;
-}
-
-export interface Web3BalanceResponse {
-  rawBalance: number;
-  formattedBalance: string;
-  decimals: number;
-  symbol: string;
-  hasBalance: boolean;
-}
-
-export interface Web3TokenConfig {
-  token: TokenDTO;
-  tokenIds?: (string | null)[];
-  metadata?: any[];
-}
-
-export interface Web3TokenListRequest {
-  accountAddress: string;
-  tokens: Web3TokenConfig[];
-}
-
-export interface Web3TokenResult {
-  tokenId: string | null;
-  balance: number;
-  formattedBalance: string;
-  hasBalance: boolean;
-  metadata: any | null;
-}
-
-export interface Web3TokenListResponse {
-  accountAddress: string;
-  tokens: {
-    token: TokenDTO;
-    results: Web3TokenResult[];
-  }[];
-}
-
-export interface NFTItem {
-  tokenId: string;
-  name: string;
-  description: string;
-  imageUrl: string;
-  rawBalance: number;
-  formattedBalance: string;
-  hasBalance: boolean;
-  metadata: any;
-  tokenIndex: number;
-}
-
-export interface ERC721CollectionRequest {
-  accountAddress: string;
-  nftContracts: TokenDTO[];
-  maxNFTsPerContract?: number;
-}
-
-export interface ERC721CollectionResponse {
-  accountAddress: string;
-  contracts: {
-    token: TokenDTO;
-    totalNFTs: number;
-    nfts: NFTItem[];
-    hasMore: boolean;
-  }[];
-  summary: {
-    totalContracts: number;
-    totalNFTs: number;
-    loadingTime: number;
-  };
-}
-
-// ✅ NEW: ERC20 Balance types (simplified)
-export interface ERC20BalanceRequest {
-  accountAddress: string;
-  token: TokenDTO;
-}
-
-// ✅ NEW: ERC1155 Collection types (clearer naming)
-export interface ERC1155CollectionRequest {
-  accountAddress: string;
-  tokens: TokenDTO[];
-}
-
-// ✅ RE-EXPORT: Standard Web3.js types for consumers
-export type { ContractAbi } from 'web3';
-
-// ✅ CACHE: Simple cache interface with TTL
-export interface CacheEntry<T> {
-  data: T;
-  timestamp: number;
-  ttl: number;
-}
-
-export interface CacheStorage {
-  [key: string]: CacheEntry<unknown>;
-}
-
-export class SimpleCache {
-  private storage: CacheStorage = {};
-  private readonly defaultTTL = 10 * 1000; // 10 seconds
-
-  set<T>(key: string, data: T, ttl?: number): void {
-    this.storage[key] = {
-      data,
-      timestamp: Date.now(),
-      ttl: ttl ?? this.defaultTTL
-    };
-  }
-
-  get<T>(key: string): T | null {
-    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 as T;
-  }
-
-  clear(): void {
-    this.storage = {};
-  }
-
-  cleanup(): void {
-    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];
-      }
-    });
-  }
-}

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

@@ -1,338 +0,0 @@
-import { Web3ChainService } from '../../web3-chain';
-import { Web3Api } from '../api/web3-api';
-import { 
-  ERC20BalanceRequest, 
-  ERC1155CollectionRequest, 
-  ERC721CollectionRequest, 
-  ERC721CollectionResponse, 
-  NFTItem, 
-  Web3BalanceResponse, 
-  Web3TokenListResponse, 
-  Web3TokenResult,
-  SimpleCache
-} from '../models';
-
-export class Web3Service {
-  //temporary fix, remove when the backend supports custom gateways
-  private readonly defaultIpfsGatewayDomain = 'pers.mypinata.cloud';
-
-  // ✅ CACHE: Simple 10-second cache instance
-  private cache = new SimpleCache();
-  private cleanupInterval: NodeJS.Timeout | null = null;
-
-  constructor(
-    private web3Api: Web3Api,
-    private web3ChainService: Web3ChainService
-  ) {
-    this.cleanupInterval = setInterval(() => {
-      this.cache.cleanup();
-    }, 30 * 1000);
-  }
-
-  destroy(): void {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    this.cache.clear();
-  }
-
-  async getERC20Balance(request: ERC20BalanceRequest): Promise<Web3BalanceResponse> {
-    
-    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<Web3BalanceResponse>(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({
-      accountAddress: request.accountAddress,
-      contractAddress: request.token.contractAddress,
-      abi: request.token.abi,
-      tokenId: null, // Always null for ERC20
-      chainId: request.token.chainId
-    });
-
-    const decimals = request.token.decimals ?? 18;
-    const symbol = request.token.symbol ?? 'UNKNOWN';
-
-    const response: Web3BalanceResponse = {
-      rawBalance,
-      formattedBalance: this.formatBalance(rawBalance, decimals),
-      decimals,
-      symbol,
-      hasBalance: rawBalance > 0
-    };
-
-    // ✅ CACHE SET: Store result in cache
-    this.cache.set(cacheKey, response);
-    
-    return response;
-  }
-
-  async getERC1155Collection(request: ERC1155CollectionRequest): Promise<Web3TokenListResponse> {
-    
-        // ✅ 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<Web3TokenListResponse>(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: string[] = token.metadata?.map(m => 
-          m.tokenMetadataIncrementalId?.toString()
-        ).filter((id): id is string => 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: Web3TokenResult[] = [];
-        for (const result of balanceResults) {
-          if (result.status === 'fulfilled' && result.value !== null && result.value.hasBalance) {
-            successfulResults.push(result.value);
-          }
-        }
-
-        return {
-          token,
-          results: successfulResults
-        };
-      })
-    );
-
-    const response: Web3TokenListResponse = {
-      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: ERC721CollectionRequest): Promise<ERC721CollectionResponse> {
-    
-        // ✅ 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<ERC721CollectionResponse>(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
-          });
-          
-          if (totalBalance === 0) {
-            return {
-              token,
-              totalNFTs: 0,
-              nfts: [],
-              hasMore: false
-            };
-          }
-
-          const nftsToLoad = Math.min(totalBalance, maxNFTs);
-          
-          const nftResults = await Promise.allSettled(
-            Array.from({ length: nftsToLoad }, async (_, index): Promise<NFTItem | null> => {
-              try {
-                const tokenId = await this.web3Api.getTokenOfOwnerByIndex({
-                  contractAddress: token.contractAddress,
-                  abi: token.abi,
-                  accountAddress: request.accountAddress,
-                  tokenIndex: index,
-                  chainId: token.chainId
-                });
-                
-                const tokenUri = await this.web3Api.getTokenUri({
-                  contractAddress: token.contractAddress,
-                  abi: token.abi,
-                  tokenId,
-                  chainId: token.chainId
-                });
-                
-                const metadata = await this.fetchMetadata(tokenUri, token.chainId);
-                
-                const nftItem: 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;
-                
-              } catch (error) {
-                console.warn(`Failed to load NFT at index ${index} for ${token.symbol}:`, error);
-                return null;
-              }
-            })
-          );
-          
-          // ✅ FIXED: Usar tipo específico NFTItem
-          const successfulNFTs = nftResults
-            .filter((result): result is PromiseFulfilledResult<NFTItem | null> => 
-              result.status === 'fulfilled' && result.value !== null
-            )
-            .map(result => result.value as NFTItem);
-          
-          return {
-            token,
-            totalNFTs: totalBalance,
-            nfts: successfulNFTs,
-            hasMore: totalBalance > maxNFTs
-          };
-          
-        } catch (error) {
-          console.error(`Failed to load NFT collection for ${token.symbol}:`, error);
-          return {
-            token,
-            totalNFTs: 0,
-            nfts: [],
-            hasMore: false
-          };
-        }
-      })
-    );
-    
-    const totalNFTs = contractResults.reduce((sum, contract) => sum + contract.nfts.length, 0);
-    const loadingTime = Date.now() - startTime;
-    
-    const response: ERC721CollectionResponse = {
-      accountAddress: request.accountAddress,
-      contracts: contractResults,
-      summary: {
-        totalContracts: request.nftContracts.length,
-        totalNFTs,
-        loadingTime
-      }
-    };
-
-    // ✅ CACHE SET: Store complete collection response
-    this.cache.set(cacheKey, response);
-    
-    return response;
-  }
-
-  // ==========================================
-  // HELPER METHODS
-  // ==========================================
-
-  private formatBalance(rawBalance: number, decimals: number): string {
-    const balance = rawBalance / Math.pow(10, decimals);
-    
-    return balance.toLocaleString('en-US', {
-      minimumFractionDigits: 0,
-      maximumFractionDigits: decimals > 0 ? 2 : 0
-    });
-  }
-
-  // ✅ FIXED: Update method signature to handle null properly
-  private findMetadata(metadata: any[] | undefined, tokenId: string | null): any | null {
-    if (!metadata || tokenId === null) return null;
-    return metadata.find(m => 
-      m.tokenMetadataIncrementalId?.toString() === tokenId
-    ) || null;
-  }
-
-  private async fetchMetadata(uri: string, chainId: number): Promise<any> {
-    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();
-    } catch (error) {
-      console.warn('Failed to fetch NFT metadata:', error);
-      return null;
-    }
-  }
-
-  private async getIpfsGatewayDomain(chainId: number): Promise<string> {
-    try {
-      const chainData = await this.web3ChainService.getChainDataWithCache(chainId);
-      return chainData.ipfsGatewayDomain || this.defaultIpfsGatewayDomain;
-    } catch (error) {
-      console.warn(`Failed to get chain data for chainId ${chainId}, using default IPFS gateway:`, error);
-      return this.defaultIpfsGatewayDomain;
-    }
-  }
-
-  private async resolveIPFSUrl(url: string, chainId: number): Promise<string> {
-    if (!url) return '';
-    
-    if (url.startsWith('ipfs://')) {
-      const gatewayDomain = await this.getIpfsGatewayDomain(chainId);
-      return `https://${gatewayDomain}/ipfs/${url.slice(7)}`;
-    }
-    
-    return url;
-  }
-}

package/src/web3-chain/api/web3-chain-api.ts

@@ -1,42 +0,0 @@
-import { PersApiClient } from '../../core/pers-api-client';
-import { ChainData } from '../models';
-
-/**
- * Platform-Agnostic Web3 Chain API Client
- * 
- * Handles blockchain chain operations using the PERS backend.
- * Uses @explorins/web3-ts types for perfect framework compatibility.
- */
-export class Web3ChainApi {
-  constructor(private apiClient: PersApiClient) {}
-
-  private basePath = '/chains';
-
-  // ==========================================
-  // PUBLIC OPERATIONS
-  // ==========================================
-
-  /**
-   * PUBLIC: Get chain data by chain ID
-   * ✅ Returns ChainData exactly as framework expects from @explorins/web3-ts
-   */
-  async getChainData(chainId: number): Promise<ChainData> {
-  try {
-
-    console.log('🔍 [Web3ChainApi] Fetching chain data for chainId:', chainId);
-    const response = await this.apiClient.get<ChainData>(`${this.basePath}/${chainId}`);
-
-    if (!response) {
-      throw new Error(`No chain data received for chainId: ${chainId}`);
-    }
-
-    return response;
-  } catch (error) {
-    console.error('❌ [Web3ChainApi] Failed to get chain data:', {
-      chainId,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    throw error;
-  }
-}
-}

package/src/web3-chain/index.ts

@@ -1,27 +0,0 @@
-import { PersApiClient } from '../core/pers-api-client';
-import { Web3ChainApi } from './api/web3-chain-api';
-import { Web3ProviderService } from './services/provider.service';
-
-import { Web3ChainService } from './services/web3-chain-service';
-
-export function createWeb3ChainSDK(apiClient: PersApiClient, providerService: Web3ProviderService) {
-  const web3ChainApi = new Web3ChainApi(apiClient);
-  const web3ChainService = new Web3ChainService(web3ChainApi, providerService); // ✅ DIRECT INJECTION
-  
-  return {
-    // ✅ REPLICA: Same methods as framework
-    getChainDataById: (chainId: number) => web3ChainService.getChainDataById(chainId),
-    getWeb3ByChainId: (chainId: number) => web3ChainService.getWeb3ByChainId(chainId),
-    
-    api: web3ChainApi,
-    service: web3ChainService
-  };
-}
-
-// ✅ EXPORT: All models and service
-export { Web3ChainApi } from './api/web3-chain-api';
-export { Web3ChainService } from './services/web3-chain-service';
-export { Web3ProviderService } from './services/provider.service';
-export * from './models';
-export type { ChainData } from './models';
-export * from '../shared/interfaces/pers-shared-lib.interfaces';

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

@@ -1,47 +0,0 @@
-
-//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,
-  };
-};