From 8c2405b36d92b0f69414464349db7c00641089a1 Mon Sep 17 00:00:00 2001 From: josojo Date: Fri, 19 Jan 2024 23:30:37 +0100 Subject: [PATCH] first try --- contracts/interfaces/IL2ForkArbitrator.sol | 109 +++++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 contracts/interfaces/IL2ForkArbitrator.sol diff --git a/contracts/interfaces/IL2ForkArbitrator.sol b/contracts/interfaces/IL2ForkArbitrator.sol new file mode 100644 index 00000000..52a39e50 --- /dev/null +++ b/contracts/interfaces/IL2ForkArbitrator.sol @@ -0,0 +1,109 @@ +// SPDX-License-Identifier: GPL-3.0-only + +pragma solidity ^0.8.20; + +// Allow mixed-case variables for compatibility with reality.eth, eg it uses question_id not questionId +/* solhint-disable var-name-mixedcase */ + + + +import {IBridgeMessageReceiver} from "@RealityETH/zkevm-contracts/contracts/interfaces/IBridgeMessageReceiver.sol"; + +/* +This contract is the arbitrator used by governance propositions for AdjudicationFramework contracts. +It charges a dispute fee of 5% of total supply [TODO], which it forwards to L1 when requesting a fork. +If there is already a dispute in progress (ie another fork has been requested but not yet triggered or +we are in the 1 week period before a fork) the new one will be queued. +*/ + +// NB This doesn't implement IArbitrator because that requires slightly more functions than we need +// TODO: Would be good to make a stripped-down IArbitrator that only has the essential functions +interface IL2ForkArbitrator is IBridgeMessageReceiver { + // @dev Error thrown when the arbitration data is not set + error ArbitrationDataNotSet(); + // @dev Error thrown when the arbitration fee is 0 + error ArbitrationFeeMustBePositive(); + // @dev Error thrown when the arbitration request has already been made + error ArbitrationAlreadyRequested(); + // @dev Error thrown when the fork is already in progress over something else + error ForkInProgress(); + // @dev Error thrown when the L2 bridge is not set + error L2BridgeNotSet(); + // @dev Error thrown when the fork is not in progress + error QuestionNotForked(); + // @dev Error thrown when status is not FORK_REQUESTED + error StatusNotForkRequested(); + // @dev Error thrown when status is not FORK_REQUEST_FAILED + error StatusNotForkRequestFailed(); + // @dev Error thrown when the fork is not in progress + error WrongStatus(); + // @dev Error thrown when called with wrong network + error WrongNetwork(); + // @dev Error thrown when called with wrong sender + error WrongSender(); + // @dev Error thrown when called from the wrong bridge + error WrongBridge(); + // @dev Error thrown when the fork is not in progress + error ForkNotInProgress(); + // @dev Error thrown when contract is not awaiting activation + error NotAwaitingActivation(); + // @dev Error thrown when the request is still in the waiting period + error RequestStillInWaitingPeriod(); + + /// @notice Return the dispute fee for the specified question. 0 indicates that we won't arbitrate it. + /// @dev Uses a general default, takes a question id param for other contracts that may want to set it per-question. + function getDisputeFee(bytes32) external view returns (uint256); + + /// @notice Request arbitration, freezing the question until we send submitAnswerByArbitrator + /// @dev The bounty can be paid only in part, in which case the last person to pay will be considered the payer + /// Will trigger an error if the notification fails, eg because the question has already been finalized + /// @param questionId The question in question + /// @param maxPrevious If specified, reverts if a bond higher than this was submitted after you sent your transaction. + function requestArbitration( + bytes32 questionId, + uint256 maxPrevious + ) external payable returns (bool); + + function storeInformation( + uint256 templateId, + uint32 openingTs, + string calldata question, + uint32 timeout, + uint32 minBond, + uint256 nonce, + uint256 delay + ) external; + + /// @notice Request a fork via the bridge + /// @dev Talks to the L1 ForkingManager asynchronously, and may fail. + /// @param questionId The questionId in the question + function requestActivateFork(bytes32 questionId) external; + + // If the fork request fails, we will get a message back through the bridge telling us about it + // We will set FORK_REQUEST_FAILED which will allow anyone to request cancellation + function onMessageReceived( + address _originAddress, + uint32 _originNetwork, + bytes memory _data + ) external payable; + + /// @notice Submit the arbitrator's answer to a question, assigning the winner automatically. + /// @param question_id The question in question + /// @param last_history_hash The history hash before the final one + /// @param last_answer_or_commitment_id The last answer given, or the commitment ID if it was a commitment. + /// @param last_answerer The address that supplied the last answer + function handleCompletedFork( + bytes32 question_id, + bytes32 last_history_hash, + bytes32 last_answer_or_commitment_id, + address last_answerer + ) external; + + /// @notice Cancel a previous arbitration request + /// @dev This is intended for situations where the stuff is happening non-atomically and the fee changes or someone else forks before us + /// @dev Another way to handle this might be to go back into QUEUED state and let people keep retrying + /// @dev NB This may revert if the contract has returned funds in the bridge but claimAsset hasn't been called yet + /// @param question_id The question in question + function cancelArbitration(bytes32 question_id) external; + function claimRefund() external; +}