dubs-server 1.0.0

package/services/portfolioService.js

@@ -0,0 +1,555 @@
+/**
+ * Portfolio Service
+ *
+ * Fetches a user's Solana portfolio (SOL balance + SPL tokens) directly from
+ * Solana RPC using @solana/web3.js.
+ *
+ * Token metadata strategy (same as jelli-portfolio-api):
+ * 1. Jupiter token list (most comprehensive, loaded on startup)
+ * 2. Metaplex on-chain metadata (for tokens not in Jupiter)
+ * 3. Off-chain metadata from URI
+ */
+
+const { Connection, PublicKey, LAMPORTS_PER_SOL } = require('@solana/web3.js');
+const axios = require('axios');
+const redisService = require('./redisService');
+
+// SPL Token Program IDs
+const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+const TOKEN_2022_PROGRAM_ID = new PublicKey('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb');
+
+// Metaplex Token Metadata Program ID
+const METADATA_PROGRAM_ID = new PublicKey('metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s');
+
+// Redis key prefix for portfolio cache
+const REDIS_KEY_PREFIX = 'portfolio:';
+
+class PortfolioService {
+  constructor(options = {}) {
+    // Token metadata cache (loaded from Jupiter)
+    this.tokenCache = new Map();
+    this.initialized = false;
+
+    // Portfolio cache
+    this.memoryCache = new Map();
+    this.CACHE_TTL = 30; // seconds for Redis
+    this.CACHE_TTL_MS = 30 * 1000; // ms for memory
+
+    // Alchemy RPC URLs
+    const alchemyKey = process.env.ALCHEMY_API_KEY || 'M7pyy3QL4xYOndpcYukNhf-yq2IG6eyl';
+    const mainnetRpc = process.env.PORTFOLIO_MAINNET_RPC || `https://solana-mainnet.g.alchemy.com/v2/${alchemyKey}`;
+    const devnetRpc = process.env.PORTFOLIO_DEVNET_RPC || `https://solana-devnet.g.alchemy.com/v2/${alchemyKey}`;
+
+    this.alchemyKey = alchemyKey;
+    this.rpcUrls = {
+      'mainnet-beta': mainnetRpc,
+      'devnet': devnetRpc,
+    };
+
+    this.connections = {
+      'mainnet-beta': new Connection(mainnetRpc, 'confirmed'),
+      'devnet': new Connection(devnetRpc, 'confirmed'),
+    };
+
+    console.log('[Portfolio] Service initialized with Alchemy');
+    console.log('  Mainnet RPC:', mainnetRpc.replace(alchemyKey, '***'));
+    console.log('  Devnet RPC:', devnetRpc.replace(alchemyKey, '***'));
+
+    // Load Jupiter token list on startup
+    this.initializeTokenList();
+  }
+
+  /**
+   * Load Solana token registry
+   */
+  async initializeTokenList() {
+    try {
+      console.log('[Portfolio] Loading Solana token registry...');
+      const response = await axios.get('https://raw.githubusercontent.com/solana-labs/token-list/main/src/tokens/solana.tokenlist.json', {
+        timeout: 15000,
+      });
+
+      if (response.data?.tokens && Array.isArray(response.data.tokens)) {
+        let count = 0;
+        response.data.tokens.forEach(token => {
+          if (token.address && token.symbol) {
+            this.tokenCache.set(token.address, {
+              mint: token.address,
+              symbol: token.symbol,
+              name: token.name || token.symbol,
+              logo: token.logoURI || null,
+              decimals: token.decimals || 9,
+              source: 'solana-registry',
+              verified: true,
+              tags: token.tags || [],
+            });
+            count++;
+          }
+        });
+        console.log(`[Portfolio] Loaded ${count} tokens from Solana registry`);
+      }
+      this.initialized = true;
+    } catch (error) {
+      console.warn('[Portfolio] Failed to load token list:', error.message);
+      this.initialized = true;
+    }
+  }
+
+  _getConnection(network = 'mainnet-beta') {
+    return this.connections[network] || this.connections['mainnet-beta'];
+  }
+
+  _isValidAddress(address) {
+    try {
+      new PublicKey(address);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  _getRedisKey(walletAddress, network) {
+    return `${REDIS_KEY_PREFIX}${network}:${walletAddress}`;
+  }
+
+  async _getCached(walletAddress, network) {
+    const redisKey = this._getRedisKey(walletAddress, network);
+
+    if (redisService.isAvailable()) {
+      try {
+        const cached = await redisService.get(redisKey);
+        if (cached) return JSON.parse(cached);
+      } catch (error) {
+        console.error('[Portfolio] Redis get error:', error.message);
+      }
+    }
+
+    const memKey = `${walletAddress}:${network}`;
+    const memCached = this.memoryCache.get(memKey);
+    if (memCached && Date.now() - memCached.timestamp < this.CACHE_TTL_MS) {
+      return memCached.data;
+    }
+    return null;
+  }
+
+  async _setCache(walletAddress, network, data) {
+    const redisKey = this._getRedisKey(walletAddress, network);
+    const memKey = `${walletAddress}:${network}`;
+
+    this.memoryCache.set(memKey, { data, timestamp: Date.now() });
+
+    if (redisService.isAvailable()) {
+      try {
+        await redisService.set(redisKey, JSON.stringify(data), this.CACHE_TTL);
+      } catch (error) {
+        console.error('[Portfolio] Redis set error:', error.message);
+      }
+    }
+  }
+
+  /**
+   * Get token metadata - check Jupiter cache first, then fetch Metaplex
+   */
+  async _getTokenMetadata(mintAddress, connection) {
+    // Check Jupiter cache first
+    if (this.tokenCache.has(mintAddress)) {
+      return this.tokenCache.get(mintAddress);
+    }
+
+    // Try Metaplex on-chain metadata
+    try {
+      const metadata = await this._fetchMetaplexMetadata(mintAddress, connection);
+      if (metadata) {
+        this.tokenCache.set(mintAddress, metadata);
+        return metadata;
+      }
+    } catch (error) {
+      // Silent fail
+    }
+
+    // Fallback
+    return {
+      symbol: mintAddress.slice(0, 4).toUpperCase(),
+      name: `Unknown Token`,
+      logo: null,
+      decimals: null,
+    };
+  }
+
+  /**
+   * Fetch Metaplex metadata (copied from jelli-portfolio-api)
+   */
+  async _fetchMetaplexMetadata(mintAddress, connection) {
+    try {
+      console.log(`[Portfolio] Fetching Metaplex metadata for ${mintAddress}`);
+
+      // Metaplex Token Metadata Program ID
+      const TOKEN_METADATA_PROGRAM_ID = 'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s';
+
+      // Create PublicKey objects for PDA derivation
+      const mintPublicKey = new PublicKey(mintAddress);
+      const metadataProgramId = new PublicKey(TOKEN_METADATA_PROGRAM_ID);
+
+      // Derive the metadata account PDA
+      const [metadataAddress] = PublicKey.findProgramAddressSync(
+        [
+          Buffer.from('metadata'),
+          metadataProgramId.toBuffer(),
+          mintPublicKey.toBuffer()
+        ],
+        metadataProgramId
+      );
+
+      console.log(`[Portfolio] Derived metadata address for ${mintAddress}: ${metadataAddress.toString()}`);
+
+      // Fetch the metadata account using RPC endpoint
+      const rpcUrl = connection._rpcEndpoint;
+      const metadataResponse = await axios.post(rpcUrl, {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'getAccountInfo',
+        params: [
+          metadataAddress.toString(),
+          {
+            encoding: 'base64'
+          }
+        ]
+      }, {
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 10000
+      });
+
+      const metadataAccount = metadataResponse.data.result?.value;
+
+      if (!metadataAccount || !metadataAccount.data) {
+        console.log(`[Portfolio] No Metaplex metadata account found for ${mintAddress}`);
+        return null;
+      }
+
+      // Decode the metadata account data
+      const accountData = Buffer.from(metadataAccount.data[0], 'base64');
+
+      // Parse the metadata account
+      try {
+        // Skip the first byte (account discriminator) and parse the basic fields
+        let offset = 1; // Skip discriminator
+
+        // Skip update authority (32 bytes)
+        offset += 32;
+
+        // Skip mint (32 bytes)
+        offset += 32;
+
+        // Read name length (4 bytes)
+        const nameLength = accountData.readUInt32LE(offset);
+        offset += 4;
+
+        // Read name
+        const name = accountData.slice(offset, offset + nameLength).toString('utf8').replace(/\0/g, '');
+        offset += nameLength;
+
+        // Read symbol length (4 bytes)
+        const symbolLength = accountData.readUInt32LE(offset);
+        offset += 4;
+
+        // Read symbol
+        const symbol = accountData.slice(offset, offset + symbolLength).toString('utf8').replace(/\0/g, '');
+        offset += symbolLength;
+
+        // Read URI length (4 bytes)
+        const uriLength = accountData.readUInt32LE(offset);
+        offset += 4;
+
+        // Read URI
+        const uri = accountData.slice(offset, offset + uriLength).toString('utf8').replace(/\0/g, '');
+
+        console.log(`[Portfolio] Parsed Metaplex metadata for ${mintAddress}: name="${name}", symbol="${symbol}", uri="${uri}"`);
+
+        // Fetch off-chain metadata if URI exists
+        let offChainMetadata = null;
+        let logo = null;
+
+        if (uri && uri.trim()) {
+          offChainMetadata = await this._fetchMetadataFromUri(uri.trim());
+          logo = offChainMetadata?.image || null;
+        }
+
+        // Only return if we have meaningful data
+        if (name || symbol || logo) {
+          return {
+            mint: mintAddress,
+            symbol: symbol || 'UNKNOWN',
+            name: name || symbol || 'Unknown Token',
+            logo,
+            decimals: null,
+            source: 'metaplex',
+            uri: uri || null,
+            offChainMetadata
+          };
+        }
+
+        return null;
+
+      } catch (parseError) {
+        console.warn(`[Portfolio] Error parsing Metaplex metadata account for ${mintAddress}:`, parseError.message);
+        return null;
+      }
+
+    } catch (error) {
+      console.warn(`[Portfolio] Error fetching Metaplex metadata for ${mintAddress}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Fetch off-chain metadata from URI
+   */
+  async _fetchMetadataFromUri(uri) {
+    try {
+      if (!uri) return null;
+
+      // Convert IPFS to HTTP gateway
+      let fetchUrl = uri;
+      if (uri.startsWith('ipfs://')) {
+        fetchUrl = uri.replace('ipfs://', 'https://ipfs.io/ipfs/');
+      }
+
+      const response = await axios.get(fetchUrl, {
+        timeout: 5000,
+        headers: { 'Accept': 'application/json', 'User-Agent': 'Dubs-Portfolio-API/1.0' }
+      });
+
+      const metadata = response.data;
+
+      // Get image URL
+      let image = metadata.image || metadata.image_url || null;
+      if (image && image.startsWith('ipfs://')) {
+        image = image.replace('ipfs://', 'https://ipfs.io/ipfs/');
+      }
+
+      return {
+        name: metadata.name || null,
+        description: metadata.description || null,
+        image,
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Get full portfolio using Alchemy RPC + DAS API
+   * 1. Get token accounts from both SPL and Token-2022 programs
+   * 2. Get metadata via getAsset for each token
+   */
+  async getPortfolio(walletAddress, network = 'mainnet-beta', forceRefresh = false) {
+    if (!walletAddress || !this._isValidAddress(walletAddress)) {
+      throw new Error('Invalid wallet address');
+    }
+
+    // Check cache
+    if (!forceRefresh) {
+      const cached = await this._getCached(walletAddress, network);
+      if (cached) {
+        console.log(`[Portfolio] Cache hit for ${walletAddress.slice(0, 8)}...`);
+        return { ...cached, fromCache: true };
+      }
+    }
+
+    const startTime = Date.now();
+    const connection = this._getConnection(network);
+    const rpcUrl = this.rpcUrls[network] || this.rpcUrls['mainnet-beta'];
+
+    try {
+      // Fetch SOL balance and token accounts (both programs) in parallel
+      const [solBalance, splTokensRes, token2022Res] = await Promise.all([
+        connection.getBalance(new PublicKey(walletAddress)),
+        axios.post(rpcUrl, {
+          jsonrpc: '2.0', id: 'spl',
+          method: 'getTokenAccountsByOwner',
+          params: [walletAddress, { programId: TOKEN_PROGRAM_ID.toString() }, { encoding: 'jsonParsed' }]
+        }, { headers: { 'Content-Type': 'application/json' }, timeout: 30000 }),
+        axios.post(rpcUrl, {
+          jsonrpc: '2.0', id: 't22',
+          method: 'getTokenAccountsByOwner',
+          params: [walletAddress, { programId: TOKEN_2022_PROGRAM_ID.toString() }, { encoding: 'jsonParsed' }]
+        }, { headers: { 'Content-Type': 'application/json' }, timeout: 30000 }),
+      ]);
+
+      // Combine token accounts
+      const splTokens = (splTokensRes.data?.result?.value || []).map(a => ({ ...a, isToken2022: false }));
+      const token2022s = (token2022Res.data?.result?.value || []).map(a => ({ ...a, isToken2022: true }));
+      const allAccounts = [...splTokens, ...token2022s];
+
+      console.log(`[Portfolio] Found ${splTokens.length} SPL + ${token2022s.length} Token-2022 accounts`);
+
+      // Filter non-zero balances and collect mints
+      const accountsWithBalance = allAccounts.filter(a => {
+        const amount = a.account?.data?.parsed?.info?.tokenAmount;
+        return amount && parseFloat(amount.uiAmount) > 0;
+      });
+
+      // Get metadata for all mints via getAsset
+      const tokenBalances = [];
+      const nftBalances = [];
+      const allTokens = [];
+
+      for (const account of accountsWithBalance) {
+        const info = account.account.data.parsed.info;
+        const mint = info.mint;
+        const tokenAmount = info.tokenAmount;
+        const isToken2022 = account.isToken2022;
+
+        // Get metadata - check local cache first, then DAS API
+        let metadata = { symbol: 'UNKNOWN', name: 'Unknown Token', logo: null, source: 'unknown' };
+
+        // Check Solana registry cache first
+        if (this.tokenCache.has(mint)) {
+          const cached = this.tokenCache.get(mint);
+          metadata = {
+            symbol: cached.symbol,
+            name: cached.name,
+            logo: cached.logo,
+            source: 'solana-registry'
+          };
+        }
+
+        // Try DAS API for additional/better metadata
+        try {
+          const assetRes = await axios.post(rpcUrl, {
+            jsonrpc: '2.0', id: mint,
+            method: 'getAsset',
+            params: { id: mint }
+          }, { headers: { 'Content-Type': 'application/json' }, timeout: 10000 });
+
+          const asset = assetRes.data?.result;
+          if (asset) {
+            const content = asset.content || {};
+            const meta = content.metadata || {};
+            const links = content.links || {};
+            const files = content.files || [];
+
+            // Only override if DAS has better data
+            if (meta.symbol) metadata.symbol = meta.symbol;
+            if (meta.name) metadata.name = meta.name;
+            if (links.image || files[0]?.uri) {
+              metadata.logo = links.image || files[0]?.uri;
+            }
+            metadata.source = 'alchemy-das';
+          }
+        } catch (e) {
+          // Silent fail - use cached data
+        }
+
+        const balance = parseFloat(tokenAmount.uiAmount);
+        const decimals = tokenAmount.decimals;
+        const isNFT = decimals === 0 && balance === 1;
+
+        const tokenData = {
+          mint,
+          tokenAccount: account.pubkey.toString(),
+          symbol: metadata.symbol,
+          name: metadata.name,
+          balance,
+          balanceFormatted: balance.toFixed(Math.min(decimals, 6)),
+          decimals,
+          rawBalance: tokenAmount.amount,
+          isNFT,
+          type: isNFT ? 'nft' : 'fungible',
+          programId: isToken2022 ? TOKEN_2022_PROGRAM_ID.toString() : TOKEN_PROGRAM_ID.toString(),
+          programType: isToken2022 ? 'Token-2022 Program' : 'Token Program',
+          isTokenExtension: isToken2022,
+          metadata: {
+            logoURI: metadata.logo,
+            verified: false,
+            source: 'alchemy-das',
+          },
+          network: 'solana',
+          environment: network,
+          timestamp: Date.now(),
+        };
+
+        allTokens.push(tokenData);
+        if (isNFT) {
+          nftBalances.push(tokenData);
+        } else {
+          tokenBalances.push(tokenData);
+        }
+      }
+
+      // Sort
+      tokenBalances.sort((a, b) => b.balance - a.balance);
+      nftBalances.sort((a, b) => a.name.localeCompare(b.name));
+
+      const elapsed = Date.now() - startTime;
+      const token2022Count = allTokens.filter(t => t.isTokenExtension).length;
+      console.log(`[Portfolio] Fetched ${walletAddress.slice(0, 8)}... in ${elapsed}ms (${tokenBalances.length} fungible, ${nftBalances.length} NFTs, ${token2022Count} Token-2022)`);
+
+      const result = {
+        address: walletAddress,
+        network: 'solana',
+        environment: network,
+        nativeBalance: {
+          network: 'solana',
+          environment: network,
+          symbol: 'SOL',
+          balance: solBalance / LAMPORTS_PER_SOL,
+          balanceFormatted: (solBalance / LAMPORTS_PER_SOL).toFixed(6),
+          rawBalance: solBalance.toString(),
+          decimals: 9,
+          timestamp: Date.now(),
+          source: 'blockchain',
+        },
+        tokenBalances,
+        nftBalances,
+        allTokens,
+        tokenCount: allTokens.length,
+        fungibleTokenCount: tokenBalances.length,
+        nftCount: nftBalances.length,
+        timestamp: Date.now(),
+        fetchTimeMs: elapsed,
+      };
+
+      await this._setCache(walletAddress, network, result);
+
+      return { ...result, fromCache: false };
+    } catch (error) {
+      console.error('[Portfolio] Error fetching portfolio:', error);
+      throw new Error(`Failed to fetch portfolio: ${error.message}`);
+    }
+  }
+
+  async invalidateCache(walletAddress, network = 'mainnet-beta') {
+    const redisKey = this._getRedisKey(walletAddress, network);
+    const memKey = `${walletAddress}:${network}`;
+
+    this.memoryCache.delete(memKey);
+
+    if (redisService.isAvailable()) {
+      try {
+        await redisService.del(redisKey);
+      } catch (error) {
+        console.error('[Portfolio] Redis delete error:', error.message);
+      }
+    }
+
+    console.log(`[Portfolio] Cache invalidated for ${walletAddress.slice(0, 8)}...`);
+  }
+
+  clearCache() {
+    this.memoryCache.clear();
+    console.log('[Portfolio] Memory cache cleared');
+  }
+
+  getCacheStats() {
+    return {
+      memoryEntries: this.memoryCache.size,
+      tokensCached: this.tokenCache.size,
+      ttlSeconds: this.CACHE_TTL,
+      redisAvailable: redisService.isAvailable(),
+      initialized: this.initialized,
+    };
+  }
+}
+
+module.exports = PortfolioService;