Blockchain Smart Contracts with Solidity · Lesson

Building Custom Oracle Contracts

Learn how to design and implement your own oracle pattern in Solidity, including request-response flows, trusted updaters, and validating data freshness on-chain.

Building Custom Oracle Contracts is a free Blockchain Smart Contracts with Solidity lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Blockchain Smart Contracts with Solidity learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Beyond Third-Party Oracles

Chainlink and similar networks cover common feeds, but sometimes you need data nobody else provides, like a proprietary API result. In those cases you build a custom oracle: an off-chain updater plus an on-chain contract that stores and serves the data.

The Two-Party Design

A custom oracle has two sides:

Off-chain updater: a server that reads the external source and sends transactions.
On-chain contract: stores the latest value and exposes a read function for other contracts.

A Minimal Storage Oracle

The simplest oracle just lets a trusted address write a value that anyone can read.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract SimpleOracle {
    address public updater;
    uint256 public value;
    uint256 public lastUpdated;

    constructor() {
        updater = msg.sender;
    }

    function setValue(uint256 newValue) external {
        require(msg.sender == updater, 'not updater');
        value = newValue;
        lastUpdated = block.timestamp;
    }
}

Guarding the Updater

The single point of trust is the updater address. Protect it with access control and allow it to be rotated safely if a key is compromised.

function transferUpdater(address newUpdater) external {
    require(msg.sender == updater, 'not updater');
    require(newUpdater != address(0), 'zero address');
    updater = newUpdater;
}

Checking Data Freshness

Stale data is dangerous. Consumers should reject values older than a threshold using the stored lastUpdated timestamp.

uint256 public constant MAX_AGE = 1 hours;

function getFreshValue() external view returns (uint256) {
    require(block.timestamp - lastUpdated <= MAX_AGE, 'stale data');
    return value;
}

Request-Response Pattern

For on-demand data, a consumer emits a request event. The off-chain updater watches for it and replies with the answer in a callback.

event DataRequested(uint256 indexed requestId, string query);

uint256 private nextId;

function requestData(string calldata query) external returns (uint256) {
    uint256 id = nextId++;
    emit DataRequested(id, query);
    return id;
}

Fulfilling a Request

The updater calls back with the result for a given request id. Store it keyed by id so the consumer can read it later.

mapping(uint256 => uint256) public answers;
mapping(uint256 => bool) public fulfilled;

function fulfill(uint256 requestId, uint256 result) external {
    require(msg.sender == updater, 'not updater');
    answers[requestId] = result;
    fulfilled[requestId] = true;
}

Reducing Single-Source Risk

One updater is one point of failure. To harden the oracle you can require multiple updaters to agree (an aggregation or median of submissions) before a value is accepted.

mapping(address => bool) public isUpdater;
mapping(address => uint256) public submitted;
address[] public updaters;

function submit(uint256 v) external {
    require(isUpdater[msg.sender], 'not updater');
    submitted[msg.sender] = v;
}

Computing a Median

A median resists a single malicious updater better than an average. Collect submissions, sort them off-chain or with a small on-chain helper, and take the middle value.

function median(uint256[] memory data) internal pure returns (uint256) {
    // assume data already sorted
    uint256 n = data.length;
    if (n % 2 == 1) return data[n / 2];
    return (data[n / 2 - 1] + data[n / 2]) / 2;
}

Trust Tradeoffs

Custom oracles trade decentralization for flexibility. Document clearly who runs the updater, what data is sourced, and how consumers should react to staleness. For high-value DeFi, prefer established decentralized oracle networks.

Consumer Integration

A consumer contract simply imports the oracle interface and reads from it, applying its own freshness checks.

interface IOracle {
    function getFreshValue() external view returns (uint256);
}

contract Consumer {
    IOracle public oracle;
    constructor(address o) { oracle = IOracle(o); }
    function price() external view returns (uint256) {
        return oracle.getFreshValue();
    }
}

Quick Check

Test your grasp of custom oracle design.

Recap

You built a custom oracle with an off-chain updater and an on-chain store. Key ideas:

Trusted updater with rotatable access control
Freshness checks via lastUpdated
Request-response flow with events and callbacks
Multiple updaters and medians to reduce single-source risk

Use custom oracles for niche data, but prefer decentralized networks for high-stakes feeds.

Frequently asked questions

Is the “Building Custom Oracle Contracts” lesson free?

Yes — the full text of “Building Custom Oracle Contracts” is free to read here on the web, and the Blockchain Smart Contracts with Solidity course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Blockchain Smart Contracts with Solidity course, upgrade to CoddyKit PRO.

What will I learn in “Building Custom Oracle Contracts”?

Learn how to design and implement your own oracle pattern in Solidity, including request-response flows, trusted updaters, and validating data freshness on-chain. You practise Blockchain Smart Contracts with Solidity with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Blockchain Smart Contracts with Solidity?

No prior experience is required. Blockchain Smart Contracts with Solidity on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Building Custom Oracle Contracts” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Blockchain Smart Contracts with Solidity lesson?

Yes. Every Blockchain Smart Contracts with Solidity lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Blockchain Smart Contracts with Solidity