Skip to main content
Answers to the questions developers and protocol teams ask most often. If your question is not covered here, reach out via any support channel.

General

IFÁ Labs is a decentralized, multi-chain oracle network that delivers trustless, manipulation-resistant price feeds for stablecoins — directly on-chain, with no off-chain dependencies for price reads.Unlike general-purpose oracles built around volatile assets like BTC and ETH, IFÁ Labs is purpose-built for stablecoins — including both global assets (USDT, USDC) and emerging market local stablecoins (cNGN in Nigeria, ZARP in South Africa, BRZ in Brazil).See What is IFÁ Labs? for the full overview.
Yes. On EVM chains, all price data is stored in audited smart contracts and is readable via public view functions. On Sui, prices are stored in a shared IfaPriceFeed object and are readable by any Move module or TypeScript client.In both cases there is no off-chain API, no middleware, and no centralized component in the read path. Price reads cost no gas when called externally. Any address can read any feed at any time without permission, API keys, or fees.
Currently live:
  • Base Mainnet — primary production deployment (EVM)
  • Base Sepolia — recommended EVM testnet
  • AssetChain Testnet — RWA-focused EVM ecosystem
  • Sui Testnet — native Move deployment on Sui
Planned: Sui Mainnet, AssetChain Mainnet, Solana, Optimism, Arbitrum, Polygon zkEVM, and additional EVM L2s based on ecosystem demand.See Supported Chains & Roadmap for full details and timelines.
Currently supported:
AssetSymbolCategory
TetherUSDT/USDGlobal
USD CoinUSDC/USDGlobal
Nigerian Naira StablecoinCNGN/USDEmerging Market
South African Rand StablecoinZARP/USDEmerging Market
Brazilian Real StablecoinBRZ/USDEmerging Market
EthereumETH/USDReference Asset
All feeds are available across every supported network — EVM and Sui. New assets are added on a rolling basis. See Supported Assets for the complete list including asset IDs.
Reading prices from IFÁ Labs is completely free. Price reads are view calls on EVM and read-only shared object queries on Sui — neither costs gas and neither requires a subscription, API key, or fee payment.The only cost is standard network gas if you deploy your own contract that consumes IFÁ Labs feeds and writes data to your own contract’s storage.
Yes. The IFÁ Labs Swap Contract is a live heterogeneous liquidity pool on Sui Testnet that uses the oracle directly for pricing — supporting deposits, withdrawals, swaps, and dust sweeping across SUI, CNGN, ZARP, and other listed assets.See Sui Swap Contract for the full overview and integration guide.

Integration

Call getAssetInfo on the oracle contract with the asset’s bytes32 ID:
    import "ifapricefeed-interface/IIfaPriceFeed.sol";

    IIfaPriceFeed constant ORACLE =
        IIfaPriceFeed(0xA9F17344689C2c2328F94464998db1d3e35B80dC); // Base Mainnet

    bytes32 constant USDT_ID =
        0x6ca0cef6107263f3b09a51448617b659278cff744f0e702c24a2f88c91e65a0d;

    function getUSDTPrice() external view returns (uint256) {
        (IIfaPriceFeed.PriceFeed memory info, bool exists) =
            ORACLE.getAssetInfo(USDT_ID);

        require(exists, "Not supported");
        require(block.timestamp - info.lastUpdateTime <= 3600, "Stale");

        return uint256(info.price) / 1e18; // human-readable price
    }
See Read Latest Price for full examples including batch reads and derived pairs.
Pass the shared IfaPriceFeed object by reference and call get_asset_info:
    use ifa_oracle::price_feed::{Self, IfaPriceFeed};
    use ifa_oracle::bytes32;

    public fun get_usdt_price(feed: &IfaPriceFeed): u256 {
        let asset_id = bytes32::new(
            x"6ca0cef6107263f3b09a51448617b659278cff744f0e702c24a2f88c91e65a0d"
        );

        let (price_feed, exists) = price_feed::get_asset_info(feed, asset_id);
        assert!(exists, 0);

        // Sui uses positive decimals — divide by 10^decimal
        // For decimal = 18: divide by 1_000_000_000_000_000_000
        price_feed::price(price_feed)
    }
The Feed Object ID on Sui Testnet is 0x5d2728b862de08de767e4f8841a38c9452d951c0602e77fc47bfbb3ab03f33f0. Pass it as the feed argument in your transaction. See the Sui Integration Guide for full examples.
Asset IDs are fixed 32-byte identifiers generated by hashing the asset symbol string with keccak256:
    bytes32 assetId = keccak256(abi.encodePacked("USDT/USD"));
