# WINkLink Price Feed Service
Before integrating, see Developer Notes.
# Overview
# WINkLink Price Feed Service Introduction
To ensure that smart contracts reflect token prices in real-world time, it is necessary to frequently update them. In particular, the prices of assets in DeFi must closely match those of the real world. Otherwise, arbitrage or contract attacks may cause losses for users and developers.
WINkLink's price service focuses on digital currency pairs, providing decentralized applications (DApps) with accurate and stable price information on real-world digital currencies. The solution offered by WINkLink aggregates price data from multiple oracle nodes, resulting in a stable price service known as the Price Feed Contract.
The contract above is called an Aggregator — the on-chain contract that holds aggregated price data from WINkLink oracle nodes. Each price feed (e.g., BTC/USD) is implemented as an Aggregator contract that consumer contracts read from.
# Supported Price Pairs List & Configurations
# Mainnet
# Nile Testnet
- WIN Token Contract Address:
TNDSHKGBmgRx9mDYA9CnxPx55nu672yQw2 - WinkMid Contract Address:
TLDU7C8K3Gd3pXrAj9gtpVVNRHZHuHHZ8P
List of price service contract addresses:
# Apply for New Trading Pairs
To request for new trading pair to be added to WINkLink officially, please fill in and submit this form. (opens new window)
# How to use existing WINkLink Price Feed
# Acquire latest price
The following example demonstrates how to read a WINkLink price feed via AggregatorV3Interface: fetch the latest price with latestRoundData(), validate freshness against the heartbeat, and query decimals() for proper precision handling.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
/**
* @title AggregatorV3Interface (WINkLink Price Feed)
* @notice Interface for reading WINkLink price feeds.
*/
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function getRoundData(uint80 _roundId)
external view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
/**
* THIS IS AN EXAMPLE CONTRACT THAT USES UN-AUDITED CODE.
* DO NOT USE THIS CODE IN PRODUCTION.
*/
contract PriceConsumer {
AggregatorV3Interface internal priceFeed;
uint256 public constant MAX_PRICE_AGE = 1 hours; // Adjust to your business tolerance
/**
* Network: TRON Mainnet / Nile Testnet
* Pass the feed address for the price pair you want to read.
* Find supported pairs and addresses in the Price Feed Service documentation.
*/
constructor(address feedAddress) {
priceFeed = AggregatorV3Interface(feedAddress);
}
/// @notice Returns the latest price together with its decimals.
/// @dev Reverts if the round is incomplete or the price is stale.
function getLatestPrice() public view returns (int256 answer, uint8 decimals) {
uint256 updatedAt;
(
/* uint80 roundId */,
answer,
/* uint256 startedAt */,
updatedAt,
/* uint80 answeredInRound */
) = priceFeed.latestRoundData();
require(updatedAt > 0, "Round not complete");
require(block.timestamp - updatedAt <= MAX_PRICE_AGE, "Price too stale");
decimals = priceFeed.decimals();
}
}
If you only need the price off-chain (e.g., in a frontend, backend, or script), you do not need to deploy any contract — read the proxy directly with TronWeb:
// Off-chain read with TronWeb — no contract deployment required.
// npm install tronweb
const { TronWeb } = require('tronweb');
// Mainnet: https://api.trongrid.io | Nile testnet: https://nile.trongrid.io
// For production, use a free TronGrid API key to avoid rate limits:
// new TronWeb({ fullHost: 'https://api.trongrid.io', headers: { 'TRON-PRO-API-KEY': 'your-key' } })
const tronWeb = new TronWeb({ fullHost: 'https://api.trongrid.io' });
// A constant (read-only) call still needs a from-address set; any valid address works:
tronWeb.setAddress('T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb');
// Proxy address of the price pair you want to read (see Supported Price Pairs List).
const FEED_ADDRESS = 'TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX';
async function getLatestPrice() {
const feed = await tronWeb.contract().at(FEED_ADDRESS);
const data = await feed.latestRoundData().call();
const decimals = await feed.decimals().call();
// Normalize the price as answer / 10 ** decimals
console.log('answer:', data.answer.toString());
console.log('updatedAt:', data.updatedAt.toString());
console.log('decimals:', decimals.toString());
}
getLatestPrice();
Or with tronpy (Python):
# Off-chain read with tronpy — no contract deployment required.
# pip install tronpy
from tronpy import Tron
# Mainnet: Tron() | Nile testnet: Tron(network='nile')
# For production, use a free TronGrid API key to avoid rate limits:
# from tronpy.providers import HTTPProvider
# client = Tron(HTTPProvider(api_key='your-key'))
client = Tron()
# Proxy address of the price pair you want to read (see Supported Price Pairs List).
FEED_ADDRESS = 'TXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
feed = client.get_contract(FEED_ADDRESS)
round_id, answer, started_at, updated_at, answered_in_round = feed.functions.latestRoundData()
decimals = feed.functions.decimals()
# Normalize the price as answer / 10 ** decimals
print('answer:', answer)
print('updatedAt:', updated_at)
print('decimals:', decimals)
# Acquire Price History
Round / RoundId — Each time the price is updated, a new Round is created and uniquely identified by a RoundId (uint80). Historical prices for any past round can be queried via getRoundData(roundId).
The following code demonstrates how to read a historical price by roundId via getRoundData().
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
/**
* DO NOT USE THIS CODE IN PRODUCTION.
*
* Continued from the AggregatorV3Interface defined above.
*/
contract HistoricalPriceConsumer {
AggregatorV3Interface internal priceFeed;
constructor(address feedAddress) {
priceFeed = AggregatorV3Interface(feedAddress);
}
/// @notice Returns the historical price for a specific roundId.
/// @param _roundId The round to query (must be a valid completed round).
function getHistoricalPrice(uint80 _roundId)
public view
returns (int256 answer, uint256 updatedAt)
{
(
/* uint80 roundId */,
answer,
/* uint256 startedAt */,
updatedAt,
/* uint80 answeredInRound */
) = priceFeed.getRoundData(_roundId);
require(updatedAt > 0, "Round not complete");
}
}
# How to setup Price Feed contracts
# Contract Deployment
Employing a decentralized structure, WINkLink features open-source smart contracts and allows any organization or individual to deploy their WINkLink oracle contracts and release these services to the public.
Users may pick their sets from all the open services available on WINkLink to create their own aggregated data contracts and benefit from decentralization.
Contracts for the project is hosted at: https://github.com/tron-oracle/winklink-libocr/tree/main/tvm-contracts (opens new window) - Connect your Github account
You may use any of the following tools or libraries for contract deployment and call testing:
- TronScan: Mainnet (opens new window), Nile Testnet (opens new window)
- Official wallet-cli (opens new window)
- Tron IDE (opens new window)
- TronBox (opens new window)
- tronweb (opens new window)
# Aggregator Contract
Aggregator contract is deployed on the TRON public chain with the following features:
- Accepts transmission from WINkLink node's off-chain aggregation
- Calculate the WIN fee on data requests and allow Oracle nodes to claim rewards
- Implements the Owned interface. This provides access control on different methods of exposed by the aggregator contract.
Contract code is available at AccessControlledOCRAggregator.sol.
# Add a Job to Your Node
The job of your node represents the data service that your node supports, and each job has a unique 32-byte ID. For end users, (Oracle address, job ID) uniquely identifies the data service provided by a WINkLink node. Each WINkLink node can provide multiple data services.
When your WINkLink node is running properly, you can add a job to your node via Operator UI:
Example: (change the parameters below to the Oracle contract address deployed in the steps above)
TIP
For bootstrap node, set the DefaultBootstrapPeers in the config file as well.
Example: DefaultBootstrapPeers = ['/ip4/127.0.0.1/tcp/6788/p2p/12D3KooWMrKGdnH6nBrf7hDz25NXFSFNk7vgsTxj9bHskWEct4xh']
# Bootstrap node
type = "offchainreporting"
schemaVersion = 1
tvmChainID = 1
name = "TUSD-TRX"
contractAddress = "ACCESS-CONTROLLED-OCR-AGGREGATOR-ADDRESS"
p2pBootstrapPeers = [
"/ip4/127.0.0.1/tcp/6788/p2p/P2P-PEER-ID",
]
isBootstrapPeer = true
keyBundleID = "NODE-KEY-BUNDLE"
forwardingAllowed = false
maxTaskDuration = "0s"
TIP
Ensure that the bootstrap node and the oracle node are configured as individual entities, each linking to its unique database instance. When operating locally, modify the config.toml file to designate different port numbers for each instance, facilitating access to the distinct Operator UIs for each.
[WebServer]
HTTPPort = 3000
SecureCookies = false # Default
# Oracle node
type = "offchainreporting"
schemaVersion = 1
tvmChainID = 2
name = "OCR: TUSD-TRX"
contractAddress = "ACCESS-CONTROLLED-OCR-AGGREGATOR-ADDRESS"
p2pBootstrapPeers = [
"/ip4/127.0.0.1/tcp/6788/p2p/P2P-PEER-ID",
]
isBootstrapPeer = false
keyBundleID = "NODE-KEY-BUNDLE"
transmitterAddress = "THE-CURRENT-NODE-EIP55-ADDRESS"
observationTimeout = "10s"
blockchainTimeout = "20s"
contractConfigTrackerSubscribeInterval = "2m"
contractConfigTrackerPollInterval = "1m"
contractConfigConfirmations = 3
observationSource = """
ds_http [type="http" method=GET url="https://www.okx.com/api/v5/market/index-tickers?instId=TUSD-USD"]
ds_parse [type="jsonparse" path="data,0,idxPx"]
ds_converttrx [type="converttrx" url="https://www.okx.com/api/v5/market/index-tickers?instId=TRX-USD" path="data.0.idxPx"]
ds_multiply [type="multiply" times=1000000]
ds_http -> ds_parse -> ds_converttrx -> ds_multiply
"""
# Query Jobs
Jobs can be retrieved under the jobs tab in Operator UI.
The sub-tabs are as follows:
- Overview: list of recent job runs and task flow
- Definition: job specification
- Errors: cumulative count of different errors encountered since job creation
- Runs: list of all job runs
# API Reference
When you use WINkLink price feeds, retrieve the feeds through the AggregatorV3Interface and the proxy address. Optionally, you can call variables and functions in the AccessControlledOffchainAggregator contract to get information about the aggregator behind the proxy.
The proxy exposes a stable address whose underlying aggregator can be upgraded without affecting your integration.
# AggregatorV3Interface
Import this interface to your contract and use it to run functions in the proxy contract. Create the interface object by pointing to the proxy address (find supported pairs and their proxy addresses in the Supported Price Pairs List above). For example:
/**
* Network: TRON Mainnet / Nile Testnet
* Pass the proxy address of the price pair you want to read.
*/
constructor(address feedAddress) {
priceFeed = AggregatorV3Interface(feedAddress);
}
To see examples for how to use this interface, see the "Acquire latest price" section above.
| Name | Description |
|---|---|
| decimals | The number of decimals in the response. |
| description | The description of the aggregator that the proxy points to. |
| getRoundData | Get data from a specific round. |
| latestRoundData | Get data from the latest round. |
| version | The version representing the type of aggregator the proxy points to. |
decimals
Get the number of decimals present in the response value.
function decimals() external view returns (uint8);
RETURN: The number of decimals.
description
Get the description of the underlying aggregator that the proxy points to.
function description() external view returns (string memory);
RETURN: The description of the underlying aggregator.
getRoundData
Get data about a specific round, using the roundId.
function getRoundData(
uint80 _roundId
) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
Parameters:
_roundId: The round ID
Return values:
roundId: The round IDanswer: The answer for this roundstartedAt: Timestamp of when the round startedupdatedAt: Timestamp of when the round was updatedansweredInRound: Deprecated — previously used when answers could take multiple rounds to be computed. On WINkLink feeds it is always equal toroundId.
latestRoundData
Get the data from the latest round.
function latestRoundData()
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
Return values:
roundId: The round ID.answer: The price that this feed provides for the configured pair.startedAt: Timestamp of when the round started.updatedAt: Timestamp of when the round was updated. Validate this against the feed's heartbeat to check freshness.answeredInRound: Deprecated — previously used when answers could take multiple rounds to be computed. On WINkLink feeds it is always equal toroundId.
Notes for WINkLink OCR feeds: each report writes both
startedAtandupdatedAtto the block timestamp of that report, so the two values are identical. The proxy encodes a phase in the high bits ofroundId(phaseId << 64 | aggregatorRoundId); as a result round IDs are not contiguous from1and increase across aggregator upgrades. Pass the phase-encodedroundId(e.g. the one returned bylatestRoundData()) when callinggetRoundData().
version
The version representing the type of aggregator the proxy points to.
function version() external view returns (uint256);
RETURN: The version number. WINkLink price feeds currently return4.
# AccessControlledOffchainAggregator
This is the contract for the aggregator. You can call functions on the aggregator directly, but it is a best practice to use the AggregatorV3Interface to run functions on the proxy instead so that changes to the aggregator do not affect your application. Read the aggregator contract only if you need functions that are not available in the proxy.
The aggregator contract has several variables and functions that might be useful for your application. Although aggregator contracts are similar for each data feed, some aggregators have different variables. Use the typeAndVersion() function on the aggregator to identify what type of aggregator it is and what version it is running.
Always check the contract source code and configuration to understand how specific data feeds operate. A reference WINkLink aggregator contract: TU5dpGzXAZwrpFfCrFzDBPWNxPm4diREqu (opens new window) on TronScan.
This contract imports OffchainAggregator and SimpleReadAccessController, which also include their own imports. The variables and functions lists include the publicly accessible items from these imported contracts.
A simple way to read the variables or functions is to get the ABI from a blockchain explorer (TronScan) and point the ABI to the aggregator address.
Variables:
| Name | Description |
|---|---|
| checkEnabled | A boolean that indicates if access is limited to addresses on the internal access list. |
| maxAnswer | The upper bound on the answer the aggregator is allowed to report. A report whose median is above this value is rejected. |
| minAnswer | The lower bound on the answer the aggregator is allowed to report. A report whose median is below this value is rejected. |
| owner | The address that owns this aggregator contract. This controls which address can execute specific functions. |
Functions:
| Name | Description |
|---|---|
| billingAccessController | The address for the billingAccessController, which limits access to the billing configuration for the aggregator. |
| decimals | Return the number of digits of precision for the stored answer. Answers are stored in fixed-point format. |
| description | Return a description for this data feed. This is different depending on which feed you select. |
| getAnswer | Deprecated — Do not use this function. |
| getBilling | Retrieve the current billing configuration. |
| getRoundData | Get the full information for a specific aggregator round including the answer and update timestamps. |
| getTimestamp | Deprecated — Do not use this function. |
| getWinToken | Get the address of the WIN token contract used to pay oracles. |
| hasAccess | Check if an address has internal access. |
| latestAnswer | Return the latest answer for this data feed. No timestamp is included to check data freshness. |
| latestConfigDetails | Return information about the current offchain reporting protocol configuration. |
| latestRound | Deprecated — Do not use this function. |
| latestRoundData | Get the full information for the most recent round including the answer and update timestamps. |
| latestTimestamp | Deprecated — Do not use this function. |
| latestTransmissionDetails | Get information about the most recent answer. |
| oracleObservationCount | Returns the number of observations that oracle is due to be reimbursed for. |
| owedPayment | Returns how much WIN an oracle is owed for its observations. |
| requesterAccessController | Returns the address for the requester access controller contract. |
| transmitters | The oracle addresses that can report answers to this aggregator. |
| typeAndVersion | Returns the aggregator type and version. The version is for the type of aggregator, and different from the contract version. |
| validatorConfig | Returns the address and the gas limit for the validator contract. |
| version | Returns the contract version. This is different from the typeAndVersion for the aggregator. |
| winAvailableForPayment | Get the amount of WIN on this contract that is available to make payments to oracles. This value can be negative if there are outstanding payment obligations. |
billingAccessController
The address for the billingAccessController, which limits access to the billing configuration for the aggregator.
function billingAccessController() external view returns (AccessControllerInterface) {
return s_billingAccessController;
}
decimals
Return the number of digits of precision for the stored answer. Answers are stored in fixed-point format.
function decimals() external view returns (uint8 decimalPlaces);
description
Return a description for this data feed. Usually this is an asset pair for a price feed.
function description() public view override checkAccess() returns (string memory) {
return super.description();
}
getAnswer
Deprecated — do not use this function. Use
getRoundData()instead.
getBilling
Retrieve the current billing configuration. On TRON, the first three fields (maximumGasPrice, reasonableGasPrice, microWinPerTrx) are not used and are set to 0.
function getBilling()
external
view
returns (
uint32 maximumGasPrice,
uint32 reasonableGasPrice,
uint32 microWinPerTrx,
uint32 winPerObservation,
uint32 winPerTransmission
)
{
Billing memory billing = s_billing;
return (
billing.maximumGasPrice,
billing.reasonableGasPrice,
billing.microWinPerTrx,
billing.winPerObservation,
billing.winPerTransmission
);
}
getRoundData
Get the full information for a specific aggregator round including the answer and update timestamps. Use this to get the full historical data for a round.
function getRoundData(uint80 _roundId)
public
view
override
checkAccess()
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
{
return super.getRoundData(_roundId);
}
getTimestamp
Deprecated — do not use this function. Use
getRoundData()instead.
getWinToken
Get the address of the WIN token contract used to pay oracles.
function getWinToken() external view returns (WinTokenInterface winToken) {
return s_winToken;
}
hasAccess
Check if an address has internal access.
function hasAccess(address _user, bytes memory _calldata) public view virtual override returns (bool) {
return super.hasAccess(_user, _calldata) || _user == tx.origin;
}
latestAnswer
Return the latest answer for this data feed. No timestamp is included to check data freshness. Returns 0 if no writes have occurred. latestRoundData includes the latest answer and timestamps for checking data freshness.
latestConfigDetails
Return information about the current offchain reporting protocol configuration.
function latestConfigDetails() external view returns (uint32 configCount, uint32 blockNumber, bytes16 configDigest) {
return (s_configCount, s_latestConfigBlockNumber, s_hotVars.latestConfigDigest);
}
latestRound
Deprecated — do not use this function. Use
latestRoundData()instead.
latestRoundData
Get the full information for the most recent round including the answer and update timestamps.
function latestRoundData()
public
view
override
checkAccess()
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
{
return super.latestRoundData();
}
latestTimestamp
Deprecated — do not use this function. Use
latestRoundData()instead.
latestTransmissionDetails
Get information about the most recent answer. Callable only by an externally owned account (EOA).
function latestTransmissionDetails()
external
view
returns (bytes16 configDigest, uint32 epoch, uint8 round, int256 latestAnswer, uint64 latestTimestamp)
{
require(msg.sender == tx.origin, "Only callable by EOA");
return (
s_hotVars.latestConfigDigest,
uint32(s_hotVars.latestEpochAndRound >> 8),
uint8(s_hotVars.latestEpochAndRound),
s_transmissions[s_hotVars.latestAggregatorRoundId].answer,
s_transmissions[s_hotVars.latestAggregatorRoundId].timestamp
);
}
oracleObservationCount
Returns the number of observations that oracle is due to be reimbursed for.
function oracleObservationCount(address _signerOrTransmitter) external view returns (uint16) {
Oracle memory oracle = s_oracles[_signerOrTransmitter];
if (oracle.role == Role.Unset) {
return 0;
}
return s_oracleObservationsCounts[oracle.index] - 1;
}
owedPayment
Returns how much WIN an oracle is owed for its observations.
function owedPayment(address _transmitter) public view returns (uint256) {
Oracle memory oracle = s_oracles[_transmitter];
if (oracle.role == Role.Unset) {
return 0;
}
Billing memory billing = s_billing;
uint256 winAmount = uint256(s_oracleObservationsCounts[oracle.index] - 1) * uint256(billing.winPerObservation);
winAmount += s_gasReimbursementsWin[oracle.index] - 1;
return winAmount;
}
requesterAccessController
Returns the address for the requester access controller contract.
function requesterAccessController() external view returns (AccessControllerInterface) {
return s_requesterAccessController;
}
transmitters
The oracle addresses that can report answers to this aggregator.
function transmitters() external view returns (address[] memory) {
return s_transmitters;
}
typeAndVersion
Returns the aggregator type and version. The version is for the type of aggregator, and different from the contract version.
function typeAndVersion() external pure virtual override returns (string memory) {
return "AccessControlledOffchainAggregator 4.0.0";
}
validatorConfig
Returns the address and the gas limit for the validator contract.
function validatorConfig() external view returns (AggregatorValidatorInterface validator, uint32 gasLimit) {
ValidatorConfig memory vc = s_validatorConfig;
return (vc.validator, vc.gasLimit);
}
version
Returns the contract version. This is different from the typeAndVersion for the aggregator.
function version() external view returns (uint256);
winAvailableForPayment
Get the amount of WIN on this contract that is available to make payments to oracles. This value can be negative if there are outstanding payment obligations.
function winAvailableForPayment() external view returns (int256 availableBalance) {
int256 balance = int256(s_winToken.balanceOf(address(this)));
int256 due = int256(totalWINDue());
return int256(balance) - int256(due);
}
# Developer Notes
WINkLink price feeds provide reliable on-chain price data through a decentralized network of 7 independent oracle nodes. The performance of feeds in your DApp depends on both external market conditions and the integration code you write. When integrating WINkLink price feeds, please be mindful of two areas: market integrity and application code.
# Market Integrity
WINkLink price feeds reflect real-world market conditions and are subject to the external market environment. When integrating, understand the market characteristics of the asset you read, and account for extreme scenarios in your application logic.
The external market environment affects feeds in the following ways:
- The market structure of the underlying asset (exchange distribution, depth, liquidity, etc.) affects price stability.
- Assets with lower liquidity are more sensitive to changes in the external market environment.
- Under extreme market scenarios (sharp volatility, sudden drops in liquidity, market disruptions), feed update behavior may diverge from normal patterns.
We recommend designing your application logic to handle extreme market scenarios, and continuously observing feed behavior after going live.
# Application Code
Application code quality, reliability, and dependency management directly affect how robustly your DApp consumes price data.
Validate price freshness
Each WINkLink price feed has a heartbeat — an interval within which the on-chain price is guaranteed to be updated. We recommend validating the timestamp before using a price:
(uint80 roundId, int256 answer, , uint256 updatedAt, ) = priceFeed.latestRoundData();
require(updatedAt > 0, "Round not complete");
require(block.timestamp - updatedAt <= MAX_PRICE_AGE, "Price too stale");
MAX_PRICE_AGE should be larger than the heartbeat of the price pair you are reading. Choose the value based on your business tolerance.
Understand decimals
The precision (decimal places) of WINkLink price feeds may differ between pairs. Always call decimals() before performing any price calculation:
uint8 dec = priceFeed.decimals();
// Normalize the price using dec in your calculation
Do not hard-code a precision value.
Keep your contract upgradeable
Avoid hard-coding feed contract addresses deep into immutable business logic. Store them in variables that can be updated by a contract owner or governance, so you can migrate to a replacement feed if WINkLink upgrades or deprecates the underlying aggregator.
Test on Nile first
Before deploying your consumer contract to mainnet, run full integration testing on the Nile testnet against WINkLink's Nile feed addresses:
- Nile testnet feed addresses: see Nile Testnet
- Get testnet TRX — used to deploy and call your own contract — from the Nile testnet faucet (opens new window)
Watch for WINkLink updates
WINkLink publishes price feed–related updates through two channels. We recommend integrators monitor content relevant to their applications:
- Official announcement channel (opens new window): matters such as feed deprecation notices and new feed launches.
- WINkLink price feed detail page (opens new window): real-time configuration parameters (e.g., heartbeat, deviation threshold) for each feed. Parameter changes are reflected here.
Before integration, record the baseline configuration parameters of the feeds you use, so you can periodically compare them after launch and detect parameter changes promptly.
Monitor in production
After integration, we recommend monitoring the following signals:
- Whether
latestRoundData()is updated on schedule (heartbeat behavior is normal) - Whether stale check or related validation events are triggered in your contract
- The frequency and distribution of the above
You can implement this through TRON block explorer event subscriptions or your own off-chain monitoring scripts.