KlerosCore

Git Source

Inherits: IArbitratorV2

State Variables

FORKING_COURT

uint96 public constant FORKING_COURT = 0;

GENERAL_COURT

uint96 public constant GENERAL_COURT = 1;

NULL_DISPUTE_KIT

uint256 public constant NULL_DISPUTE_KIT = 0;

DISPUTE_KIT_CLASSIC

uint256 public constant DISPUTE_KIT_CLASSIC = 1;

DEFAULT_NB_OF_JURORS

uint256 public constant DEFAULT_NB_OF_JURORS = 3;

ALPHA_DIVISOR

uint256 public constant ALPHA_DIVISOR = 1e4;

NON_PAYABLE_AMOUNT

uint256 public constant NON_PAYABLE_AMOUNT = (2 ** 256 - 2) / 2;

SEARCH_ITERATIONS

uint256 public constant SEARCH_ITERATIONS = 10;

NATIVE_CURRENCY

IERC20 public constant NATIVE_CURRENCY = IERC20(address(0));

governor

address public governor;

pinakion

IERC20 public pinakion;

jurorProsecutionModule

address public jurorProsecutionModule;

sortitionModule

ISortitionModule public sortitionModule;

courts

Court[] public courts;

disputeKitNodes

DisputeKitNode[] public disputeKitNodes;

disputes

Dispute[] public disputes;

jurors

mapping(address => Juror) internal jurors;

currencyRates

mapping(IERC20 => CurrencyRate) public currencyRates;

Functions

onlyByGovernor

modifier onlyByGovernor();

constructor

Constructor.

constructor(
    address _governor,
    IERC20 _pinakion,
    address _jurorProsecutionModule,
    IDisputeKit _disputeKit,
    bool _hiddenVotes,
    uint256[4] memory _courtParameters,
    uint256[4] memory _timesPerPeriod,
    bytes memory _sortitionExtraData,
    ISortitionModule _sortitionModuleAddress
);

Parameters

executeGovernorProposal

Allows the governor to call anything on behalf of the contract.

function executeGovernorProposal(address _destination, uint256 _amount, bytes memory _data) external onlyByGovernor;

Parameters

changeGovernor

Changes the governor storage variable.

function changeGovernor(address payable _governor) external onlyByGovernor;

Parameters

changePinakion

Changes the pinakion storage variable.

function changePinakion(IERC20 _pinakion) external onlyByGovernor;

Parameters

changeJurorProsecutionModule

Changes the jurorProsecutionModule storage variable.

function changeJurorProsecutionModule(address _jurorProsecutionModule) external onlyByGovernor;

Parameters

changeSortitionModule

Changes the _sortitionModule storage variable. Note that the new module should be initialized for all courts.

function changeSortitionModule(ISortitionModule _sortitionModule) external onlyByGovernor;

Parameters

addNewDisputeKit

Add a new supported dispute kit module to the court.

function addNewDisputeKit(IDisputeKit _disputeKitAddress, uint256 _parent) external onlyByGovernor;

Parameters

createCourt

Creates a court under a specified parent court.

function createCourt(
    uint96 _parent,
    bool _hiddenVotes,
    uint256 _minStake,
    uint256 _alpha,
    uint256 _feeForJuror,
    uint256 _jurorsForCourtJump,
    uint256[4] memory _timesPerPeriod,
    bytes memory _sortitionExtraData,
    uint256[] memory _supportedDisputeKits
) external onlyByGovernor;

Parameters

changeCourtParameters

function changeCourtParameters(
    uint96 _courtID,
    bool _hiddenVotes,
    uint256 _minStake,
    uint256 _alpha,
    uint256 _feeForJuror,
    uint256 _jurorsForCourtJump,
    uint256[4] memory _timesPerPeriod
) external onlyByGovernor;

enableDisputeKits

Adds/removes court's support for specified dispute kits.

function enableDisputeKits(uint96 _courtID, uint256[] memory _disputeKitIDs, bool _enable) external onlyByGovernor;

Parameters

changeAcceptedFeeTokens

Changes the supported fee tokens.

