@kleros/kleros-v2-contracts

Smart contracts for Kleros v2

Deployed Addresses

Refresh the list of deployed contracts by running ./scripts/generateDeploymentsMarkdown.sh.

v2-alpha-1

Chiado

• ArbitrableExample
• ForeignGatewayOnGnosis
• SortitionSumTreeFactory
• TokenBridge
• WETH
• WETHFaucet
• WPNKFaucet
• WrappedPinakionV2
• xKlerosLiquidV2

Goerli

• PNK
• ArbitrableExample

Arbitrum Goerli

• PNK
• ArbitrableExampleEthFee
• BlockHashRNG
• DisputeKitClassic
• DisputeResolver
• HomeGatewayToGnosis
• KlerosCore
• PolicyRegistry
• RandomizerRNG
• SortitionModule

Getting Started

Install the Dependencies

yarn install

Run Tests

yarn test

Compile the Contracts

yarn build

Run Linter on Files

yarn lint

Fix Linter Issues on Files

yarn fix

Deploy Instructions

NOTICE: the commands below work only if you are inside the contracts/ directory.

0. Set the Environment Variables

Copy .env.example file as .env and edit it accordingly.

cp .env.example .env

The following env vars are required:

• PRIVATE_KEY: the private key of the deployer account used for the testnets.
• MAINNET_PRIVATE_KEY: the private key of the deployer account used for Mainnet.
• INFURA_API_KEY: the API key for infura.

The ones below are optional:

• ETHERSCAN_API_KEY: to verify the source of the newly deployed contracts on Etherscan.
• ARBISCAN_API_KEY: to verify the source of the newly deployed contracts on Arbitrum.
• GNOSISSCAN_API_KEY: to verify the source of the newly deployed contracts on Gnosis chain.

1. Update the Constructor Parameters (optional)

If some of the constructor parameters (such as the Meta Evidence) needs to change, you need to update the files in the deploy/ directory.

2. Deploy to a Local Network

The complete deployment is multi-chain, so a deployment to the local network can only simulate either the Home chain or the Foreign chain.

Shell 1: the node

yarn hardhat node --tags nothing

Shell 2: the deploy script

yarn deploy --network localhost --tags <Arbitration|VeaMock|ForeignGatewayOnEthereum|HomeGateway>

3. Deploy to Public Testnets

# ArbitrumGoerli to Chiado
yarn deploy --network arbitrumGoerli --tags Arbitration
yarn deploy --network chiado --tags ForeignGatewayOnGnosis
yarn deploy --network chiado --tags KlerosLiquidOnGnosis
yarn deploy --network arbitrumGoerli --tags HomeGatewayToGnosis

# Goerli
yarn deploy --network arbitrumGoerli --tags Arbitration
yarn deploy --network goerli --tags ForeignGatewayOnEthereum
yarn deploy --network arbitrumGoerli --tags HomeGatewayToEthereum

The deployed addresses should be displayed to the screen after the deployment is complete. If you missed them, you can always go to the deployments/<network> directory and look for the respective file.

Running Test Fixtures

Shell 1: the node

yarn hardhat node --tags Arbitration,VeaMock

Shell 2: the test scripts

yarn test --network localhost

4. Verify the Source Code

This must be done for each network separately.

# explorer
yarn etherscan-verify --network <arbitrumGoerli|arbitrum|chiado|gnosischain|goerli|mainnet>

# sourcify
yarn sourcify --network <arbitrumGoerli|arbitrum|chiado|gnosischain|goerli|mainnet>

Ad-hoc procedures

Populating the policy registry and courts

1/ Export the registry data from V1

for network in mainnet gnosischain
do
  yarn hardhat run scripts/getPoliciesV1.ts  --network $network | tee config/policies.v1.$network.json
  yarn hardhat run scripts/getCourtsV1.ts --network $network | tee config/courts.v1.$network.json
done

2/ Import the data to V2 - Local Network

:warning: By default this script populates from *.mainnet.json. To populate from *.gnosischain.json, set the variable USE_GNOSIS to true inside scripts/populateCourts.ts.

:warning: It is possible to switch to testnet-friendly court parameters by setting the variable TESTING_PARAMETERS to true inside scripts/populateCourts.ts.

Shell 1:

yarn hardhat node --tags Arbitration

Shell 2:

yarn hardhat run scripts/populatePolicyRegistry.ts --network localhost
yarn hardhat run scripts/populateCourts.ts --network localhost

3/ Import the data to V2 - Public Testnet

yarn hardhat run scripts/populatePolicyRegistry.ts --network arbitrumGoerli
yarn hardhat run scripts/populateCourts.ts --network arbitrumGoerli

Generate deployment artifacts for existing contracts

Usage

scripts/generateDeploymentArtifact.sh <network> <address>

Example: WETH on Gnosis chain

scripts/generateDeploymentArtifact.sh gnosischain 0xf8d1677c8a0c961938bf2f9adc3f3cfda759a9d9 > deployments/gnosischain/WETH.json

Push the contracts to a Tenderly project

Ensure that your $TENDERLY_PROJECT and $TENDERLY_USERNAME is set correctly in .env.

yarn hardhat --network goerli tenderly:push
yarn hardhat --network arbitrumGoerli tenderly:push

Contents

• arbitrables
• dispute-kits
• CentralizedArbitrator
• IArbitrable
• IArbitrator
• IDisputeKit
• ISortitionModule
• KlerosCore
• KlerosGovernor
• PolicyRegistry
• SortitionModule

Contents

• ArbitrableExample
• ArbitrableExampleEthFee
• DisputeResolver

ArbitrableExample

Git Source

Inherits: IArbitrable, IMetaEvidence

State Variables

governor

address public immutable governor;

arbitrator

IArbitrator public arbitrator;

weth

ERC20 public immutable weth;

externalIDtoLocalID

mapping(uint256 => uint256) public externalIDtoLocalID;

disputes

DisputeStruct[] public disputes;

Functions

constructor

Constructor

constructor(IArbitrator _arbitrator, uint256 _metaEvidenceID, string memory _metaEvidence, ERC20 _weth);

Parameters

createDispute

TRUSTED. Calls createDispute function of the specified arbitrator to create a dispute. Note that we don’t need to check that msg.value is enough to pay arbitration fees as it’s the responsibility of the arbitrator contract.

function createDispute(
    uint256 _numberOfRulingOptions,
    bytes calldata _arbitratorExtraData,
    uint256 _metaEvidenceID,
    uint256 _evidenceGroupID,
    uint256 _feeInWeth
) external payable returns (uint256 disputeID);

Parameters

Returns

rule

To be called by the arbitrator of the dispute, to declare the winning ruling.

function rule(uint256 _externalDisputeID, uint256 _ruling) external override;

Parameters

changeMetaEvidence

function changeMetaEvidence(uint256 _metaEvidenceID, string memory _metaEvidence) external;

changeArbitrator

function changeArbitrator(IArbitrator _arbitrator) external;

Structs

DisputeStruct

struct DisputeStruct {
    bool isRuled;
    uint256 ruling;
    uint256 numberOfRulingOptions;
}

ArbitrableExampleEthFee

Git Source

Inherits: IArbitrable, IMetaEvidence

State Variables

META_EVIDENCE_ID

uint256 META_EVIDENCE_ID = 0;

governor

address public governor;

arbitrator

IArbitrator public immutable arbitrator;

externalIDtoLocalID

mapping(uint256 => uint256) public externalIDtoLocalID;

disputes

