bug: ReflectorService fetches prices from CoinGecko only — advertised Reflector oracle integration is not implemented

[Uchechukwu-Ekezie]

Description

The project is named SentientFi and prominently features Reflector oracle integration as a core feature (README, architecture diagrams, smart contract code), but the ReflectorService class in backend/src/services/reflector.ts exclusively fetches prices from CoinGecko. No call to the Stellar Reflector oracle contract is made anywhere in the backend. The service name is misleading and the feature is not implemented.

Evidence

README claims Reflector integration

The README lists as a key feature:

"Reflector oracle integration for accurate on-chain price feeds"

Smart contract implements Reflector correctly

contracts/src/reflector.rs defines a proper ReflectorClient:

mod reflector_interface {
    use soroban_sdk::{contractclient, Env, Symbol};

    #[contractclient(name = "ReflectorClient")]
    pub trait ReflectorInterface {
        fn lastprice(env: Env, asset: soroban_sdk::Symbol) -> Option<PriceData>;
    }
}

contracts/src/lib.rs line 125 calls it during execute_rebalance:

let price_data = ReflectorClient::new(&env, &reflector_address)
    .lastprice(&asset_symbol);

Backend ReflectorService only uses CoinGecko

backend/src/services/reflector.ts:

// Line 1: unused import
import SorobanRpc from '@stellar/stellar-sdk/rpc'  // ← Imported but never used

// Line 105: actual price fetch
const url = `https://api.coingecko.com/api/v3/simple/price?ids=${coinIds.join(',')}&vs_currencies=usd&include_24hr_change=true`
const response = await fetch(url, { ... })

There is no code path in the backend that ever calls a Soroban RPC endpoint to query the Reflector contract. The SorobanRpc import on line 1 being unused confirms this is a placeholder that was never implemented.

Fallback prices are hardcoded (not from cache)

When CoinGecko fails, the backend falls back to:

const fallbackPrices = {
    XLM: { price: 0.358878, ... },
    BTC: { price: 111150, ... },
    ETH: { price: 4384.56, ... },
    USDC: { price: 0.999781, ... },
}

These are hardcoded values, not a recent snapshot from Reflector.

Impact

1. Single point of failure: All price data depends entirely on CoinGecko. If CoinGecko rate-limits the API key (or if the free tier is used), price data goes stale immediately
2. Incorrect documentation: Users and auditors expect on-chain price feeds from the advertised Reflector integration
3. Smart contract / backend mismatch: The contract uses on-chain Reflector prices for rebalancing decisions; the backend uses CoinGecko prices for drift detection. The two systems may use different prices for the same asset at the same moment, causing incorrect rebalancing triggers

Proposed Fix

Implement the Reflector oracle backend integration:

// backend/src/services/reflector.ts

import SorobanRpc from '@stellar/stellar-sdk/rpc'
import { Contract, scValToNative, xdr } from '@stellar/stellar-sdk'

const REFLECTOR_CONTRACT_ID = process.env.REFLECTOR_CONTRACT_ID!
const SOROBAN_RPC_URL = process.env.SOROBAN_RPC_URL || 'https://soroban-testnet.stellar.org'

async function fetchPriceFromReflector(asset: string): Promise<number | null> {
    const rpc = new SorobanRpc.Server(SOROBAN_RPC_URL)
    const contract = new Contract(REFLECTOR_CONTRACT_ID)

    try {
        const result = await rpc.simulateTransaction(
            contract.call('lastprice', /* asset Symbol */)
        )
        if (SorobanRpc.Api.isSimulationSuccess(result)) {
            const priceData = scValToNative(result.result!.retval)
            return priceData?.price ?? null
        }
    } catch (err) {
        logger.warn(`[Reflector] Price fetch failed for ${asset}:`, err)
    }
    return null
}

Then use Reflector as primary source and CoinGecko as fallback:

Price request → Reflector contract (on-chain) → CoinGecko fallback → hardcoded fallback

Add to .env.example:

REFLECTOR_CONTRACT_ID=CDOR33VMS...
SOROBAN_RPC_URL=https://soroban-testnet.stellar.org

Files Affected

• backend/src/services/reflector.ts — implement Reflector calls
• backend/.env.example — add REFLECTOR_CONTRACT_ID, SOROBAN_RPC_URL
• README.md — clarify current status (CoinGecko only) until fix is merged

[LawalRahman]

Hi,

I’m a full-stack and blockchain developer with experience building fintech and payment-focused applications. I work across frontend, backend, APIs, and smart contract integrations with a strong focus on turning ideas into working products quickly.

For this issue, I’d focus on delivering a simple but well-structured solution that demonstrates clear Stellar utility rather than unnecessary complexity. My priority would be reliability, clean architecture, secure implementation, and an MVP that can realistically evolve beyond the hackathon.

I’m ready to begin immediately and ship iteratively with clear progress updates.

[Marvy247]

I've reviewed the issue description, and I'm confident I can implement all the requested details smoothly.​Please assign this issue to me! I can have a PR ready for review in a few hours. Thank You.

[balisdev]

Hi Team,

I noticed that while SentientFi’s smart contracts cleanly interact with the Reflector oracle (lastprice), the backend ReflectorService relies solely on external REST calls to CoinGecko and hardcoded fallback integers. This structural mismatch can cause drift detection discrepancies between off-chain tracking and on-chain trade execution boundaries.

Why I'm a Good Fit
Stellar/Soroban RPC Architecture: I have extensive experience working with @stellar/stellar-sdk, spinning up SorobanRpc.Server connections, and decoding intricate contract-returned XDR components back into clean native JavaScript data structures.

Resilient Data Pipelines: I understand how to organize failover mechanisms securely—ensuring that primary queries utilize authoritative on-chain data (Reflector), while routing to CoinGecko exclusively as an auxiliary fallback layer.

Fixing Architectural Drifts: I am comfortable working with across-the-stack environments, mapping configuration parameters cleanly via .env arrays, and keeping source-truth codebase modules perfectly synchronized with open documentation profiles.

My Execution Plan
Configure Environment Vectors: Populate REFLECTOR_CONTRACT_ID and SOROBAN_RPC_URL within the .env.example configurations.

Build the On-Chain RPC Fetcher: Implement a robust fetchPriceFromReflector execution loop using simulation parameters or live lookups via @stellar/stellar-sdk/rpc.

Assemble the Failover Hierarchy: Refactor reflector.ts to implement the requested priority resolution layer: Reflector (Primary) ➔ CoinGecko (Secondary Fallback) ➔ Hardcoded Constants (Last Resort).

Please assign this issue to me, and I’ll restore true on-chain price accuracy to the SentientFi backend!

[grantfox-oss]

🦊 GrantFox — @balisdev has been assigned to this issue as part of the Official Campaign campaign!

Next steps:

1. Open a Pull Request referencing this issue (e.g., Closes #8)
2. Your PR will be reviewed by the grantFoxin maintainers

Good luck! Track your progress on GrantFox.

[grantfox-oss]

🎉 This issue has been marked as completed on GrantFox as part of the Official Campaign campaign!

@balisdev's PR #26 was approved and merged by @Uchechukwu-Ekezie.

🏆 @balisdev: You earned 35 FoxPoints for this contribution! Your current tier: Explorer (366 total points). Track your full progress on GrantFox.

👏 Great work, @balisdev! Keep contributing to grantFoxin.