function changeAcceptedFeeTokens(IERC20 _feeToken, bool _accepted) external onlyByGovernor;

Parameters

changeCurrencyRates

Changes the currency rate of a fee token.

function changeCurrencyRates(IERC20 _feeToken, uint64 _rateInEth, uint8 _rateDecimals) external onlyByGovernor;

Parameters

setStake

Sets the caller's stake in a court.

function setStake(uint96 _courtID, uint256 _stake) external;

Parameters

setStakeBySortitionModule

function setStakeBySortitionModule(address _account, uint96 _courtID, uint256 _stake, uint256 _penalty) external;

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 _numberOfChoices, bytes memory _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 _numberOfChoices, bytes calldata _extraData, IERC20 _feeToken, uint256 _feeAmount)
    external
    override
    returns (uint256 disputeID);

Parameters

Returns

_createDispute

function _createDispute(uint256 _numberOfChoices, bytes memory _extraData, IERC20 _feeToken, uint256 _feeAmount)
    internal
    returns (uint256 disputeID);

passPeriod

Passes the period of a specified dispute.

function passPeriod(uint256 _disputeID) external;

Parameters

draw

Draws jurors for the dispute. Can be called in parts.

function draw(uint256 _disputeID, uint256 _iterations) external;

Parameters

appeal

Appeals the ruling of a specified dispute. Note: Access restricted to the Dispute Kit for this disputeID.

function appeal(uint256 _disputeID, uint256 _numberOfChoices, bytes memory _extraData) external payable;

Parameters

execute

Distribute the PNKs at stake and the dispute fees for the specific round of the dispute. Can be called in parts.

function execute(uint256 _disputeID, uint256 _round, uint256 _iterations) external;

Parameters

_executePenalties

Distribute the PNKs at stake and the dispute fees for the specific round of the dispute, penalties only.

function _executePenalties(ExecuteParams memory _params) internal returns (uint256);

Parameters

Returns

_executeRewards

Distribute the PNKs at stake and the dispute fees for the specific round of the dispute, rewards only.

function _executeRewards(ExecuteParams memory _params) internal;

Parameters

executeRuling

Executes a specified dispute's ruling.

function executeRuling(uint256 _disputeID) external;

Parameters

arbitrationCost

Compute the cost of arbitration denominated in 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 memory _extraData) public view override returns (uint256 cost);

Parameters

Returns

arbitrationCost

Compute the cost of arbitration denominated in _feeToken. 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 _extraData, IERC20 _feeToken) public view override returns (uint256 cost);

Parameters

Returns

appealCost

Gets the cost of appealing a specified dispute.

function appealCost(uint256 _disputeID) public view returns (uint256 cost);

Parameters

Returns

appealPeriod

Gets the start and the end of a specified dispute's current appeal period.

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

Parameters

Returns

currentRuling

Gets the current ruling of a specified dispute.

function currentRuling(uint256 _disputeID) public view returns (uint256 ruling, bool tied, bool overridden);

Parameters

Returns

getRoundInfo

function getRoundInfo(uint256 _disputeID, uint256 _round)
    external
    view
    returns (
        uint256 disputeKitID,
        uint256 pnkAtStakePerJuror,
        uint256 totalFeesForJurors,
        uint256 nbVotes,
        uint256 repartitions,
        uint256 pnkPenalties,
        address[] memory drawnJurors,
        uint256 sumFeeRewardPaid,
        uint256 sumPnkRewardPaid,
        IERC20 feeToken
    );

getNumberOfRounds

function getNumberOfRounds(uint256 _disputeID) external view returns (uint256);

getJurorBalance

function getJurorBalance(address _juror, uint96 _courtID)
    external
    view
    returns (uint256 staked, uint256 locked, uint256 nbCourts);

isSupported

function isSupported(uint96 _courtID, uint256 _disputeKitID) external view returns (bool);

getDisputeKitChildren

Gets non-primitive properties of a specified dispute kit node.

function getDisputeKitChildren(uint256 _disputeKitID) external view returns (uint256[] memory);

Parameters

Returns

getTimesPerPeriod

Gets the timesPerPeriod array for a given court.