DisputeStruct[] public disputes;

Functions

constructor

Constructor

constructor(IArbitrator _arbitrator, string memory _metaEvidence);

Parameters

createDispute

TRUSTED. Calls createDispute function of the specified arbitrator to create a dispute. Note that we don’t need to check that msg.value is enough to pay arbitration fees as it’s the responsibility of the arbitrator contract.

function createDispute(uint256 _numberOfRulingOptions, bytes calldata _arbitratorExtraData, uint256 _evidenceGroupID)
    external
    payable
    returns (uint256 disputeID);

Parameters

Returns

rule

To be called by the arbitrator of the dispute, to declare the winning ruling.

function rule(uint256 _externalDisputeID, uint256 _ruling) external override;

Parameters

changeMetaEvidence

function changeMetaEvidence(string memory _metaEvidence) external;

Structs

DisputeStruct

struct DisputeStruct {
    bool isRuled;
    uint256 ruling;
    uint256 numberOfRulingOptions;
}

DisputeResolver

Git Source

Inherits: IArbitrable, IMetaEvidence

State Variables

arbitrator

IArbitrator public immutable arbitrator;

disputes

DisputeStruct[] public disputes;

externalIDtoLocalID

mapping(uint256 => uint256) public externalIDtoLocalID;

Functions

constructor

Constructor

constructor(IArbitrator _arbitrator);

Parameters

createDispute

TRUSTED. Calls createDispute function of the specified arbitrator to create a dispute. Note that we don’t need to check that msg.value is enough to pay arbitration fees as it’s the responsibility of the arbitrator contract.

function createDispute(
    bytes calldata _arbitratorExtraData,
    string calldata _metaevidenceURI,
    uint256 _numberOfRulingOptions
) external payable returns (uint256 disputeID);

Parameters

Returns

rule

To be called by the arbitrator of the dispute, to declare the winning ruling.

function rule(uint256 _externalDisputeID, uint256 _ruling) external override;

Parameters

Structs

DisputeStruct

struct DisputeStruct {
    bytes arbitratorExtraData;
    bool isRuled;
    uint256 ruling;
    uint256 numberOfRulingOptions;
}

Contents

• BaseDisputeKit
• DisputeKitClassic
• IProofOfHumanity
• DisputeKitSybilResistant

BaseDisputeKit

Git Source

Inherits: IDisputeKit

State Variables

governor

address public governor;

core

KlerosCore public core;

Functions

onlyByGovernor

modifier onlyByGovernor();

onlyByCore

modifier onlyByCore();

constructor

Constructor.

constructor(address _governor, KlerosCore _core);

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

_postDrawCheck

Checks that the chosen address satisfies certain conditions for being drawn.

function _postDrawCheck(uint256 _coreDisputeID, address _juror) internal virtual returns (bool);

Parameters

Returns

DisputeKitClassic

Git Source

Inherits: BaseDisputeKit, IEvidence

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;

ONE_BASIS_POINT

uint256 public constant ONE_BASIS_POINT = 10000;

disputes

Dispute[] public disputes;

coreDisputeIDToLocal

mapping(uint256 => uint256) public coreDisputeIDToLocal;

Functions

notJumped

modifier notJumped(uint256 _coreDisputeID);

constructor

Constructor.

constructor(address _governor, KlerosCore _core) BaseDisputeKit(_governor, _core);

Parameters

changeGovernor

Changes the governor storage variable.

function changeGovernor(address payable _governor) external onlyByGovernor;

Parameters

changeCore

Changes the core storage variable.

function changeCore(address _core) external onlyByGovernor;

Parameters

createDispute

Creates a local dispute and maps it to the dispute ID in the Core contract. Note: Access restricted to Kleros Core only.

function createDispute(uint256 _coreDisputeID, uint256 _numberOfChoices, bytes calldata _extraData, uint256 _nbVotes)
    external
    override
    onlyByCore;

Parameters

draw

Draws the juror from the sortition tree. The drawn address is picked up by Kleros Core. Note: Access restricted to Kleros Core only.

function draw(uint256 _coreDisputeID)
    external
    override
    onlyByCore
    notJumped(_coreDisputeID)
    returns (address drawnAddress);

Parameters

Returns

castCommit

Sets the caller's commit for the specified votes. It can be called multiple times during the commit period, each call overrides the commits of the previous one. O(n) where n is the number of votes.

function castCommit(uint256 _coreDisputeID, uint256[] calldata _voteIDs, bytes32 _commit)
    external
    notJumped(_coreDisputeID);

Parameters

castVote

Sets the caller's choices for the specified votes. O(n) where n is the number of votes.

function castVote(
    uint256 _coreDisputeID,
    uint256[] calldata _voteIDs,
    uint256 _choice,
    uint256 _salt,
    string memory _justification
) external notJumped(_coreDisputeID);

Parameters

fundAppeal

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

function fundAppeal(uint256 _coreDisputeID, uint256 _choice) external payable notJumped(_coreDisputeID);

Parameters

withdrawFeesAndRewards

Allows those contributors who attempted to fund an appeal round to withdraw any reimbursable fees or rewards after the dispute gets resolved.

function withdrawFeesAndRewards(
    uint256 _coreDisputeID,
    address payable _beneficiary,
    uint256 _coreRoundID,
    uint256 _choice
) external returns (uint256 amount);

Parameters

Returns

submitEvidence

Submits evidence.

function submitEvidence(uint256 _evidenceGroupID, string calldata _evidence) external;

Parameters

getFundedChoices

function getFundedChoices(uint256 _coreDisputeID) public view returns (uint256[] memory fundedChoices);

currentRuling

Gets the current ruling of a specified dispute.

function currentRuling(uint256 _coreDisputeID)
    external
    view
    override
    returns (uint256 ruling, bool tied, bool overridden);

Parameters

Returns

getDegreeOfCoherence

Gets the degree of coherence of a particular voter. This function is called by Kleros Core in order to determine the amount of the reward.

function getDegreeOfCoherence(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _voteID)
    external
    view
    override
    returns (uint256);

Parameters

Returns

getCoherentCount

Gets the number of jurors who are eligible to a reward in this round.

function getCoherentCount(uint256 _coreDisputeID, uint256 _coreRoundID) external view override returns (uint256);

Parameters

Returns

areCommitsAllCast

Returns true if all of the jurors have cast their commits for the last round.

function areCommitsAllCast(uint256 _coreDisputeID) external view override returns (bool);

Parameters

Returns

areVotesAllCast

Returns true if all of the jurors have cast their votes for the last round.

function areVotesAllCast(uint256 _coreDisputeID) external view override returns (bool);

Parameters

Returns

isVoteActive

Returns true if the specified voter was active in this round.

function isVoteActive(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _voteID)
    external
    view
    override
    returns (bool);

Parameters

Returns

getRoundInfo

function getRoundInfo(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _choice)
    external
    view
    override
    returns (
        uint256 winningChoice,
        bool tied,
        uint256 totalVoted,
        uint256 totalCommited,
        uint256 nbVoters,
        uint256 choiceCount
    );

getVoteInfo

function getVoteInfo(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _voteID)
    external
    view
    override
    returns (address account, bytes32 commit, uint256 choice, bool voted);

_postDrawCheck

Checks that the chosen address satisfies certain conditions for being drawn.

function _postDrawCheck(uint256 _coreDisputeID, address _juror) internal view override returns (bool);

Parameters

Returns

Events

DisputeCreation

event DisputeCreation(uint256 indexed _coreDisputeID, uint256 _numberOfChoices, bytes _extraData);

