Custom Oracle Integration: Band Protocol Pull Model and Scripts

A client faced a problem: their DeFi protocol on Polygon required a reliable data source to calculate interest rates across 50+ pairs. Chainlink didn't fit — high push-update costs ($5000 per month for 50 feeds) and limited customization. We proposed integrating Band Protocol, which uses a pull model via BandChain (Cosmos SDK) and allows creating custom oracle scripts. As a result, gas costs decreased 5x, with savings up to 97% (saving ~$8000 per month for 100 pairs). Our experience includes 20+ oracle integrations in DeFi protocols with a combined TVL of $150M+. With 5+ years in blockchain development, our team ensures reliable deployment. Get a consultation — contact us to evaluate your project.

Solving Expensive Data Problems with Custom Oracles

Band Protocol is a cross-chain oracle built on a separate BandChain blockchain with 30+ validators executing data requests. Unlike Chainlink's push model where price feeds update every 10 minutes, Band operates on demand. You pay only for the data you actually use.

BandChain Architecture

• BandChain: a blockchain on Cosmos SDK optimized for oracles. Validators vote on request results; consensus time is 3 seconds.
• Oracle Scripts: programs in Owanscript (WebAssembly) that define how to aggregate data from selected sources. For example, take the median of 3 sources over the last 5 minutes.
• Data Sources: verified sources (CoinGecko, Binance, CryptoCompare) — you can combine up to 10 sources in a single script.
• IBC + Bridges: results are transmitted to other chains via IBC (Cosmos) or bridge contracts (EVM) with a fee of $0.01 per request.

EVM Integration

For standard prices (BTC/USD, ETH/USD), you can use the ready-made IStdReference contract:

interface IStdReference {
    struct ReferenceData {
        uint256 rate;
        uint256 lastUpdatedBase;
        uint256 lastUpdatedQuote;
    }
    function getReferenceData(string memory _base, string memory _quote)
        external view returns (ReferenceData memory);
    function getReferenceDataBulk(
        string[] memory _bases, 
        string[] memory _quotes
    ) external view returns (ReferenceData[] memory);
}

contract BandConsumer {
    IStdReference ref;
    
    constructor(IStdReference _ref) {
        ref = _ref;
    }
    
    function getPrice(string memory symbol) external view returns (uint256) {
        IStdReference.ReferenceData memory data = ref.getReferenceData(symbol, "USD");
        // Check freshness: data not older than 1 hour
        require(block.timestamp - data.lastUpdatedBase < 3600, "Stale price");
        return data.rate;
    }
}

Custom Oracle Scripts and How to Create Them

An oracle script is a program in Owanscript that defines which external APIs to query, how to aggregate results, and how to return data. We create scripts tailored to your task: from simple median to weighted averages with manipulation protection.

Example of an advanced oracle script for prices with frontrunning protection:

# Fetch function with response time check
def execute(ctx):
    sources = ctx.get_sources()
    prices = []
    for s in sources:
        data = s.fetch()
        if data.response_time > 500: # ms
            continue
        prices.append(data.price)
    # Remove 10% extreme values
    trim = len(prices) // 10
    trimmed = sorted(prices)[trim:-trim]
    return median(trimmed)

Why Custom Oracle Scripts Are the Main Advantage of Band?

Band lets you write your own scripts in Owanscript. This offers flexibility unavailable in Chainlink, especially for non-standard feeds — weather, sports, random numbers. Band outperforms Chainlink by 3-10x in data update cost when dealing with many pairs. The financial benefit is clear: for 100 pairs, savings reach $8000 per month.

How to Create an Oracle Script: Step by Step

1. Define data sources. Choose from verified APIs (CoinGecko, Binance) — up to 5 sources.
2. Write aggregation logic in Owanscript. Use median, average, or weighted with trimming of extremes.
3. Compile the script to WASM. Size limit — 1 MB.
4. Deploy the script to BandChain. Deployment fee — 0.1 BAND (~$0.50).
5. Test locally using Band CLI.
6. Connect consumer contract to the bridge.

How We Conduct Integration

We perform full-cycle integration. The process includes stages with estimated timelines:

What’s Included in the Work?

• Full smart contract code with comments.
• Docker environment for testing.
• Deployment and feed update documentation.
• Access to monitoring dashboard (Tenderly).
• Training session for your team (1 hour).
• Guarantee of correct contract operation for 1 month after deployment.

Comparison: Band Protocol vs Chainlink

Band Protocol is optimal for projects on Cosmos and those needing custom data feeds. For Ethereum mainnet DeFi with high liquidity, Chainlink remains the standard. However, with a large number of pairs, Band delivers 3-10x cost savings. Contact us so we can evaluate your project and choose the best integration scheme.

Learn more on Wikipedia.

Estimated timeline: from one week to one month. Get a consultation — contact us to assess your project. Order Band Protocol integration today to reduce oracle costs.

Integration of Blockchain Oracles: Chainlink, Pyth, API3