function getTimesPerPeriod(uint96 _courtID) external view returns (uint256[4] memory timesPerPeriod);

Parameters

Returns

getNumberOfVotes

Gets the number of votes permitted for the specified dispute in the latest round.

function getNumberOfVotes(uint256 _disputeID) external view returns (uint256);

Parameters

isDisputeKitJumping

Returns true if the dispute kit will be switched to a parent DK.

function isDisputeKitJumping(uint256 _disputeID) external view returns (bool);

Parameters

Returns

getDisputeKitNodesLength

function getDisputeKitNodesLength() external view returns (uint256);

getDisputeKit

Gets the dispute kit for a specific _disputeKitID.

function getDisputeKit(uint256 _disputeKitID) external view returns (IDisputeKit);

Parameters

getJurorCourtIDs

Gets the court identifiers where a specific _juror has staked.

function getJurorCourtIDs(address _juror) public view returns (uint96[] memory);

Parameters

convertEthToTokenAmount

function convertEthToTokenAmount(IERC20 _toToken, uint256 _amountInEth) public view returns (uint256);

_enableDisputeKit

Toggles the dispute kit support for a given court.

function _enableDisputeKit(uint96 _courtID, uint256 _disputeKitID, bool _enable) internal;

Parameters

_setStakeForAccount

Sets the specified juror's stake in a court. O(n + p * log_k(j)) where n is the number of courts the juror has staked in, p is the depth of the court tree, k is the minimum number of children per node of one of these courts' sortition sum tree, and j is the maximum number of jurors that ever staked in one of these courts simultaneously.

function _setStakeForAccount(address _account, uint96 _courtID, uint256 _stake, uint256 _penalty)
    internal
    returns (bool succeeded);

Parameters

Returns

_extraDataToCourtIDMinJurorsDisputeKit

Gets a court ID, the minimum number of jurors and an ID of a dispute kit from a specified extra data bytes array. Note that if extradata contains an incorrect value then this value will be switched to default.

function _extraDataToCourtIDMinJurorsDisputeKit(bytes memory _extraData)
    internal
    view
    returns (uint96 courtID, uint256 minJurors, uint256 disputeKitID);

Parameters

Returns

Events

StakeSet

event StakeSet(address indexed _address, uint256 _courtID, uint256 _amount);

StakeDelayed

event StakeDelayed(address indexed _address, uint256 _courtID, uint256 _amount, uint256 _penalty);

NewPeriod

event NewPeriod(uint256 indexed _disputeID, Period _period);

AppealPossible

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

AppealDecision

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

Draw

event Draw(address indexed _address, uint256 indexed _disputeID, uint256 _roundID, uint256 _voteID);

CourtCreated

event CourtCreated(
    uint256 indexed _courtID,
    uint96 indexed _parent,
    bool _hiddenVotes,
    uint256 _minStake,
    uint256 _alpha,
    uint256 _feeForJuror,
    uint256 _jurorsForCourtJump,
    uint256[4] _timesPerPeriod,
    uint256[] _supportedDisputeKits
);

CourtModified

event CourtModified(
    uint96 indexed _courtID,
    bool _hiddenVotes,
    uint256 _minStake,
    uint256 _alpha,
    uint256 _feeForJuror,
    uint256 _jurorsForCourtJump,
    uint256[4] _timesPerPeriod
);

DisputeKitCreated

event DisputeKitCreated(uint256 indexed _disputeKitID, IDisputeKit indexed _disputeKitAddress, uint256 indexed _parent);

DisputeKitEnabled

event DisputeKitEnabled(uint96 indexed _courtID, uint256 indexed _disputeKitID, bool indexed _enable);

CourtJump

event CourtJump(uint256 indexed _disputeID, uint256 indexed _roundID, uint96 indexed _fromCourtID, uint96 _toCourtID);

DisputeKitJump

event DisputeKitJump(
    uint256 indexed _disputeID, uint256 indexed _roundID, uint256 indexed _fromDisputeKitID, uint256 _toDisputeKitID
);

TokenAndETHShift