CommitCast

event CommitCast(uint256 indexed _coreDisputeID, uint256[] _voteIDs, bytes32 _commit);

Contribution

event Contribution(
    uint256 indexed _coreDisputeID,
    uint256 indexed _coreRoundID,
    uint256 _choice,
    address indexed _contributor,
    uint256 _amount
);

Withdrawal

event Withdrawal(
    uint256 indexed _coreDisputeID,
    uint256 indexed _coreRoundID,
    uint256 _choice,
    address indexed _contributor,
    uint256 _amount
);

ChoiceFunded

event ChoiceFunded(uint256 indexed _coreDisputeID, uint256 indexed _coreRoundID, uint256 indexed _choice);

Structs

Dispute

struct Dispute {
    Round[] rounds;
    uint256 numberOfChoices;
    bool jumped;
    mapping(uint256 => uint256) coreRoundIDToLocal;
    bytes extraData;
}

Round

struct Round {
    Vote[] votes;
    uint256 winningChoice;
    mapping(uint256 => uint256) counts;
    bool tied;
    uint256 totalVoted;
    uint256 totalCommitted;
    mapping(uint256 => uint256) paidFees;
    mapping(uint256 => bool) hasPaid;
    mapping(address => mapping(uint256 => uint256)) contributions;
    uint256 feeRewards;
    uint256[] fundedChoices;
    uint256 nbVotes;
}

Vote

struct Vote {
    address account;
    bytes32 commit;
    uint256 choice;
    bool voted;
}

IProofOfHumanity

Git Source

Functions

isRegistered

Return true if the submission is registered and not expired.

function isRegistered(address _submissionID) external view returns (bool);

Parameters

Returns

DisputeKitSybilResistant

Git Source

Inherits: BaseDisputeKit, IEvidence

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;

ONE_BASIS_POINT

uint256 public constant ONE_BASIS_POINT = 10000;

poh

IProofOfHumanity public poh;

disputes

Dispute[] public disputes;

coreDisputeIDToLocal

mapping(uint256 => uint256) public coreDisputeIDToLocal;

Functions

notJumped

modifier notJumped(uint256 _coreDisputeID);

constructor

Constructor.

constructor(address _governor, KlerosCore _core, IProofOfHumanity _poh) BaseDisputeKit(_governor, _core);

Parameters

changeGovernor

Changes the governor storage variable.

function changeGovernor(address payable _governor) external onlyByGovernor;

Parameters

changeCore

Changes the core storage variable.

function changeCore(address _core) external onlyByGovernor;

Parameters

changePoh

Changes the poh storage variable.

function changePoh(address _poh) external onlyByGovernor;

Parameters

createDispute

Creates a local dispute and maps it to the dispute ID in the Core contract. Note: Access restricted to Kleros Core only.

function createDispute(uint256 _coreDisputeID, uint256 _numberOfChoices, bytes calldata _extraData, uint256 _nbVotes)
    external
    override
    onlyByCore;

Parameters

draw

Draws the juror from the sortition tree. The drawn address is picked up by Kleros Core. Note: Access restricted to Kleros Core only.

function draw(uint256 _coreDisputeID)
    external
    override
    onlyByCore
    notJumped(_coreDisputeID)
    returns (address drawnAddress);

Parameters

Returns

castCommit

Sets the caller's commit for the specified votes. It can be called multiple times during the commit period, each call overrides the commits of the previous one. O(n) where n is the number of votes.

function castCommit(uint256 _coreDisputeID, uint256[] calldata _voteIDs, bytes32 _commit)
    external
    notJumped(_coreDisputeID);

Parameters

castVote

Sets the caller's choices for the specified votes. O(n) where n is the number of votes.

function castVote(
    uint256 _coreDisputeID,
    uint256[] calldata _voteIDs,
    uint256 _choice,
    uint256 _salt,
    string memory _justification
) external notJumped(_coreDisputeID);

Parameters

fundAppeal

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

function fundAppeal(uint256 _coreDisputeID, uint256 _choice) external payable notJumped(_coreDisputeID);

Parameters

withdrawFeesAndRewards

Allows those contributors who attempted to fund an appeal round to withdraw any reimbursable fees or rewards after the dispute gets resolved.

function withdrawFeesAndRewards(
    uint256 _coreDisputeID,
    address payable _beneficiary,
    uint256 _coreRoundID,
    uint256 _choice
) external returns (uint256 amount);

Parameters

Returns

submitEvidence

Submits evidence.

function submitEvidence(uint256 _evidenceGroupID, string calldata _evidence) external;

Parameters

getFundedChoices

function getFundedChoices(uint256 _coreDisputeID) public view returns (uint256[] memory fundedChoices);

currentRuling

Gets the current ruling of a specified dispute.

function currentRuling(uint256 _coreDisputeID)
    external
    view
    override
    returns (uint256 ruling, bool tied, bool overridden);

Parameters

Returns

getDegreeOfCoherence

Gets the degree of coherence of a particular voter. This function is called by Kleros Core in order to determine the amount of the reward.

function getDegreeOfCoherence(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _voteID)
    external
    view
    override
    returns (uint256);

Parameters

Returns

getCoherentCount

Gets the number of jurors who are eligible to a reward in this round.

function getCoherentCount(uint256 _coreDisputeID, uint256 _coreRoundID) external view override returns (uint256);

Parameters

Returns

areCommitsAllCast

Returns true if all of the jurors have cast their commits for the last round.

function areCommitsAllCast(uint256 _coreDisputeID) external view override returns (bool);

Parameters

Returns

areVotesAllCast

Returns true if all of the jurors have cast their votes for the last round.

function areVotesAllCast(uint256 _coreDisputeID) external view override returns (bool);

Parameters

Returns

isVoteActive

Returns true if the specified voter was active in this round.

function isVoteActive(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _voteID)
    external
    view
    override
    returns (bool);

Parameters

Returns

getRoundInfo

function getRoundInfo(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _choice)
    external
    view
    override
    returns (
        uint256 winningChoice,
        bool tied,
        uint256 totalVoted,
        uint256 totalCommited,
        uint256 nbVoters,
        uint256 choiceCount
    );

getVoteInfo

function getVoteInfo(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _voteID)
    external
    view
    override
    returns (address account, bytes32 commit, uint256 choice, bool voted);

_postDrawCheck

Checks that the chosen address satisfies certain conditions for being drawn.

function _postDrawCheck(uint256 _coreDisputeID, address _juror) internal view override returns (bool);

Parameters

Returns

_proofOfHumanity

Checks if an address belongs to the Proof of Humanity registry.

function _proofOfHumanity(address _address) internal view returns (bool);

Parameters

Returns

Events

DisputeCreation

event DisputeCreation(uint256 indexed _coreDisputeID, uint256 _numberOfChoices, bytes _extraData);

CommitCast

event CommitCast(uint256 indexed _coreDisputeID, uint256[] _voteIDs, bytes32 _commit);

Contribution

event Contribution(
    uint256 indexed _coreDisputeID,
    uint256 indexed _coreRoundID,
    uint256 _choice,
    address indexed _contributor,
    uint256 _amount
);

Withdrawal

event Withdrawal(
    uint256 indexed _coreDisputeID,
    uint256 indexed _coreRoundID,
    uint256 _choice,
    address indexed _contributor,
    uint256 _amount
);

ChoiceFunded

event ChoiceFunded(uint256 indexed _coreDisputeID, uint256 indexed _coreRoundID, uint256 indexed _choice);

