CentralizedArbitrator

Git Source

Inherits: IArbitratorV2

This is a centralized arbitrator deciding alone on the result of disputes. It illustrates how IArbitratorV2 interface can be implemented. Note that this contract supports appeals. The ruling given by the arbitrator can be appealed by crowdfunding a desired choice.

State Variables

WINNER_STAKE_MULTIPLIER

uint256 public constant WINNER_STAKE_MULTIPLIER = 10000;

LOSER_STAKE_MULTIPLIER

uint256 public constant LOSER_STAKE_MULTIPLIER = 20000;

LOSER_APPEAL_PERIOD_MULTIPLIER

uint256 public constant LOSER_APPEAL_PERIOD_MULTIPLIER = 5000;

MULTIPLIER_DIVISOR

uint256 public constant MULTIPLIER_DIVISOR = 10000;

owner

address public owner = msg.sender;

appealDuration

uint256 public appealDuration;

arbitrationFee

uint256 private arbitrationFee;

appealFee

uint256 public appealFee;

disputes

DisputeStruct[] public disputes;

disputeIDtoRoundArray

mapping(uint256 => Round[]) public disputeIDtoRoundArray;

Functions

onlyOwner

modifier onlyOwner();

constructor

Constructor.

constructor(uint256 _arbitrationFee, uint256 _appealDuration, uint256 _appealFee);

Parameters

setArbitrationFee

Set the arbitration fee. Only callable by the owner.

function setArbitrationFee(uint256 _arbitrationFee) external onlyOwner;

Parameters

setAppealDuration

Set the duration of the appeal period. Only callable by the owner.

function setAppealDuration(uint256 _appealDuration) external onlyOwner;

Parameters

setAppealFee

Set the appeal fee. Only callable by the owner.

function setAppealFee(uint256 _appealFee) external onlyOwner;

Parameters

createDispute

Create a dispute and pay for the fees in the native currency, typically ETH. Must be called by the arbitrable contract. Must pay at least arbitrationCost(_extraData).

function createDispute(uint256 _choices, bytes calldata _extraData)
    external
    payable
    override
    returns (uint256 disputeID);

Parameters

Returns

createDispute

Create a dispute and pay for the fees in the native currency, typically ETH. Must be called by the arbitrable contract. Must pay at least arbitrationCost(_extraData).

function createDispute(uint256, bytes calldata, IERC20, uint256) external pure override returns (uint256);

Parameters

Returns

fundAppeal

Manages contributions, and appeals a dispute if at least two choices are fully funded. This function allows the appeals to be crowdfunded. Note that the surplus deposit will be reimbursed.

function fundAppeal(uint256 _disputeID, uint256 _choice) external payable;

Parameters

giveRuling

Give a ruling to a dispute. Once it's given the dispute can be appealed, and after the appeal period has passed this function should be called again to finalize the ruling. Accounts for the situation where the winner loses a case due to paying less appeal fees than expected.

function giveRuling(uint256 _disputeID, uint256 _ruling) external onlyOwner;

Parameters

withdrawFeesAndRewards

Allows to withdraw any reimbursable fees or rewards after the dispute gets resolved.

function withdrawFeesAndRewards(uint256 _disputeID, address payable _beneficiary, uint256 _round, uint256 _choice)
    external
    returns (uint256 amount);

Parameters

Returns

arbitrationCost

Compute the cost of arbitration denominated in the native currency, typically ETH. It is recommended not to increase it often, as it can be highly time and gas consuming for the arbitrated contracts to cope with fee augmentation.

function arbitrationCost(bytes calldata) public view override returns (uint256 fee);

Parameters

Returns

arbitrationCost

Compute the cost of arbitration denominated in the native currency, typically ETH. It is recommended not to increase it often, as it can be highly time and gas consuming for the arbitrated contracts to cope with fee augmentation.

function arbitrationCost(bytes calldata, IERC20) public pure override returns (uint256);

Parameters

Returns

fundingStatus

Return the funded amount and funding goal for one of the choices.

function fundingStatus(uint256 _disputeID, uint256 _choice) external view returns (uint256 funded, uint256 goal);

Parameters

Returns

appealPeriod

Compute the start and end of the dispute's appeal period, if possible. If the dispute is not appealble return (0, 0).

function appealPeriod(uint256 _disputeID) public view returns (uint256 start, uint256 end);

Parameters

Returns

currentRuling

function currentRuling(uint256) public pure returns (uint256, bool, bool);

Events

AppealPossible

To be emitted when a dispute can be appealed.

event AppealPossible(uint256 indexed _disputeID, IArbitrableV2 indexed _arbitrable);

AppealDecision

To be emitted when the current ruling is appealed.

event AppealDecision(uint256 indexed _disputeID, IArbitrableV2 indexed _arbitrable);

Contribution

Raised when a contribution is made, inside fundAppeal function.

event Contribution(
    uint256 indexed _disputeID, uint256 indexed _round, uint256 _choice, address indexed _contributor, uint256 _amount
);

Withdrawal

Raised when a contributor withdraws a non-zero value.

event Withdrawal(
    uint256 indexed _disputeID, uint256 indexed _round, uint256 _choice, address indexed _contributor, uint256 _amount
);

ChoiceFunded

To be raised when a choice is fully funded for appeal.

event ChoiceFunded(uint256 indexed _disputeID, uint256 indexed _round, uint256 indexed _choice);

Structs

DisputeStruct

struct DisputeStruct {
    IArbitrableV2 arbitrated;
    bytes arbitratorExtraData;
    uint256 choices;
    uint256 appealPeriodStart;
    uint256 arbitrationFee;
    uint256 ruling;
    DisputeStatus status;
}

Round

struct Round {
    mapping(uint256 => uint256) paidFees;
    mapping(uint256 => bool) hasPaid;
    mapping(address => mapping(uint256 => uint256)) contributions;
    uint256 feeRewards;
    uint256[] fundedChoices;
}

Enums

DisputeStatus

enum DisputeStatus {
    Waiting,
    Appealable,
    Solved
}