FTSOv2: The Sub-2-Second Oracle That’s Killing DeFi’s Latency Problem

By Kaushtubh Agrawal, Flare Network Developer Ambassador

A derivatives trader on Ethereum just lost $50,000 because their options contract settled using 15-minute-old price data. This isn’t a bug—it’s the oracle problem. Flare Network’s FTSOv2 solves this in 1.8 seconds, for free, at protocol level.

What is Flare Network and Why Does It Matter?

Flare Network is an EVM-compatible, decentralized smart contract platform purpose-built to bring reliable real-world data on-chain at scale. Unlike traditional blockchains that focus purely on value transfer, Flare positions itself as the “Layer 1 for data,” designed to make blockchains useful for complex, data-driven applications.

Key Flare Network Features

• Native Interoperability: Seamless data and asset bridging across 75+ chains via protocols like LayerZero
• Open Oracle Infrastructure: Not limited to price feeds—any signal, event, or dataset can be referenced on-chain
• EVM Compatibility: Deploy existing Ethereum dApps with minimal modifications
• Gas Efficiency: Optimized for high-frequency data operations without network congestion
• Cross-Chain Data Hub: Acts as a central source of truth for multi-chain applications

At the heart of this ecosystem lies FTSOv2—the engine that transforms Flare’s ambitious data vision into reality.

Built for Security, Speed, and Scale

FTSOv2 is not just another oracle—it’s enshrined in Flare’s protocol, meaning it inherits the same security guarantees as the rest of the network and enables truly decentralized, manipulation-resistant data.

What Makes FTSOv2 Revolutionary

Rock-Solid Security

Protocol-native design secured by over 67% of all FLR staked across 100+ independent data providers using a sophisticated pass-based reward system.

Sub–2–Second Speed

Block-latency feeds update roughly every 1.8 seconds, making it one of the fastest oracle systems in existence.

Massive Scalability

Supports 1,000+ price feeds simultaneously—crypto pairs, equities, commodities, and forex—while consuming under 10% of network gas.

Totally Free Access

Zero per-query costs for block-latency feeds. You only pay minimal gas to verify data on-chain.

Rich Historical Data

Access up to 2 weeks of on-chain price history for analytics, backtesting, and advanced trading strategies.

Cross-Chain Ready

FTSOv2 prices can be published across chains via LayerZero, making Flare a universal data oracle for the multi-chain future.

TL;DR

• 1.8-Second Updates: Every block, versus minutes-or-hours for competitors
• Zero Cost: Unlimited free queries
• Protocol-Native Security: Oracle built into consensus with 67% of FLR staked
• Real-Time Derivatives: Enables on-chain options AMMs, perpetuals, and arbitrage
• Hands-On Code: Smart contract and React examples provided

1. On-Chain Options AMM: A Real-World Use Case

Remember our $50K trader? With stale data, their option expired underwater. FTSOv2’s sub-2-second feeds let you build a fully decentralized Option AMM that mints, prices, and settles options in near real-time—no intermediaries.
Project: Demo, Github

How It Works

Minting Options

• User locks premium and sets strike, expiry, call/put
• Contract pulls latest FLR/USD from FTSOv2

Price Fetch & Randomness Check

(uint256 px, , uint64 ts) = ftsoV2.getFeedById(feedId);
require(block.timestamp - ts  strike → payout = px − strike  
- If put: px  Option) public options;
    uint256 public counter;

    event Mint(uint256 id, bytes21 feedId, uint256 strike);
    event Exercise(uint256 id, uint256 price);

    function mint(bytes21 feedId, uint256 strike, uint64 ttl, bool isCall) external payable {
        require(msg.value > 0, "Premium required");
        options[counter] = Option(feedId, strike, uint64(block.timestamp)+ttl, msg.value, msg.sender, isCall, false);
        emit Mint(counter++, feedId, strike);
    }

    function exercise(uint256 id) external {
        Option storage o = options[id];
        require(msg.sender == o.holder && block.timestamp o.strike : px  o.strike ? px - o.strike : o.strike - px;
        payable(o.holder).transfer(payout);
        emit Exercise(id, px);
    }
}

