사용자 지정 오라클 컨트랙트 구축

Beyond Third-Party Oracles

The Two-Party Design

A Minimal Storage Oracle

// 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

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

Checking Data Freshness

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

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

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

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

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

Consumer Integration

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

Recap