Structs

Dispute

struct Dispute {
    Round[] rounds;
    uint256 numberOfChoices;
    bool jumped;
    mapping(uint256 => uint256) coreRoundIDToLocal;
    bytes extraData;
}

Round

struct Round {
    Vote[] votes;
    uint256 winningChoice;
    mapping(uint256 => uint256) counts;
    bool tied;
    uint256 totalVoted;
    uint256 totalCommitted;
    mapping(uint256 => uint256) paidFees;
    mapping(uint256 => bool) hasPaid;
    mapping(address => mapping(uint256 => uint256)) contributions;
    uint256 feeRewards;
    uint256[] fundedChoices;
    uint256 nbVotes;
    mapping(address => bool) alreadyDrawn;
}

Vote

struct Vote {
    address account;
    bytes32 commit;
    uint256 choice;
    bool voted;
}

CentralizedArbitrator

Git Source

Inherits: IArbitrator

This is a centralized arbitrator deciding alone on the result of disputes. It illustrates how IArbitrator 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. Must be called by the arbitrable contract. Must be paid at least arbitrationCost().

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

Parameters

Returns

fundAppeal

TRUSTED. 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

Cost of arbitration.

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

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

Events

AppealPossible

To be emitted when a dispute can be appealed.

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

AppealDecision

To be emitted when the current ruling is appealed.

event AppealDecision(uint256 indexed _disputeID, IArbitrable 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 {
    IArbitrable 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
}

IArbitrable

Git Source

Functions

rule

Give a ruling for a dispute. Must be called by the arbitrator. The purpose of this function is to ensure that the address calling it has the right to rule on the contract.

function rule(uint256 _disputeID, uint256 _ruling) external;

Parameters

Events

Ruling

To be raised when a ruling is given.

event Ruling(IArbitrator indexed _arbitrator, uint256 indexed _disputeID, uint256 _ruling);

IArbitrator

Git Source

Functions

createDispute

Create a dispute. Must be called by the arbitrable contract. Must pay at least arbitrationCost(_extraData).

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

Parameters

Returns

arbitrationCost

Compute the cost of arbitration. 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) external view returns (uint256 cost);

Parameters

Returns

Events

DisputeCreation

To be emitted when a dispute is created.

event DisputeCreation(uint256 indexed _disputeID, IArbitrable indexed _arbitrable);

Ruling

To be raised when a ruling is given.

event Ruling(IArbitrable indexed _arbitrable, uint256 indexed _disputeID, uint256 _ruling);

IDisputeKit

Git Source

Functions

createDispute

Creates a local dispute and maps it to the dispute ID in the Core contract. Note: Access restricted to Kleros Core only.

function createDispute(uint256 _coreDisputeID, uint256 _numberOfChoices, bytes calldata _extraData, uint256 _nbVotes)
    external;

Parameters

draw

Draws the juror from the sortition tree. The drawn address is picked up by Kleros Core. Note: Access restricted to Kleros Core only.

function draw(uint256 _coreDisputeID) external returns (address drawnAddress);

Parameters

Returns

currentRuling

Gets the current ruling of a specified dispute.

function currentRuling(uint256 _coreDisputeID) external view returns (uint256 ruling, bool tied, bool overridden);

Parameters

Returns

getDegreeOfCoherence

Gets the degree of coherence of a particular voter. This function is called by Kleros Core in order to determine the amount of the reward.

function getDegreeOfCoherence(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _voteID)
    external
    view
    returns (uint256);

Parameters

Returns

getCoherentCount

Gets the number of jurors who are eligible to a reward in this round.

function getCoherentCount(uint256 _coreDisputeID, uint256 _coreRoundID) external view returns (uint256);

Parameters

Returns

areCommitsAllCast

Returns true if all of the jurors have cast their commits for the last round.

function areCommitsAllCast(uint256 _coreDisputeID) external view returns (bool);

Parameters

Returns

areVotesAllCast

Returns true if all of the jurors have cast their votes for the last round.

function areVotesAllCast(uint256 _coreDisputeID) external view returns (bool);

Parameters

Returns

isVoteActive

Returns true if the specified voter was active in this round.

function isVoteActive(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _voteID) external view returns (bool);

Parameters

Returns

getRoundInfo

function getRoundInfo(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _choice)
    external
    view
    returns (
        uint256 winningChoice,
        bool tied,
        uint256 totalVoted,
        uint256 totalCommited,
        uint256 nbVoters,
        uint256 choiceCount
    );

getVoteInfo

function getVoteInfo(uint256 _coreDisputeID, uint256 _coreRoundID, uint256 _voteID)
    external
    view
    returns (address account, bytes32 commit, uint256 choice, bool voted);

Events

Justification

Emitted when casting a vote to provide the justification of juror's choice.

event Justification(
    uint256 indexed _coreDisputeID, address indexed _juror, uint256 indexed _choice, string _justification
);

ISortitionModule

Git Source

Functions

createTree

function createTree(bytes32 _key, bytes memory _extraData) external;

setStake

function setStake(address _account, uint96 _courtID, uint256 _value) external;

setJurorInactive

function setJurorInactive(address _account) external;

notifyRandomNumber

function notifyRandomNumber(uint256 _drawnNumber) external;

draw

function draw(bytes32 _court, uint256 _coreDisputeID, uint256 _voteID) external view returns (address);

preStakeHook

function preStakeHook(address _account, uint96 _courtID, uint256 _stake, uint256 _penalty)
    external
    returns (preStakeHookResult);

createDisputeHook

function createDisputeHook(uint256 _disputeID, uint256 _roundID) external;

postDrawHook

function postDrawHook(uint256 _disputeID, uint256 _roundID) external;

Events

NewPhase

event NewPhase(Phase _phase);

Enums

Phase

enum Phase {
    staking,
    generating,
    drawing
}

preStakeHookResult

enum preStakeHookResult {
    ok,
    delayed,
    failed
}

KlerosCore

Git Source

Inherits: IArbitrator

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;

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;

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

changeCourtMinStake

Changes the minStake property value of a specified court. Don't set to a value lower than its parent's minStake property value.

function changeCourtMinStake(uint96 _courtID, uint256 _minStake) external onlyByGovernor;

Parameters

changeCourtAlpha

Changes the alpha property value of a specified court.

function changeCourtAlpha(uint96 _courtID, uint256 _alpha) external onlyByGovernor;

Parameters

changeCourtJurorFee

Changes the feeForJuror property value of a specified court.

function changeCourtJurorFee(uint96 _courtID, uint256 _feeForJuror) external onlyByGovernor;

Parameters

changeCourtJurorsForJump

Changes the jurorsForCourtJump property value of a specified court.

function changeCourtJurorsForJump(uint96 _courtID, uint256 _jurorsForCourtJump) external onlyByGovernor;

Parameters

changeCourtHiddenVotes

Changes the hiddenVotes property value of a specified court.

function changeCourtHiddenVotes(uint96 _courtID, bool _hiddenVotes) external onlyByGovernor;

Parameters

changeCourtTimesPerPeriod

Changes the timesPerPeriod property value of a specified court.

function changeCourtTimesPerPeriod(uint96 _courtID, uint256[4] memory _timesPerPeriod) external onlyByGovernor;

Parameters

enableDisputeKits

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

function enableDisputeKits(uint96 _courtID, uint256[] memory _disputeKitIDs, bool _enable) 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

Creates a dispute. Must be called by the arbitrable contract.

