Price Feed Service

Overview

The Price Feed Service provides reliable, tamper-resistant price data for cryptocurrencies, traditional assets, and other financial instruments on the Neo N3 blockchain. This service enables DeFi applications to access accurate price information for critical operations such as lending, trading, and collateralization.

Key Features

Real-time price data for a wide range of assets
Multiple price data sources for increased reliability
Aggregation mechanisms to prevent manipulation
Configurable update frequency
On-chain verification of price data
Historical price data access
Low-latency data delivery
Support for custom price pairs

Supported Assets

The Price Feed Service supports a wide range of asset pairs, including:

Cryptocurrencies

NEO/USD
GAS/USD
BTC/USD
ETH/USD
NEO/BTC
NEO/ETH
And many other popular trading pairs

Fiat Currencies

USD/EUR
USD/JPY
USD/GBP
And other major forex pairs

Commodities

XAU/USD (Gold)
XAG/USD (Silver)
And other major commodities

For a complete list of supported assets, check the Price Feed API documentation.

How It Works

The Price Feed Service follows a rigorous process to ensure accuracy and reliability:

Data Collection: Price data is collected from multiple reputable sources including major exchanges, data providers, and aggregators.
Data Validation: Each data point is validated for accuracy, timeliness, and reliability.
Aggregation: Multiple price points are aggregated using a volume-weighted median algorithm to filter out outliers and prevent manipulation.
TEE Processing: Data processing occurs in a Trusted Execution Environment (TEE) to ensure integrity.
On-chain Publication: The validated price data is published to on-chain contracts where it can be accessed by other smart contracts.
Verification: Each price update includes verification data that confirms its source and processing integrity.

Data Quality Assurance

Our Price Feed Service implements several mechanisms to ensure data quality:

Minimum number of data points required for each update
Maximum deviation thresholds to detect unusual price movements
Heartbeat updates to ensure data freshness even when prices are stable
Source credibility scoring to weight more reliable sources higher

Accessing Price Data

Price data can be accessed in several ways:

On-chain Access

Smart contracts can directly read price data from the Price Feed contracts:

// Example of how a Neo N3 smart contract would access price data
// This is pseudocode for illustration purposes

public static object GetNeoPrice()
{
    // Get the Price Feed contract
    UInt160 priceFeedContract = "0xe8f984de846c9a6a32c78755b95eb918acd7b2a4".ToScriptHash();
    
    // Call the getPrice method with the asset pair
    object[] args = new object[] { "NEO/USD" };
    var result = (BigInteger)Contract.Call(priceFeedContract, "getPrice", CallFlags.ReadOnly, args);
    
    // Price is returned as an integer with 8 decimal places
    // e.g., 1234567890 represents $12.34567890
    return result;
}

// Example of getting the last update timestamp
public static object GetLastUpdateTime()
{
    UInt160 priceFeedContract = "0xe8f984de846c9a6a32c78755b95eb918acd7b2a4".ToScriptHash();
    
    object[] args = new object[] { "NEO/USD" };
    var result = (BigInteger)Contract.Call(priceFeedContract, "getLastUpdateTime", CallFlags.ReadOnly, args);
    
    // Returns a timestamp in Unix epoch format
    return result;
}

API Access

For off-chain applications, price data can be accessed through the REST API:

Request

GET https://api.neo-service-layer.com/v1/price-feed/pairs/NEO-USD

Response

{
  "pair": "NEO-USD",
  "price": "12.34567890",
  "decimals": 8,
  "lastUpdateTime": 1679523600,
  "sources": ["binance", "huobi", "okx", "gate"],
  "confidence": 0.98,
  "deviation": 0.0025
}

JavaScript Functions

You can also access price data from within JavaScript functions:

async function main(args) {
  // Get current NEO price
  const neoPrice = neo.getPrice("NEO/USD");
  
  // Get historical NEO price
  const historicalPrice = neo.getHistoricalPrice({
    pair: "NEO/USD",
    timestamp: new Date("2023-03-15").getTime() / 1000
  });
  
  // Get multiple prices at once
  const prices = await neo.getPrices(["NEO/USD", "GAS/USD", "BTC/USD"]);
  
  return {
    currentNeoPrice: neoPrice,
    historicalNeoPrice: historicalPrice,
    allPrices: prices,
    timestamp: new Date().toISOString()
  };
}

Use Cases

DeFi Applications

Lending Protocols: Determine collateralization ratios and liquidation thresholds
DEXs: Provide reference prices for trading
Derivatives: Create price-based financial instruments
Stablecoins: Maintain pegs to fiat currencies

Smart Contracts

Escrow Services: Release funds based on market conditions
Parametric Insurance: Trigger payouts based on price thresholds
Decentralized Options: Settle contracts at expiration

Business Logic

Treasury Management: Automate portfolio rebalancing
Risk Assessment: Monitor asset volatility
Financial Reporting: Calculate asset values in fiat terms

Technical Example: Liquidation Protection System

The following example demonstrates a function that monitors a collateralized position and takes protective action if it approaches liquidation:

async function main(args) {
  const { address, loanId, warningThreshold, actionThreshold } = args;
  
  // Get loan details (simulated contract call)
  const loanContract = "0x8c34578c30b7e1d148c6c5f2ddb75c812e6f1991";
  const loan = neo.call({
    scriptHash: loanContract,
    operation: "getLoan",
    args: [loanId]
  });
  
  // Get current NEO price
  const neoPrice = neo.getPrice("NEO/USD");
  
  // Calculate current collateral ratio
  const collateralValueUSD = loan.collateralAmount * neoPrice;
  const loanValueUSD = loan.loanAmount;
  const collateralRatio = collateralValueUSD / loanValueUSD;
  
  // Determine if action is needed
  let actionTaken = false;
  let actionType = null;
  
  if (collateralRatio <= actionThreshold) {
    // Execute protective action by adding collateral or partially repaying the loan
    actionType = "protective_action";
    
    // In a real implementation, this would call a contract to add collateral
    // or repay part of the loan to increase the collateral ratio
    
    actionTaken = true;
  } else if (collateralRatio <= warningThreshold) {
    // Send a warning notification
    actionType = "warning";
    
    // In a real implementation, this might trigger a notification
    // through an external system
    
    actionTaken = true;
  }
  
  return {
    address,
    loanId,
    currentPrice: neoPrice,
    collateralAmount: loan.collateralAmount,
    loanAmount: loan.loanValueUSD,
    collateralRatio,
    warningThreshold,
    actionThreshold,
    actionTaken,
    actionType,
    timestamp: new Date().toISOString()
  };
}

Service Guarantees

Update Frequency: Price data is updated at least every 60 seconds for major assets
Deviation Triggers: Price updates are also triggered when prices move beyond a threshold (e.g., 0.5%)
Heartbeat Updates: Even when prices are stable, updates occur to confirm data freshness
Data Availability: 99.9% uptime for price feed services
Historical Data: Access to price history for at least 90 days

API Reference

For a complete API reference, see the Price Feed API documentation.