The symbol string format is uppercase with a forward slash: "SYMBOL/USD". The same underlying 32-byte value works on every IFÁ Labs deployment — no remapping between networks.On EVM the ID is used as a bytes32 hex string. On Sui it is passed as a vector<u8> — same bytes, different format. You can independently verify any asset ID by computing the hash yourself and comparing against the published value. See Working with Asset IDs for full details.
The conversion formula differs between EVM and Sui:EVMdecimal is negative (e.g. -18). Divide by 10^(-decimal):
    // Solidity
    uint256 humanPrice = uint256(info.price) / 1e18;
    // JavaScript (EVM)
    const humanPrice = ethers.formatUnits(info.price, -info.decimal);
Suidecimal is positive (e.g. 18). Divide by 10^decimal:
    // Move
    // price = 1_000_000_000_000_000_000, decimal = 18 → $1.00
    // Divide price by pow(10, decimal) for human-readable value
    // TypeScript (Sui)
    const humanPrice = Number(price) / Math.pow(10, decimal);
Always read decimal dynamically rather than hardcoding — future assets may use different precision. See Decimal Precision & Formatting for full conversion guidance.
Set MAX_PRICE_AGE to at least 1.5× the heartbeat interval for each asset:
AssetHeartbeatMinimum MAX_PRICE_AGE
USDT/USD1 hour5,400s (90 min)
USDC/USD1 hour5,400s (90 min)
CNGN/USD2 hours10,800s (3 hrs)
ZARP/USD2 hours10,800s (3 hrs)
BRZ/USD2 hours10,800s (3 hrs)
ETH/USD1 hour5,400s (90 min)
The 1.5× buffer accounts for heartbeat jitter — minor delays in relayer submission that mean heartbeats don’t fire at exactly regular intervals.On Sui, the contract exposes a built-in helper: price_feed::is_fresh(price_feed, current_time, max_age) returns a bool directly — you do not need to implement the subtraction check yourself.For production deployments, run the cadence analysis script in Price Appears Stale to calibrate thresholds from real on-chain data rather than documentation estimates.
Yes, on both EVM and Sui.EVM — use getAssetsInfo with an array of asset IDs:
    bytes32[] memory ids = new bytes32[](3);
    ids[0] = USDT_ASSET_ID;
    ids[1] = CNGN_ASSET_ID;
    ids[2] = ZARP_ASSET_ID;

    (IIfaPriceFeed.PriceFeed[] memory infos, bool[] memory exists) =
        ORACLE.getAssetsInfo(ids);
Sui — use get_assets_info with a vector<Bytes32>:
    let (price_feeds, exists) = price_feed::get_assets_info(feed, asset_indexes);
One call is significantly cheaper than N consecutive single-asset calls on both chains. See Gas Optimization Tips for EVM, and the Sui Integration Guide for Move.
Use the derived pair functions. IFÁ Labs computes cross-asset prices on-chain using the two underlying USD feeds as intermediates.EVM:
    IIfaPriceFeed.DerivedPair memory pair = ORACLE.getPairbyId(
        CNGN_ASSET_ID,
        USDT_ASSET_ID,
        IIfaPriceFeed.PairDirection.Forward
    );
Sui:
    let pair = price_feed::get_pair_by_id(feed, cngn_id, usdt_id, 0); // 0 = forward
On Sui, derived pair results always use decimal = 30 with derived_price scaled by 10^30. This is fixed — not per-asset.Any combination of the six supported assets is computable as a derived pair. See Function Reference for the EVM API, or the Sui Integration Guide for Move.
On Sui, derived pair functions abort if either underlying asset does not exist — they do not return a false flag. Always verify both assets exist with get_asset_info before calling pair functions on Sui.
No. On EVM, price reads are view calls — no wallet, no ETH, no transaction required. On Sui, price reads use devInspectTransactionBlock — no SUI tokens or signing required.You only need tokens if you are deploying your own contracts that consume IFÁ Labs feeds.
Yes. On EVM, use ethers.js or viem:
    const { ethers } = require("ethers");

    const provider = new ethers.JsonRpcProvider("https://mainnet.base.org");
    const oracle   = new ethers.Contract(
      "0xA9F17344689C2c2328F94464998db1d3e35B80dC",
      ["function getAssetInfo(bytes32) view returns ((int256 price, int8 decimal, uint256 lastUpdateTime), bool exists)"],
      provider
    );

    const [info, exists] = await oracle.getAssetInfo(
      "0x6ca0cef6107263f3b09a51448617b659278cff744f0e702c24a2f88c91e65a0d"
    );

    const price = ethers.formatUnits(info.price, -info.decimal);
    console.log(`USDT/USD: $${price}`);