When we design oracle integration for a DeFi protocol, the first problem is access to external data. A smart contract without an oracle is deterministic and blind. Token price, fiat exchange rate, event outcome — all off-chain. But as soon as you introduce an oracle, oracle manipulation appears. It drained Mango Markets ($114M), Cream Finance ($130M), and dozens of smaller protocols.

Why do oracles break? And what is the danger of spot price?

Classic attack: attacker takes a flash loan of $100M, buys a token in an illiquid pool — price spikes 5×, victim contract reads that price as collateral value, attacker borrows against inflated collateral, repays flash loan, walks away with profit. All in one transaction.

Mango Markets lost $114M exactly that way: Avraham Eisenberg manipulated MNGO price through spot positions on the platform that used spot price for collateral calculation. More complex than flash loan, but works on less liquid assets.

The rule is simple: never use spot price from an on-chain pool directly for loans, liquidations, or minting significant amounts. The correct replacement is TWAP (Time-Weighted Average Price). Uniswap v3 stores cumulative tick values in a circular buffer (up to 65,535 observations). Minimum safe TWAP for DeFi is 30 minutes. An attack on a 30-minute TWAP through a pool with $10M+ liquidity costs hundreds of thousands of dollars — economically infeasible.

Chainlink Data Feeds: Architecture and Edge Cases

Chainlink Data Feeds are a decentralized oracle network (DON): multiple node operators fetch data from different sources, aggregate by median. The AggregatorV3Interface contract returns latestRoundData() with fields roundId, answer, startedAt, updatedAt, answeredInRound.

Most integrations make one mistake: they only check answer > 0, ignoring staleness. If Chainlink hasn't updated the price in the last 3600 seconds (heartbeat for ETH/USD is 1 hour on mainnet), updatedAt will show that. Correct check:

(, int256 price, , uint256 updatedAt, ) = priceFeed.latestRoundData();
require(price > 0, "Invalid price");
require(block.timestamp - updatedAt <= 3600 + 300, "Stale price"); // heartbeat + buffer

Circuit breaker in Chainlink: if the real price goes beyond minAnswer/maxAnswer (hardcoded in the aggregator), Chainlink returns the boundary value. LUNA in May 2022: when price fell from $80 to $0.10, several lending protocols kept receiving minAnswer = $0.10 instead of actual ~$0.0006. Check answer != aggregator.minAnswer() && answer != aggregator.maxAnswer() — this is "price truncated at boundary".

Chainlink VRF v2

VRF uses a different architecture: contract requests randomness via requestRandomWords(), coordinator sends VRF proof on-chain, contract verifies proof through BLS-based verifier. Latency is 2–3 blocks on mainnet. Acceptable for gaming/NFT minting, but not for time-sensitive operations.

How to choose between Chainlink, Pyth, and API3?

Pyth works on a pull model: prices are published on Wormhole, the application fetches the fresh price in the user transaction. Pyth latency is 400ms vs 10–60 seconds for Chainlink. Beneficial for perpetuals and options. For lending with 30-minute TWAP, Chainlink is sufficient. Integration via IPyth: getPriceNoOlderThan(priceId, maxAge) — on Ethereum mainnet during high gas, a 60-second maxAge may be too strict.

API3 builds a first-party oracle: the API provider runs its own oracle node (Airnode) and signs data with its key. Important for regulated financial data (Bloomberg, Refinitiv) from a compliance perspective.

What is a circuit breaker and why is it dangerous?

A circuit breaker is a protection against extreme price values built into the Chainlink aggregator. If the price goes beyond minAnswer/maxAnswer, the oracle returns the boundary value, not the real one. LUNA is an example where protocols didn't check boundaries and borrowers walked away with millions. Source: Chainlink documentation

How We Integrate Chainlink Data Feeds

1. Requirements analysis: assets, chains, acceptable staleness, manipulation sensitivity. Many protocols use a primary + fallback scheme: Chainlink Data Feeds as primary, Uniswap TWAP as fallback on staleness, circuit breaker if deviation >10% between sources.
2. Architecture design: contract selection, heartbeat configuration, minAnswer/maxAnswer check for each feed.
3. Implementation: writing wrappers with staleness and circuit breaker checks. We use Foundry fork testing with vm.mockCall to manipulate latestRoundData. Reproduce stale price, circuit breaker trigger, zero price scenarios — all handled by pause mechanism.
4. Testing: invariant tests with Echidna (fuzzing), gas optimization (caching roundId, batch requests).
5. Security audit: formal verification of aggregation logic, oracle manipulation vector checks.
6. Deployment and monitoring: Tenderly alerts for staleness, deviation between feeds, suspicious activity.

Estimated Timelines

Specific oracle choice and architecture are discussed after a technical briefing.

What Is Included in the Work

• Audit of existing oracle integration (if any)
• Project documentation with architectural decisions
• Smart contract implementation and deployment
• Monitoring and alert setup (Tenderly)
• Integration tests and security verification results
• Training of the client's team on oracle operations
• Support for 1 month after deployment

We have completed more than 20 oracle integrations for DeFi protocols, including lending and perps. Experience: 5+ years in Web3 development. We guarantee a secure architecture certified through formal verification and audits by leading firms. Contact us for a technical briefing — we will select the optimal provider for your project.