function createDispute(uint256 _numberOfChoices, bytes memory _extraData)
    external
    payable
    override
    returns (uint256 disputeID);

Parameters

Returns

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 tokens and ETH 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 tokens and ETH for the specific round of the dispute, penalties only.

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

Parameters

Returns

_executeRewards

Distribute the tokens and ETH for the specific round of the dispute, rewards only.

function _executeRewards(ExecuteParams memory _params) internal;

Parameters

executeRuling

Executes a specified dispute's ruling. UNTRUSTED.

function executeRuling(uint256 _disputeID) external;

Parameters

arbitrationCost

Gets the cost of arbitration in a specified court.

function arbitrationCost(bytes memory _extraData) 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 tokensAtStakePerJuror,
        uint256 totalFeesForJurors,
        uint256 repartitions,
        uint256 penalties,
        address[] memory drawnJurors,
        uint256 disputeKitID,
        uint256 sumRewardPaid,
        uint256 sumTokenRewardPaid
    );

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

_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

_safeTransfer

Calls transfer() without reverting.

function _safeTransfer(address _to, uint256 _value) internal returns (bool);

Parameters

Returns

_safeTransferFrom

Calls transferFrom() without reverting.

function _safeTransferFrom(address _from, address _to, uint256 _value) internal returns (bool);

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, IArbitrable indexed _arbitrable);

AppealDecision

event AppealDecision(uint256 indexed _disputeID, IArbitrable 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, string _param);

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 _tokenAmount,
    int256 _ethAmount
);

LeftoverRewardSent

event LeftoverRewardSent(
    uint256 indexed _disputeID, uint256 indexed _roundID, uint256 _tokenAmount, uint256 _ethAmount
);

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;
    IArbitrable arbitrated;
    Period period;
    bool ruled;
    uint256 lastPeriodChange;
    Round[] rounds;
}

Round

struct Round {
    uint256 disputeKitID;
    uint256 tokensAtStakePerJuror;
    uint256 totalFeesForJurors;
    uint256 nbVotes;
    uint256 repartitions;
    uint256 penalties;
    address[] drawnJurors;
    uint256 sumRewardPaid;
    uint256 sumTokenRewardPaid;
}

Juror

struct Juror {
    uint96[] courtIDs;
    mapping(uint96 => uint256) stakedTokens;
    mapping(uint96 => uint256) lockedTokens;
}

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 penaltiesInRound;
    uint256 repartition;
}

Enums

Period

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

KlerosGovernor

Git Source

Inherits: IArbitrable, IMetaEvidence

State Variables

arbitrator

IArbitrator public arbitrator;

arbitratorExtraData

bytes public arbitratorExtraData;

metaEvidenceUpdates

uint256 public metaEvidenceUpdates;

submissionBaseDeposit

uint256 public submissionBaseDeposit;

submissionTimeout

uint256 public submissionTimeout;

executionTimeout

uint256 public executionTimeout;

withdrawTimeout

uint256 public withdrawTimeout;

lastApprovalTime

uint256 public lastApprovalTime;

reservedETH

uint256 public reservedETH;

submissions

Submission[] public submissions;

sessions

Session[] public sessions;

Functions

duringSubmissionPeriod

modifier duringSubmissionPeriod();

duringApprovalPeriod

modifier duringApprovalPeriod();

onlyByGovernor

modifier onlyByGovernor();

constructor

Constructor.

constructor(
    IArbitrator _arbitrator,
    bytes memory _arbitratorExtraData,
    string memory _metaEvidence,
    uint256 _submissionBaseDeposit,
    uint256 _submissionTimeout,
    uint256 _executionTimeout,
    uint256 _withdrawTimeout
);

Parameters

changeSubmissionDeposit

Changes the value of the base deposit required for submitting a list.

function changeSubmissionDeposit(uint256 _submissionBaseDeposit) external onlyByGovernor;

Parameters

changeSubmissionTimeout

Changes the time allocated for submission. Note that it can't be changed during approval period because there can be an active dispute in the old arbitrator contract and prolonging submission timeout might switch it back to submission period.

function changeSubmissionTimeout(uint256 _submissionTimeout) external onlyByGovernor duringSubmissionPeriod;

Parameters

changeExecutionTimeout

Changes the time allocated for list's execution.

function changeExecutionTimeout(uint256 _executionTimeout) external onlyByGovernor;

Parameters

changeWithdrawTimeout

Changes list withdrawal timeout. Note that withdrawals are only possible in the first half of the submission period.

function changeWithdrawTimeout(uint256 _withdrawTimeout) external onlyByGovernor;

Parameters

changeArbitrator

Changes the arbitrator of the contract. Note that it can't be changed during approval period because there can be an active dispute in the old arbitrator contract.

function changeArbitrator(IArbitrator _arbitrator, bytes memory _arbitratorExtraData)
    external
    onlyByGovernor
    duringSubmissionPeriod;

Parameters

changeMetaEvidence

Update the meta evidence used for disputes.

function changeMetaEvidence(string memory _metaEvidence) external onlyByGovernor;

Parameters

submitList

Creates transaction list based on input parameters and submits it for potential approval and execution. Transactions must be ordered by their hash.

function submitList(
    address[] memory _target,
    uint256[] memory _value,
    bytes memory _data,
    uint256[] memory _dataSize,
    string memory _description
) external payable duringSubmissionPeriod;

Parameters

withdrawTransactionList

Withdraws submitted transaction list. Reimburses submission deposit. Withdrawal is only possible during the first half of the submission period and during withdrawTimeout after the submission is made.

function withdrawTransactionList(uint256 _submissionID, bytes32 _listHash) external;

Parameters

executeSubmissions

Approves a transaction list or creates a dispute if more than one list was submitted. TRUSTED. If nothing was submitted changes session.

function executeSubmissions() external duringApprovalPeriod;

rule

Gives a ruling for a dispute. Must be called by the arbitrator.

function rule(uint256 _disputeID, uint256 _ruling) external override;

Parameters

executeTransactionList

Executes selected transactions of the list. UNTRUSTED.

function executeTransactionList(uint256 _listID, uint256 _cursor, uint256 _count) external;

Parameters

receive

Receive function to receive funds for the execution of transactions.

receive() external payable;

getExpendableFunds

Gets the sum of contract funds that are used for the execution of transactions.

function getExpendableFunds() public view returns (uint256);

Returns

getTransactionInfo

Gets the info of the specific transaction in the specific list.

function getTransactionInfo(uint256 _listID, uint256 _transactionIndex)
    external
    view
    returns (address target, uint256 value, bytes memory data, bool executed);

Parameters

Returns

getSubmittedLists

Gets the array of submitted lists in the session. Note that this function is O(n), where n is the number of submissions in the session. This could exceed the gas limit, therefore this function should only be used for interface display and not by other contracts.

function getSubmittedLists(uint256 _session) external view returns (uint256[] memory submittedLists);

Parameters

Returns

getNumberOfTransactions

Gets the number of transactions in the list.

function getNumberOfTransactions(uint256 _listID) external view returns (uint256 txCount);

Parameters

Returns

getNumberOfCreatedLists

Gets the number of lists created in contract's lifetime.

function getNumberOfCreatedLists() external view returns (uint256);

Returns

getCurrentSessionNumber

Gets the number of the ongoing session.

function getCurrentSessionNumber() external view returns (uint256);

Returns

Events

ListSubmitted

Emitted when a new list is submitted.

event ListSubmitted(uint256 indexed _listID, address indexed _submitter, uint256 indexed _session, string _description);