On Sui, use the Sui TypeScript SDK with devInspectTransactionBlock. See the Sui Integration Guide for the full pattern.See Get Your First Price for full EVM off-chain examples in JavaScript, Python, and via Basescan.

Security

Yes. All EVM oracle contracts were professionally audited by A&D Forensics in July 2025.Audit result: no critical or high severity findings. Seven findings total — five low severity, two informational. All seven were resolved before mainnet deployment.The full audit summary is at AdForensics Audit Summary. The complete report is available on request from support@ifalabs.com and in the GitHub repository.The Sui Move contracts (oracle and swap) are currently on testnet. A formal audit will be completed before either reaches mainnet.
On EVM, the oracle contracts are immutable — no upgrade mechanism, no proxy pattern, and no admin keys that can modify stored prices or pause feed updates. Once a price is written to contract storage by an authorized relayer, it remains there until the next legitimate update.On Sui, the IfaPriceFeed shared object is write-protected — only the authorized IfaPriceFeedVerifier can submit updates, and only the relayer address configured in the verifier can call submit_price_feed. The AdminCap controls verifier configuration but cannot directly alter stored prices.IFÁ Labs cannot retroactively alter historical prices or freeze a feed on either chain.
Multiple layers of protection prevent this:
  • Prices are aggregated from multiple independent sources before submission — no single source determines the output
  • Outlier detection filters anomalous data points before consensus calculation
  • A weighted median algorithm makes the final price resistant to minority manipulation
  • Zero-price and peg bounds validation reject obviously wrong values before on-chain submission
  • Decentralized relayers independently verify the aggregated price before signing
  • On Sui, the verifier contract additionally rejects prices with zero value or zero timestamps, and ignores submissions with older timestamps than the current stored value
See Data Integrity Mechanisms for the full seven-layer defense architecture.
Five methods are available — all using public data with no trust in IFÁ Labs required:
  1. Read the current on-chain price and compare against external market sources
  2. Independently compute any asset ID using keccak256 and verify it matches the published value
  3. Query historical PriceUpdated events (EVM) or AssetInfoSet events (Sui) and verify update cadence and price progression
  4. Compare prices across chains to verify cross-chain consistency
  5. Clone the audited commit and compare compiled bytecode against the deployed contract
Full instructions for all five methods: Verification Proofs.
Email support@ifalabs.com with a description of the issue, reproduction steps, and your assessment of severity. Do not disclose security issues publicly before coordinating with IFÁ Labs.We acknowledge all reports within 48 hours. See Report a Vulnerability for the full responsible disclosure policy.

MCP Server

The IFÁ Labs MCP Server exposes the full oracle infrastructure through the Model Context Protocol — an open standard that lets AI assistants and coding tools call external tools and data sources directly.In practice: you can ask Claude, Cursor, Windsurf, TRAE, or any MCP-compatible client for live stablecoin prices, asset IDs, feed freshness checks, and network configuration — and get verified on-chain data back in seconds, without leaving your editor or AI assistant.See What is the IFÁ Labs MCP Server? for full details.
    npm install -g @ifalabs/mcp-server
Then add it to your MCP client’s configuration. For Claude Desktop:
    {
      "mcpServers": {
        "ifalabs": {
          "command": "ifa-mcp",
          "args": ["--network", "base-mainnet"]
        }
      }
    }
Full installation instructions for every supported client: MCP Server Installation & Setup.
Any MCP-compatible client. Officially tested and documented:
  • Claude Desktop
  • Cursor
  • Windsurf
  • TRAE
  • Zed
  • Continue
  • LangChain, CrewAI, AutoGen (programmatic)
See MCP Client Compatibility for client-specific configuration and known limitations.
No. The MCP server reads from the same free, public oracle contracts as any other integration. No API keys, no subscription, and no gas required.

Assets and Feeds

Contact IFÁ Labs with the following:
  • Token contract address on all relevant chains
  • Backing mechanism and reserve proof or documentation
  • Current daily trading volume across all venues
  • The protocol or use case driving the request
