A decentralized
truthmachine

UMA' s optimistic oracle (OO) can record any verifiable truth or data onto a blockchain.

How UMA works

The Optimistic Oracle verifies data in stages

Statement

A statement is proposed as true

A natural-language statement is submitted along with a bond. The bond acts as a bounty for anyone to dispute it if they have evidence to the contrary.

Challenge period

Most statements go undisputed

Anyone can propose an answer to a data request, and it is accepted as true if it is not disputed during the challenge period.

Dispute

Anyone can dispute a statement

Each statement submitted for validation is an opportunity for anyone to earn a reward by disputing it successfully. As the game theory would predict, disputes are rare in practice because the incentives are always to be honest. That makes the OO “optimistic”.

Voting

Tokenholders vote on disputes and earn rewards

The UMA token provides economic guarantees to the Optimistic Oracle. The community of tokenholders provide the human component, as voters, for the OO's final resolution on disputes or queries. Those who vote with the majority earn rewards.

Participate as a Voter

Stake, vote & earn up to 30.1% APR

Stake

Stake your $UMA to help secure UMA's Optimistic Oracle.

Vote

Token holders who vote correctly and consistently earn higher APYs.

Earn

Successful voters will gradually own a higher percentage of the protocol than unsuccessful or inactive voters.

Link to voter app

Participate as a Builder

Launch products with theas your backbone

Governance

The OO can be used to enable more trustless forms of DAO governance. The first product using this is oSnap, which is a trustless method to execute the results of a Snapshot vote on chain.

Real question used by oSnap

Does this on-chain transaction match an approved Snapshot vote?

pragma solidity ^0.8.14;
/**
 * @title Optimistic Governor
 * @notice A contract that allows optimistic governance of a set of transactions. The contract can be used to propose
 * transactions that can be challenged by anyone. If the challenge is not resolved within a certain liveness period, the
 * transactions can be executed.
 */
contract OptimisticGovernor {
    function proposeTransactions(Transaction[] memory _transactions, bytes memory _explanation) external nonReentrant {
        // note: Optional explanation explains the intent of the transactions to make comprehension easier.
        uint256 time = getCurrentTime();
        address proposer = msg.sender;

        // Create proposal in memory to emit in an event.
        Proposal memory proposal;
        proposal.requestTime = time;

        // Add transactions to proposal in memory.
        for (uint256 i = 0; i < _transactions.length; i++) {
            // If the transaction has any data with it the recipient must be a contract, not an EOA.
            if (_transactions[i].data.length > 0) {
                require(_isContract(_transactions[i].to), "EOA can't accept tx with data");
            }
        }
        proposal.transactions = _transactions;

        // Create the proposal hash.
        bytes32 proposalHash = keccak256(abi.encode(_transactions));

        // Add the proposal hash, explanation and rules to ancillary data.
        bytes memory claim = _constructClaim(proposalHash, _explanation);

        // Check that the proposal is not already mapped to an assertionId, i.e., is not a duplicate.
        require(proposalHashes[proposalHash] == bytes32(0), "Duplicate proposals not allowed");

        // Get the bond from the proposer and approve the required bond to be used by the Optimistic Oracle V3.
        // This will fail if the proposer has not granted the Optimistic Governor contract an allowance
        // of the collateral token equal to or greater than the totalBond.
        uint256 totalBond = getProposalBond();
        collateral.safeTransferFrom(msg.sender, address(this), totalBond);
        collateral.safeIncreaseAllowance(address(optimisticOracleV3), totalBond);

        // Assert that the proposal is correct at the Optimistic Oracle V3.
        bytes32 assertionId =
            optimisticOracleV3.assertTruth(
                claim, // claim containing proposalHash, explanation and rules.
                proposer, // asserter will receive back bond if the assertion is correct.
                address(this), // callbackRecipient is set to this contract for automated proposal deletion on disputes.
                escalationManager, // escalationManager (if set) used for whitelisting proposers / disputers.
                liveness, // liveness in seconds.
                collateral, // currency in which the bond is denominated.
                totalBond, // bond amount used to assert proposal.
                identifier, // identifier used to determine if the claim is correct at DVM.
                bytes32(0) // domainId is not set.
            );

        // Maps the proposal hash to the returned assertionId and vice versa.
        proposalHashes[proposalHash] = assertionId;
        assertionIds[assertionId] = proposalHash;

        emit TransactionsProposed(
            proposer,
            time,
            assertionId,
            proposal,
            proposalHash,
            _explanation,
            rules,
            time + liveness
        );