Structs

Session

struct Session {
    uint256 ruling;
    uint256 disputeID;
    uint256[] submittedLists;
    uint256 sumDeposit;
    Status status;
    mapping(bytes32 => bool) alreadySubmitted;
    uint256 durationOffset;
}

Transaction

struct Transaction {
    address target;
    uint256 value;
    bytes data;
    bool executed;
}

Submission

struct Submission {
    address payable submitter;
    uint256 deposit;
    Transaction[] txs;
    bytes32 listHash;
    uint256 submissionTime;
    bool approved;
    uint256 approvalTime;
}

Enums

Status

enum Status {
    NoDispute,
    DisputeCreated,
    Resolved
}

PolicyRegistry

Git Source

Author: Enrique Piqueras - epiquerass@gmail.com

A contract to maintain a policy for each court.

State Variables

governor

address public governor;

policies

mapping(uint256 => string) public policies;

Functions

onlyByGovernor

Requires that the sender is the governor.

modifier onlyByGovernor();

constructor

Constructs the PolicyRegistry contract.

constructor(address _governor);

Parameters

changeGovernor

Changes the governor storage variable.

function changeGovernor(address _governor) external onlyByGovernor;

Parameters

setPolicy

Sets the policy for the specified court.

function setPolicy(uint256 _courtID, string calldata _courtName, string calldata _policy) external onlyByGovernor;

Parameters

Events

PolicyUpdate

Emitted when a policy is updated.

event PolicyUpdate(uint256 indexed _courtID, string _courtName, string _policy);

SortitionModule

Git Source

Inherits: ISortitionModule

A factory of trees that keeps track of staked values for sortition.

State Variables

MAX_STAKE_PATHS

uint256 public constant MAX_STAKE_PATHS = 4;

DEFAULT_K

uint256 public constant DEFAULT_K = 6;

governor

address public governor;

core

KlerosCore public core;

phase

Phase public phase;

minStakingTime

uint256 public minStakingTime;

maxDrawingTime

uint256 public maxDrawingTime;

lastPhaseChange

uint256 public lastPhaseChange;

randomNumberRequestBlock

uint256 public randomNumberRequestBlock;

disputesWithoutJurors

uint256 public disputesWithoutJurors;

rng

RNG public rng;

randomNumber

uint256 public randomNumber;

rngLookahead

uint256 public rngLookahead;

delayedStakeWriteIndex

uint256 public delayedStakeWriteIndex;

delayedStakeReadIndex

uint256 public delayedStakeReadIndex = 1;

sortitionSumTrees

mapping(bytes32 => SortitionSumTree) sortitionSumTrees;

delayedStakes

mapping(uint256 => DelayedStake) public delayedStakes;

Functions

onlyByGovernor

modifier onlyByGovernor();

onlyByCore

modifier onlyByCore();

constructor

Constructor.

constructor(
    address _governor,
    KlerosCore _core,
    uint256 _minStakingTime,
    uint256 _maxDrawingTime,
    RNG _rng,
    uint256 _rngLookahead
);

Parameters

changeMinStakingTime

Changes the minStakingTime storage variable.

function changeMinStakingTime(uint256 _minStakingTime) external onlyByGovernor;

Parameters

changeMaxDrawingTime

Changes the maxDrawingTime storage variable.

function changeMaxDrawingTime(uint256 _maxDrawingTime) external onlyByGovernor;

Parameters

changeRandomNumberGenerator

Changes the _rng and _rngLookahead storage variables.

function changeRandomNumberGenerator(RNG _rng, uint256 _rngLookahead) external onlyByGovernor;

Parameters

passPhase

function passPhase() external;

createTree

Create a sortition sum tree at the specified key.

function createTree(bytes32 _key, bytes memory _extraData) external override onlyByCore;

Parameters

executeDelayedStakes

Executes the next delayed stakes.

function executeDelayedStakes(uint256 _iterations) external;

Parameters

preStakeHook

function preStakeHook(address _account, uint96 _courtID, uint256 _stake, uint256 _penalty)
    external
    override
    onlyByCore
    returns (preStakeHookResult);

createDisputeHook

function createDisputeHook(uint256, uint256) external override onlyByCore;

postDrawHook

function postDrawHook(uint256, uint256) external override onlyByCore;

notifyRandomNumber

Saves the random number to use it in sortition. Not used by this contract because the storing of the number is inlined in passPhase().

function notifyRandomNumber(uint256 _randomNumber) public override;

Parameters

setStake

Sets the value for a particular court and its parent courts.

function setStake(address _account, uint96 _courtID, uint256 _value) external override onlyByCore;

Parameters

setJurorInactive

Unstakes the inactive juror from all courts. 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 setJurorInactive(address _account) external override onlyByCore;

Parameters

draw

Draw an ID from a tree using a number. Note that this function reverts if the sum of all values in the tree is 0.

function draw(bytes32 _key, uint256 _coreDisputeID, uint256 _voteID)
    public
    view
    override
    returns (address drawnAddress);

Parameters

Returns

_updateParents

Update all the parents of a node.

function _updateParents(bytes32 _key, uint256 _treeIndex, bool _plusOrMinus, uint256 _value) private;

Parameters

_stakePathIDToAccount

Retrieves a juror's address from the stake path ID.

function _stakePathIDToAccount(bytes32 _stakePathID) internal pure returns (address account);

Parameters

Returns

_extraDataToTreeK

function _extraDataToTreeK(bytes memory _extraData) internal pure returns (uint256 K);

_set

Set a value in a tree.

function _set(bytes32 _key, uint256 _value, bytes32 _ID) internal;

Parameters

_accountAndCourtIDToStakePathID

Packs an account and a court ID into a stake path ID.

function _accountAndCourtIDToStakePathID(address _account, uint96 _courtID)
    internal
    pure
    returns (bytes32 stakePathID);

Parameters

Returns

Structs

SortitionSumTree

struct SortitionSumTree {
    uint256 K;
    uint256[] stack;
    uint256[] nodes;
    mapping(bytes32 => uint256) IDsToNodeIndexes;
    mapping(uint256 => bytes32) nodeIndexesToIDs;
}

DelayedStake

struct DelayedStake {
    address account;
    uint96 courtID;
    uint256 stake;
    uint256 penalty;
}

Contents

• EvidenceModule
• IEvidence
• IMetaEvidence
• ModeratedEvidenceModule

EvidenceModule

Git Source

State Variables

arbitrator

IArbitrator public arbitrator;

Functions

constructor

constructor(IArbitrator _arbitrator);

submitEvidence

Submits evidence.

function submitEvidence(uint256 _evidenceGroupID, string calldata _evidence) external;

Parameters

Events

Evidence

event Evidence(
    IArbitrator indexed _arbitrator, uint256 indexed _evidenceGroupID, address indexed _party, string _evidence
);

IEvidence

Git Source

Events

Evidence

To be raised when evidence is submitted. Should point to the resource (evidences are not to be stored on chain due to gas considerations).

event Evidence(uint256 indexed _evidenceGroupID, address indexed _party, string _evidence);

IMetaEvidence

Git Source

Events

MetaEvidence

To be emitted when meta-evidence is submitted.

event MetaEvidence(uint256 indexed _metaEvidenceID, string _evidence);

Dispute

To be emitted when a dispute is created to link the correct meta-evidence to the disputeID.

event Dispute(
    IArbitrator indexed _arbitrator, uint256 indexed _disputeID, uint256 _metaEvidenceID, uint256 _evidenceGroupID
);

