Merge pull request #65 from keljoshX/feature/multi-currency-price-feed

Multi Currency Price Feed Feature

Author: elizabetheonoja-art

index.js

@@ -1,6 +1,7 @@
 require('dotenv').config();
 const express = require('express');
 const cors = require('cors');
+const { getUSDCToFiatRates, getXLMToUSDCPath } = require('./services/priceFeedService');
 const { checkAndInitializeLease, getLeases, saveLeases } = require('./worker');
 const leaseRoutes = require('./src/routes/leaseRoutes');
 const ownerRoutes = require('./src/routes/ownerRoutes');
@@ -500,6 +501,55 @@ app.post('/sign-lease', async (req, res) => {
   res.json({ message: `Lease ${leaseId} signed by ${role}.`, state: leases[leaseId] });
 });
 
+/**
+ * Get current USDC to Fiat exchange rates.
+ * Query params: currencies (comma-separated list of fiat currency codes, e.g., 'ngn,eur')
+ */
+app.get('/api/price-feed', async (req, res) => {
+  try {
+    const { currencies } = req.query;
+    const currencyList = currencies ? currencies.split(',') : ['ngn', 'eur', 'usd'];
+    const rates = await getUSDCToFiatRates(currencyList);
+    res.json({ 
+      success: true, 
+      rates,
+      base_currency: 'USDC' 
+    });
+  } catch (error) {
+    res.status(500).json({ 
+      success: false, 
+      message: error.message 
+    });
+  }
+});
+
+/**
+ * Calculate the best path for XLM to USDC payment.
+ * Query params: amount (destination USDC amount)
+ */
+app.get('/api/calculate-path-payment', async (req, res) => {
+  try {
+    const { amount } = req.query;
+    if (!amount) {
+      return res.status(400).json({ 
+        success: false, 
+        message: 'Destination amount is required.' 
+      });
+    }
+
+    const pathDetails = await getXLMToUSDCPath(amount);
+    res.json({ 
+      success: true, 
+      ...pathDetails 
+    });
+  } catch (error) {
+    res.status(500).json({ 
+      success: false, 
+      message: error.message 
+    });
+  }
+});
+
 // Asset metadata endpoints
 app.get('/api/asset/:id/metadata', async (req, res) => {
   try {

package-lock.json

@@ -0,0 +1,74 @@
+const axios = require('axios');
+const { Horizon, Asset } = require('@stellar/stellar-sdk');
+
+const COINGECKO_API_URL = 'https://api.coingecko.com/api/v3';
+const STELLAR_HORIZON_URL = 'https://horizon-testnet.stellar.org';
+const server = new Horizon.Server(STELLAR_HORIZON_URL);
+
+// USDC on Stellar Testnet (Circle issuer)
+const USDC_ASSET = new Asset(
+  'USDC',
+  'GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5'
+);
+
+/**
+ * Fetch USDC to Fiat exchange rates.
+ * @param {string[]} currencies - Array of fiat currency codes (e.g., ['ngn', 'eur']).
+ * @returns {Promise<Object>} - Exchange rates.
+ */
+async function getUSDCToFiatRates(currencies = ['ngn', 'eur', 'usd']) {
+  try {
+    // USDC's ID on CoinGecko is 'usd-coin'
+    const response = await axios.get(`${COINGECKO_API_URL}/simple/price`, {
+      params: {
+        ids: 'usd-coin',
+        vs_currencies: currencies.join(','),
+      },
+    });
+    return response.data['usd-coin'];
+  } catch (error) {
+    console.error('Error fetching fiat rates from CoinGecko:', error.message);
+    // Fallback or rethrow
+    throw new Error('Failed to fetch fiat exchange rates.');
+  }
+}
+
+/**
+ * Calculate the best path for XLM to USDC payment.
+ * @param {string} destinationAmount - Amount of USDC required by the landlord.
+ * @returns {Promise<Object>} - Path payment details.
+ */
+async function getXLMToUSDCPath(destinationAmount) {
+  try {
+    const paths = await server.strictReceivePaths(
+      [Asset.native()], // Source asset (XLM)
+      USDC_ASSET,       // Destination asset (USDC)
+      destinationAmount // Destination amount
+    ).call();
+
+    if (paths.records && paths.records.length > 0) {
+      // Sort by source amount ascending to find the most cost-effective path
+      const sortedPaths = paths.records.sort((a, b) => parseFloat(a.source_amount) - parseFloat(b.source_amount));
+      const bestPath = sortedPaths[0];
+
+      return {
+        sourceAsset: 'XLM',
+        sourceAmount: bestPath.source_amount,
+        destinationAsset: 'USDC',
+        destinationAmount: destinationAmount,
+        path: bestPath.path,
+        price: bestPath.source_amount / destinationAmount,
+      };
+    } else {
+      throw new Error('No path found for XLM to USDC.');
+    }
+  } catch (error) {
+    console.error('Error finding Stellar path:', error.message);
+    throw new Error('Failed to calculate path payment.');
+  }
+}
+
+module.exports = {
+  getUSDCToFiatRates,
+  getXLMToUSDCPath,
+};

services/priceFeedService.js

@@ -0,0 +1,82 @@
+const request = require('supertest');
+const app = require('../index');
+const axios = require('axios');
+const { Horizon } = require('@stellar/stellar-sdk');
+
+// Mock axios
+jest.mock('axios');
+
+// Mock Horizon server
+jest.mock('@stellar/stellar-sdk', () => {
+  const originalModule = jest.requireActual('@stellar/stellar-sdk');
+  return {
+    ...originalModule,
+    Horizon: {
+      Server: jest.fn().mockImplementation(() => ({
+        strictReceivePaths: jest.fn().mockReturnValue({
+          call: jest.fn().mockResolvedValue({
+            records: [
+              {
+                source_amount: '10.5',
+                path: [],
+              },
+            ],
+          }),
+        }),
+      })),
+    },
+  };
+});
+
+describe('Price Feed API', () => {
+  describe('GET /api/price-feed', () => {
+    it('should return USDC to Fiat rates', async () => {
+      const mockRates = {
+        'usd-coin': {
+          ngn: 1500,
+          eur: 0.92,
+          usd: 1,
+        },
+      };
+      axios.get.mockResolvedValue({ data: mockRates });
+
+      const response = await request(app).get('/api/price-feed?currencies=ngn,eur,usd');
+
+      expect(response.status).toBe(200);
+      expect(response.body.success).toBe(true);
+      expect(response.body.rates).toEqual(mockRates['usd-coin']);
+      expect(response.body.base_currency).toBe('USDC');
+    });
+
+    it('should handle errors when fetching rates', async () => {
+      axios.get.mockRejectedValue(new Error('API Error'));
+
+      const response = await request(app).get('/api/price-feed');
+
+      expect(response.status).toBe(500);
+      expect(response.body.success).toBe(false);
+      expect(response.body.message).toBe('Failed to fetch fiat exchange rates.');
+    });
+  });
+
+  describe('GET /api/calculate-path-payment', () => {
+    it('should return path details for XLM to USDC', async () => {
+      const response = await request(app).get('/api/calculate-path-payment?amount=100');
+
+      expect(response.status).toBe(200);
+      expect(response.body.success).toBe(true);
+      expect(response.body.sourceAsset).toBe('XLM');
+      expect(response.body.sourceAmount).toBe('10.5');
+      expect(response.body.destinationAsset).toBe('USDC');
+      expect(response.body.destinationAmount).toBe('100');
+    });
+
+    it('should return 400 if amount is missing', async () => {
+      const response = await request(app).get('/api/calculate-path-payment');
+
+      expect(response.status).toBe(400);
+      expect(response.body.success).toBe(false);
+      expect(response.body.message).toBe('Destination amount is required.');
+    });
+  });
+});