event TokenAndETHShift(
    address indexed _account,
    uint256 indexed _disputeID,
    uint256 indexed _roundID,
    uint256 _degreeOfCoherency,
    int256 _pnkAmount,
    int256 _feeAmount,
    IERC20 _feeToken
);

LeftoverRewardSent

event LeftoverRewardSent(
    uint256 indexed _disputeID, uint256 indexed _roundID, uint256 _pnkAmount, uint256 _feeAmount, IERC20 _feeToken
);

Errors

GovernorOnly

error GovernorOnly();

UnsuccessfulCall

error UnsuccessfulCall();

InvalidDisputKitParent

error InvalidDisputKitParent();

DepthLevelMax

error DepthLevelMax();

MinStakeLowerThanParentCourt

error MinStakeLowerThanParentCourt();

UnsupportedDisputeKit

error UnsupportedDisputeKit();

InvalidForkingCourtAsParent

error InvalidForkingCourtAsParent();

WrongDisputeKitIndex

error WrongDisputeKitIndex();

CannotDisableRootDKInGeneral

error CannotDisableRootDKInGeneral();

ArraysLengthMismatch

error ArraysLengthMismatch();

StakingFailed

error StakingFailed();

WrongCaller

error WrongCaller();

ArbitrationFeesNotEnough

error ArbitrationFeesNotEnough();

DisputeKitNotSupportedByCourt

error DisputeKitNotSupportedByCourt();

TokenNotAccepted

error TokenNotAccepted();

EvidenceNotPassedAndNotAppeal

error EvidenceNotPassedAndNotAppeal();

DisputeStillDrawing

error DisputeStillDrawing();

CommitPeriodNotPassed

error CommitPeriodNotPassed();

VotePeriodNotPassed

error VotePeriodNotPassed();

AppealPeriodNotPassed

error AppealPeriodNotPassed();

NotEvidencePeriod

error NotEvidencePeriod();

AppealFeesNotEnough

error AppealFeesNotEnough();

DisputeNotAppealable

error DisputeNotAppealable();

DisputeKitOnly

error DisputeKitOnly();

NotExecutionPeriod

error NotExecutionPeriod();

RulingAlreadyExecuted

error RulingAlreadyExecuted();

DisputePeriodIsFinal

error DisputePeriodIsFinal();

Structs

Court

struct Court {
    uint96 parent;
    bool hiddenVotes;
    uint256[] children;
    uint256 minStake;
    uint256 alpha;
    uint256 feeForJuror;
    uint256 jurorsForCourtJump;
    uint256[4] timesPerPeriod;
    mapping(uint256 => bool) supportedDisputeKits;
    bool disabled;
}

Dispute

struct Dispute {
    uint96 courtID;
    IArbitrableV2 arbitrated;
    Period period;
    bool ruled;
    uint256 lastPeriodChange;
    Round[] rounds;
}

Round

struct Round {
    uint256 disputeKitID;
    uint256 pnkAtStakePerJuror;
    uint256 totalFeesForJurors;
    uint256 nbVotes;
    uint256 repartitions;
    uint256 pnkPenalties;
    address[] drawnJurors;
    uint256 sumFeeRewardPaid;
    uint256 sumPnkRewardPaid;
    IERC20 feeToken;
}

Juror

struct Juror {
    uint96[] courtIDs;
    mapping(uint96 => uint256) stakedPnk;
    mapping(uint96 => uint256) lockedPnk;
}

DisputeKitNode

struct DisputeKitNode {
    uint256 parent;
    uint256[] children;
    IDisputeKit disputeKit;
    uint256 depthLevel;
    bool disabled;
}

ExecuteParams

struct ExecuteParams {
    uint256 disputeID;
    uint256 round;
    uint256 coherentCount;
    uint256 numberOfVotesInRound;
    uint256 pnkPenaltiesInRound;
    uint256 repartition;
}

CurrencyRate

struct CurrencyRate {
    bool feePaymentAccepted;
    uint64 rateInEth;
    uint8 rateDecimals;
}

Enums

Period

enum Period {
    evidence,
    commit,
    vote,
    appeal,
    execution
}