ModeratedEvidenceModule

Git Source

Inherits: IArbitrable, IMetaEvidence

State Variables

AMOUNT_OF_CHOICES

uint256 public constant AMOUNT_OF_CHOICES = 2;

MULTIPLIER_DIVISOR

uint256 public constant MULTIPLIER_DIVISOR = 10000;

evidences

mapping(bytes32 => EvidenceData) evidences;

disputeIDtoEvidenceID

mapping(uint256 => bytes32) public disputeIDtoEvidenceID;

arbitratorDataList

ArbitratorData[] public arbitratorDataList;

arbitrator

IArbitrator public immutable arbitrator;

governor

address public governor;

bondTimeout

uint256 public bondTimeout;

totalCostMultiplier

uint256 public totalCostMultiplier;

initialDepositMultiplier

uint256 public initialDepositMultiplier;

Functions

onlyGovernor

modifier onlyGovernor();

constructor

Constructor.

constructor(
    IArbitrator _arbitrator,
    address _governor,
    uint256 _totalCostMultiplier,
    uint256 _initialDepositMultiplier,
    uint256 _bondTimeout,
    bytes memory _arbitratorExtraData,
    string memory _metaEvidence
);

Parameters

changeGovernor

Change the governor of the contract.

function changeGovernor(address _governor) external onlyGovernor;

Parameters

changeInitialDepositMultiplier

Change the proportion of arbitration fees that must be paid as fee stake by parties when there is no winner or loser (e.g. when the arbitrator refused to rule).

function changeInitialDepositMultiplier(uint256 _initialDepositMultiplier) external onlyGovernor;

Parameters

changeTotalCostMultiplier

Change the proportion of arbitration fees that must be paid as fee stake by the winner of the previous round.

function changeTotalCostMultiplier(uint256 _totalCostMultiplier) external onlyGovernor;

Parameters

changeBondTimeout

Change the the time window within which evidence submissions and removals can be contested. Ongoing moderations will start using the latest bondTimeout available after calling moderate() again.

function changeBondTimeout(uint256 _bondTimeout) external onlyGovernor;

Parameters

changeMetaEvidence

Update the meta evidence used for disputes.

function changeMetaEvidence(string calldata _newMetaEvidence) external onlyGovernor;

Parameters

changeArbitratorExtraData

Change the arbitrator to be used for disputes that may be raised in the next requests. The arbitrator is trusted to support appeal period and not reenter.

function changeArbitratorExtraData(bytes calldata _arbitratorExtraData) external onlyGovernor;

Parameters

submitEvidence

Submits evidence.

function submitEvidence(uint256 _evidenceGroupID, string calldata _evidence) external payable;

Parameters

moderate

Moderates an evidence submission. Requires the contester to at least double the accumulated stake of the oposing party. Optimization opportunity: use bytes calldata args and compress _evidenceID and _side (only for optimistic rollups).

function moderate(bytes32 _evidenceID, Party _side) external payable;

Parameters

resolveModerationMarket

Resolves a moderation event once the timeout has passed.

function resolveModerationMarket(bytes32 _evidenceID) external;

Parameters

contribute

Make a fee contribution.

function contribute(
    Moderation storage _moderation,
    Party _side,
    address payable _contributor,
    uint256 _amount,
    uint256 _totalRequired
) internal returns (uint256);

Parameters

Returns

calculateContribution

Returns the contribution value and remainder from available ETH and required amount.

function calculateContribution(uint256 _available, uint256 _requiredAmount)
    internal
    pure
    returns (uint256 taken, uint256 remainder);

Parameters

Returns

withdrawFeesAndRewards

Withdraws contributions of moderations. Reimburses contributions if the appeal was not fully funded. If the appeal was fully funded, sends the fee stake rewards and reimbursements proportional to the contributions made to the winner of a dispute. Optimization opportunity: use bytes calldata args and compress _evidenceID and _moderationID (only for optimistic rollups).

function withdrawFeesAndRewards(address payable _beneficiary, bytes32 _evidenceID, uint256 _moderationID)
    external
    returns (uint256 reward);

Parameters

rule

Give a ruling for a dispute. Must be called by the arbitrator to enforce the final ruling. The purpose of this function is to ensure that the address calling it has the right to rule on the contract.

function rule(uint256 _disputeID, uint256 _ruling) public override;

Parameters

getNumberOfModerations

Gets the number of moderation events of the specific evidence submission.

function getNumberOfModerations(bytes32 _evidenceID) external view returns (uint256);

Parameters

Returns

getContributions

Gets the contributions made by a party for a given moderation.

function getContributions(bytes32 _evidenceID, uint256 _moderationID, address _contributor)
    external
    view
    returns (uint256[3] memory contributions);

Parameters

Returns

getModerationInfo

Gets the information of a moderation event.

function getModerationInfo(bytes32 _evidenceID, uint256 _moderationID)
    external
    view
    returns (uint256[3] memory paidFees, Party currentWinner, uint256 feeRewards);

Parameters

Returns

getCurrentArbitratorIndex

Gets the last arbitrator data index, which is used for current new submissions.

function getCurrentArbitratorIndex() external view returns (uint256);

Returns

Events

Evidence

To be raised when evidence is submitted. Should point to the resource (evidences are not to be stored on chain due to gas considerations).

event Evidence(
    IArbitrator indexed _arbitrator, uint256 indexed _evidenceGroupID, address indexed _party, string _evidence
);

ModerationStatusChanged

Indicate that a party has to pay a fee or would otherwise be considered as losing.

event ModerationStatusChanged(bytes32 indexed _evidenceID, Party _currentWinner);

Structs

EvidenceData

struct EvidenceData {
    address payable submitter;
    bool disputed;
    Party ruling;
    uint256 disputeID;
    Moderation[] moderations;
}

Moderation

struct Moderation {
    uint256[3] paidFees;
    uint256 feeRewards;
    mapping(address => uint256[3]) contributions;
    bool closed;
    Party currentWinner;
    uint256 bondDeadline;
    uint256 arbitratorDataID;
}

ArbitratorData

struct ArbitratorData {
    uint256 metaEvidenceUpdates;
    bytes arbitratorExtraData;
}

Enums

Party

enum Party {
    None,
    Submitter,
    Moderator
}

Contents

• interfaces
• mock
• ForeignGateway
• ForeignGatewayOnGnosis
• HomeGateway

Contents

• IForeignGateway
• IHomeGateway

IForeignGateway

Git Source

Inherits: IArbitrator, IReceiverGateway

Functions

relayRule

Relay the rule call from the home gateway to the arbitrable.

function relayRule(address _messageSender, bytes32 _disputeHash, uint256 _ruling, address _forwarder) external;

withdrawFees

function withdrawFees(bytes32 _disputeHash) external;

disputeHashToForeignID

function disputeHashToForeignID(bytes32 _disputeHash) external view returns (uint256);

createDisputeERC20

function createDisputeERC20(uint256 _choices, bytes calldata _extraData, uint256 _amount)
    external
    returns (uint256 disputeID);

IHomeGateway

Git Source

Inherits: IArbitrable, IMetaEvidence, ISenderGateway

Functions

relayCreateDispute

Provide the same parameters as on the foreignChain while creating a dispute. Providing incorrect parameters will create a different hash than on the foreignChain and will not affect the actual dispute/arbitrable's ruling.