Reach out via support@ifalabs.com, Telegram, or GitHub Issues.IFÁ Labs prioritizes emerging market stablecoins in Africa, Latin America, and Southeast Asia. New assets are reviewed and deployed on a rolling basis.
The most likely cause is that your MAX_PRICE_AGE threshold is tighter than the asset’s natural update cadence.During stable market conditions, IFÁ Labs feeds update only when the price moves beyond the deviation threshold — not continuously. A feed that appears stale by your threshold may be accurate and working correctly.Set MAX_PRICE_AGE to at least 1.5× the heartbeat interval for the asset. Then run the cadence analysis script in Price Appears Stale to calibrate from real on-chain data.If the feed age significantly exceeds the heartbeat interval across all assets simultaneously, a relayer issue may be affecting the deployment. Check the Telegram for incident announcements.
Yes — the underlying 32-byte value is identical across every network, including Sui.The format differs between chain types:
  • EVM — used as a bytes32 hex string: 0x6ca0cef6...
  • Sui — passed as a vector<u8>: x"6ca0cef6..." in Move, or a byte array in TypeScript
The only thing that changes between networks is the contract address (EVM) or object ID (Sui). See Contract Addresses for the full reference.
ETH/USD is included as a reference asset to enable derived pair calculations between stablecoins and ETH — for example, pricing USDC in ETH terms or ETH in CNGN terms.IFÁ Labs is stablecoin-first. ETH is not a primary feed target — it is there to make cross-asset pricing more flexible for protocols that need it. Do not apply stablecoin-specific checks (like a $1.00 peg deviation guard) to ETH/USD.

Sui

Several things are different on Sui:
  • Shared objects instead of contract addresses. You pass the IfaPriceFeed object by reference in transactions — there is no contract address to call.
  • Positive decimal convention. Sui uses u8 for the decimal field. 18 means divide by 10^18 — the opposite sign from EVM’s -18.
  • Derived pair decimal is always 30. All derived pair results on Sui have decimal = 30 and derived_price scaled by 10^30.
  • Asset IDs as vector<u8>. Same 32-byte values as EVM — but passed without the 0x prefix using Sui’s hex literal syntax x"...".
  • Built-in is_fresh helper. The Sui contract exposes price_feed::is_fresh(price_feed, current_time, max_age): bool — no need to implement the staleness check yourself.
  • Derived pair functions abort on missing assets. On EVM, missing assets return exists = false. On Sui, they abort. Always check both assets exist before calling pair functions.
See the Sui Integration Guide for the full pattern.
Two options:
  • Official Sui Faucetfaucet.sui.io for testnet SUI
  • IFÁ Labs Faucet — claim testnet SUI and WAL tokens directly from the IFÁ Labs multi-token faucet deployed on Sui Testnet. See the Testnet Faucet page for claim instructions.
ObjectID
Package ID0x99847c953ee11ca57b6d602494c914d7d82a2d42c4c8a80307331fead5b22c4a
Feed Object ID0x5d2728b862de08de767e4f8841a38c9452d951c0602e77fc47bfbb3ab03f33f0
Verifier Object ID0x028e5df554ac7d253a132c60bcd13cf32bea9eb8c81d04d685c2a31299fbe43b
When reading prices, pass the Feed Object ID. The Package ID is only needed when importing ifa_oracle as a dependency in your own Move package.
These object IDs were updated after a redeployment of the oracle package. If you previously saved different IDs, they are now stale — always cross-check against Contract Addresses before integrating.
See Contract Addresses for the full reference.
Yes. The IFÁ Labs Swap Contract is a live heterogeneous liquidity pool deployed on Sui Testnet, priced directly by the IFÁ Labs oracle. It supports liquidity deposits and withdrawals, asset-to-asset swaps, and dust sweeping into a target asset across SUI, CNGN, ZARP, and other listed tokens.See Sui Swap Contract for the full overview, pool details, and integration guide.

Community and Contribution

Three channels:
  • X: @ifalabs — deployment announcements, new assets, ecosystem news
  • Telegram: t.me/ifalabs — real-time updates and incident announcements
  • GitHub: Watch the repository — contract changes and releases
The Changelog is updated for every significant release.
Yes. Pull requests are welcome for bug fixes, test coverage, gas optimizations, documentation improvements, and new integration examples.See GitHub & Bug Reports for the full contribution workflow, repository structure, and contribution areas.
A formal bug bounty program is under development. Until it launches, critical and high severity findings submitted through responsible disclosure will be reviewed for discretionary rewards based on impact and report quality.See Report a Vulnerability for the current disclosure policy and contact channels.

Still Have Questions?

Get Help

Every support channel and what each one is best for.

GitHub & Bug Reports

Report bugs, request features, and contribute to IFÁ Labs.