Pro Tip: Always verify randomness and enforce access controls.

2. Problem → Solution → How It Works

2.1 The Oracle Problem

DeFi oracles are slow, costly, and centralized—creating stale data and single points of failure.

2.2 FTSOv2’s Answer

• Dual Feeds: Anchor (90s commit–reveal) and block-latency (≈1.8s per block)
• Scalable & Secure:

 {
        const fetch = async () => {
            const [v, d, ts] = await ftso.methods.getFeedById(FLR_USD).call();
            setPrice((v/10**Math.abs(d)).toFixed(6));
        };
        fetch();
        const id = setInterval(fetch, 2000);
        return () => clearInterval(id);
    }, []);

    return FLR/USD: ${price};
}

2.3 Under the Hood

VRF Selection: Random provider lottery each block

Pass-Based Incentives: Reputation via data accuracy and uptime

Consensus Enshrinement: Oracle in protocol layer for maximum security

3. Build With FTSOv2: Quickstart

3.1 Smart Contract Setup

npm install -g hardhat
npm install @flarenetwork/flare-periphery-contracts

// contracts/FtsoExample.sol
pragma solidity ^0.8.20;

import "@flarenetwork/flare-periphery-contracts/flare/ContractRegistry.sol";
import "@flarenetwork/flare-periphery-contracts/flare/FtsoV2Interface.sol";

contract FtsoExample {
    FtsoV2Interface ftsoV2 = ContractRegistry.getFtsoV2();
    bytes21 FLR_USD = 0x01464c522f55534400000000000000000000000000;

    function getPrice() external view returns (uint256 v, int8 d, uint64 ts) {
        return ftsoV2.getFeedById(FLR_USD);
    }
}

3.2 React Frontend

// src/App.jsx
import React, { useEffect, useState } from "react";
import Web3 from "web3";
import ABI from "./FTSOV2_ABI.json";

const web3 = new Web3("https://flare-api.flare.network/ext/C/rpc");
const ftso = new web3.eth.Contract(ABI, "0x1000000000000000000000000000000000000003");
const FLR_USD = "0x01464c522f55534400000000000000000000000000";

export default function App() {
    const [price, setPrice] = useState("-");

    useEffect(() => {
        const fetch = async () => {
            const [v, d, ts] = await ftso.methods.getFeedById(FLR_USD).call();
            setPrice((v/10**Math.abs(d)).toFixed(6));
        };
        fetch();
        const id = setInterval(fetch, 2000);
        return () => clearInterval(id);
    }, []);

    return <div><h1>FLR/USD: ${price}</h1></div>;
}

4. Interactive Benchmarks

5. Advanced Use Cases & Next Steps

• Perpetual Futures: Mark positions every block
• Arbitrage Bots: Detect spreads across chains via LayerZero
• AI Analytics: On-chain volatility indices using 2-week history

Your 5-Minute Challenge

• Deploy FtsoExample on Coston2
• Integrate React UI and verify live prices
• Mint & exercise an option in OptionAMM

Conclusion

FTSOv2 eliminates the latency and cost barriers of DeFi oracles, empowering real-time, secure, and free data for advanced derivatives and beyond. How will FTSOv2 transform your DeFi vision? Drop your ideas below and join the Flare developer community on Discord to get started!

Connect with me on Twitter or drop a comment below — feedback, questions, and builds welcome!

📢 Stay Updated

• Flare Developer Docs: Comprehensive guides, API references, and tutorials
• Join Flare Network Discord: Connect with developers, get real-time support, and join technical discussions
• Flare Network GitHub Docs: Access code examples, contribute to open-source projects
• Flare Network Official Website: Latest announcements and ecosystem updates