function relayCreateDispute(
    uint256 _foreignChainID,
    bytes32 _foreignBlockHash,
    uint256 _foreignDisputeID,
    uint256 _choices,
    bytes calldata _extraData,
    address _arbitrable
) external payable;

Parameters

disputeHashToHomeID

Looks up the local home disputeID for a disputeHash. For cross-chain Evidence standard.

function disputeHashToHomeID(bytes32 _disputeHash) external view returns (uint256);

Parameters

Contents

• VeaMock

VeaMock

Git Source

Inherits: IVeaOutboxOnL1, IVeaInbox

Functions

sendMessage

Sends an arbitrary message to receiving chain. Note: Calls authenticated by receiving gateway checking the sender argument.

function sendMessage(address _to, bytes4 _fnSelector, bytes memory _data) external returns (uint64 msgId);

Parameters

Returns

saveSnapshot

Snapshots can be saved a maximum of once per epoch. Saves snapshot of state root. O(log(count)) where count number of messages in the inbox.

function saveSnapshot() external;

sendMessage

Verifies and relays the message. Note: Gateways expect first argument of message call to be the arbitrum message sender, used for authentication.

function sendMessage(bytes32[] calldata _proof, uint64 _msgId, address _to, bytes calldata _message) external;

Parameters

resolveDisputedClaim

Resolves any challenge of the optimistic claim for 'epoch' using the canonical bridge. Note: Access restricted to canonical bridge.

function resolveDisputedClaim(uint256 _epoch, bytes32 _stateRoot, Claim memory _claim) external;

Parameters

ForeignGateway

Git Source

Inherits: IForeignGateway

State Variables

DEFAULT_NB_OF_JURORS

uint256 public constant DEFAULT_NB_OF_JURORS = 3;

localDisputeID

uint256 internal localDisputeID = 1;

feeForJuror

mapping(uint96 => uint256) public feeForJuror;

governor

address public governor;

veaOutbox

address public veaOutbox;

senderChainID

uint256 public immutable senderChainID;

senderGateway

address public override senderGateway;

deprecatedVeaOutbox

address public deprecatedVeaOutbox;

deprecatedVeaOutboxExpiration

uint256 public deprecatedVeaOutboxExpiration;

disputeHashtoDisputeData

mapping(bytes32 => DisputeData) public disputeHashtoDisputeData;

Functions

onlyFromVea

modifier onlyFromVea(address _messageSender);

onlyByGovernor

modifier onlyByGovernor();

constructor

constructor(address _governor, address _veaOutbox, address _senderGateway, uint256 _senderChainID);

changeGovernor

Changes the governor.

function changeGovernor(address _governor) external;

Parameters

changeVea

Changes the outbox.

function changeVea(address _veaOutbox, uint256 _gracePeriod) external onlyByGovernor;

Parameters

changeReceiverGateway

Changes the sender gateway.

function changeReceiverGateway(address _senderGateway) external;

Parameters

changeCourtJurorFee

Changes the feeForJuror property value of a specified court.

function changeCourtJurorFee(uint96 _courtID, uint256 _feeForJuror) external onlyByGovernor;

Parameters

createDispute

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

createDisputeERC20

function createDisputeERC20(uint256, bytes calldata, uint256) external override returns (uint256);

arbitrationCost

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

relayRule

Relay the rule call from the home gateway to the arbitrable.

function relayRule(address _messageSender, bytes32 _disputeHash, uint256 _ruling, address _relayer)
    external
    override
    onlyFromVea(_messageSender);

withdrawFees

function withdrawFees(bytes32 _disputeHash) external override;

disputeHashToForeignID

function disputeHashToForeignID(bytes32 _disputeHash) external view override returns (uint256);

extraDataToCourtIDMinJurors

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

Events

OutgoingDispute

event OutgoingDispute(
    bytes32 disputeHash,
    bytes32 blockhash,
    uint256 localDisputeID,
    uint256 _choices,
    bytes _extraData,
    address arbitrable
);

ArbitrationCostModified

event ArbitrationCostModified(uint96 indexed _courtID, uint256 _feeForJuror);

Structs

DisputeData

struct DisputeData {
    uint248 id;
    bool ruled;
    address arbitrable;
    uint256 paid;
    address relayer;
}

ForeignGatewayOnGnosis

Git Source

Inherits: IForeignGateway

State Variables

DEFAULT_NB_OF_JURORS

uint256 public constant DEFAULT_NB_OF_JURORS = 3;

weth

IERC20 public immutable weth;

localDisputeID

uint256 internal localDisputeID = 1;

feeForJuror

mapping(uint96 => uint256) public feeForJuror;

governor

address public governor;

veaOutbox

address public veaOutbox;

senderChainID

uint256 public immutable senderChainID;

senderGateway

address public override senderGateway;

deprecatedVeaOutbox

address public deprecatedVeaOutbox;

deprecatedVeaOutboxExpiration

uint256 public deprecatedVeaOutboxExpiration;

disputeHashtoDisputeData

mapping(bytes32 => DisputeData) public disputeHashtoDisputeData;

Functions

onlyFromVea

modifier onlyFromVea(address _messageSender);

onlyByGovernor

modifier onlyByGovernor();

constructor

constructor(address _governor, address _veaOutbox, address _senderGateway, uint256 _senderChainID, IERC20 _weth);

changeGovernor

Changes the governor.

function changeGovernor(address _governor) external;

Parameters

changeVea

Changes the outbox.

function changeVea(address _veaOutbox, uint256 _gracePeriod) external onlyByGovernor;

Parameters

changeReceiverGateway

Changes the sender gateway.

function changeReceiverGateway(address _senderGateway) external;

Parameters

changeCourtJurorFee

Changes the feeForJuror property value of a specified court.

function changeCourtJurorFee(uint96 _courtID, uint256 _feeForJuror) external onlyByGovernor;

Parameters

createDispute

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

createDisputeERC20

function createDisputeERC20(uint256 _choices, bytes calldata _extraData, uint256 _amount)
    external
    override
    returns (uint256 disputeID);

arbitrationCost

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

relayRule

Relay the rule call from the home gateway to the arbitrable.

function relayRule(address _messageSender, bytes32 _disputeHash, uint256 _ruling, address _relayer)
    external
    override
    onlyFromVea(_messageSender);

withdrawFees

function withdrawFees(bytes32 _disputeHash) external override;

disputeHashToForeignID

function disputeHashToForeignID(bytes32 _disputeHash) external view override returns (uint256);

extraDataToCourtIDMinJurors

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

Events

OutgoingDispute

event OutgoingDispute(
    bytes32 disputeHash,
    bytes32 blockhash,
    uint256 localDisputeID,
    uint256 _choices,
    bytes _extraData,
    address arbitrable
);

ArbitrationCostModified

event ArbitrationCostModified(uint96 indexed _courtID, uint256 _feeForJuror);

Structs

DisputeData

struct DisputeData {
    uint248 id;
    bool ruled;
    address arbitrable;
    uint256 paid;
    address relayer;
}

HomeGateway

Git Source

Inherits: IHomeGateway

State Variables

governor

address public governor;

arbitrator

IArbitrator public arbitrator;

veaInbox

IVeaInbox public veaInbox;

receiverGateway

address public override receiverGateway;

receiverChainID

uint256 public immutable receiverChainID;

disputeIDtoHash

mapping(uint256 => bytes32) public disputeIDtoHash;

disputeHashtoID

mapping(bytes32 => uint256) public disputeHashtoID;

disputeHashtoRelayedData

mapping(bytes32 => RelayedData) public disputeHashtoRelayedData;

Functions