Contract 0x3Af3ff120aeB43Df7fC73CDd5E83b03DbfC81a9E

 
 
Txn Hash
Method
Block
From
To
Value [Txn Fee]
0xe781702377bfacb8bf864378a9b5d8407831af04a9706594fdab4b541b95d0540x60a06040239468302022-01-20 12:56:01425 days 23 hrs ago0xdf456b614fe9ff1c7c0b380330da29c96d40fb02 IN  Create: ArbitratorManifest0 MATIC0.14860925250
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
ArbitratorManifest

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 10000 runs

Other Settings:
default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2022-01-20
*/

// SPDX-License-Identifier: GPL-3.0-only

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: contracts/interfaces/IDisputeManagerCore.sol
pragma solidity ^0.8.4;

interface IDisputeManagerCore {
    event NewDispute(
        uint256 indexed disputeId,
        address indexed subject,
        uint64 indexed draftTermId,
        uint64 jurorsNumber,
        bytes metadata
    );
    event EvidenceSubmitted(uint256 indexed disputeId, address indexed submitter, bytes evidence);
    event EvidencePeriodClosed(uint256 indexed disputeId, uint64 indexed termId);
    event RulingComputed(uint256 indexed disputeId, uint8 indexed ruling);
}

// File: contracts/interfaces/IDisputeManager.sol
pragma solidity ^0.8.4;

interface IDisputeManager is IDisputeManagerCore {
    enum DisputeState {
        PreDraft,
        Adjudicating,
        Ruled
    }

    enum AdjudicationState {
        Invalid,
        Committing,
        Revealing,
        Appealing,
        ConfirmingAppeal,
        Ended
    }

    function createDispute(address _subject, uint8 _possibleRulings, bytes calldata _metadata) external returns (uint256);
    function submitEvidence(address _subject, uint256 _disputeId, address _submitter, bytes calldata _evidence) external;
    function closeEvidencePeriod(address _subject, uint256 _disputeId) external;
    function draft(uint256 _disputeId) external;
    function createAppeal(uint256 _disputeId, uint256 _roundId, uint8 _ruling) external;
    function confirmAppeal(uint256 _disputeId, uint256 _roundId, uint8 _ruling) external;
    function computeRuling(uint256 _disputeId) external returns (address subject, uint8 finalRuling);
    function settlePenalties(uint256 _disputeId, uint256 _roundId, uint256 _jurorsToSettle) external;
    function settleReward(uint256 _disputeId, uint256 _roundId, address _juror) external;
    function settleAppealDeposit(uint256 _disputeId, uint256 _roundId) external;
    function getDisputeFees() external view returns (IERC20 feeToken, uint256 feeAmount);
    function getDispute(uint256 _disputeId)
        external view returns (
            address subject,
            uint8 possibleRulings,
            DisputeState state,
            uint8 finalRuling,
            uint256 lastRoundId,
            uint64 createTermId
        );
    function getRound(uint256 _disputeId, uint256 _roundId)
        external view returns (
            uint64 draftTerm,
            uint64 delayedTerms,
            uint64 jurorsNumber,
            uint64 selectedJurors,
            uint256 jurorFees,
            bool settledPenalties,
            uint256 collectedTokens,
            uint64 coherentJurors,
            AdjudicationState state
        );
    function getAppeal(uint256 _disputeId, uint256 _roundId)
        external view returns (
            address maker,
            uint64 appealedRuling,
            address taker,
            uint64 opposedRuling
        );
    function getNextRoundDetails(uint256 _disputeId, uint256 _roundId)
        external view returns (
            uint64 nextRoundStartTerm,
            uint64 nextRoundJurorsNumber,
            DisputeState newDisputeState,
            IERC20 feeToken,
            uint256 totalFees,
            uint256 jurorFees,
            uint256 appealDeposit,
            uint256 confirmAppealDeposit
        );
    function getJuror(uint256 _disputeId, uint256 _roundId, address _juror)
        external view returns (
            uint64 weight,
            bool rewarded
        );


    event DisputeStateChanged(uint256 indexed disputeId, DisputeState indexed state);
    event JurorDrafted(uint256 indexed disputeId, uint256 indexed roundId, address indexed juror);
    event RulingAppealed(uint256 indexed disputeId, uint256 indexed roundId, uint8 ruling);
    event RulingAppealConfirmed(uint256 indexed disputeId, uint256 indexed roundId, uint64 indexed draftTermId, uint256 jurorsNumber);
    event PenaltiesSettled(uint256 indexed disputeId, uint256 indexed roundId, uint256 collectedTokens);
    event RewardSettled(uint256 indexed disputeId, uint256 indexed roundId, address juror, uint256 tokens, uint256 fees);
    event AppealDepositSettled(uint256 indexed disputeId, uint256 indexed roundId);
    event MaxJurorsPerDraftBatchChanged(uint64 previousMaxJurorsPerDraftBatch, uint64 currentMaxJurorsPerDraftBatch);
}

// File: contracts/interfaces/IArbitratorManifest.sol
pragma solidity ^0.8.4;

interface IArbitratorManifest {
    event PartiesSet(
        uint256 indexed disputeId,
        address indexed defendant,
        address indexed challenger
    );
    event RepStateSet(
        address indexed client,
        address indexed rep,
        bool isActive
    );
    event AllowRepresentation(
        address indexed rep,
        address indexed client,
        bool allowed
    );

    function setPartiesOf(uint256 _disputeId, address _defendant, address _challenger) external;
    function setRepStatus(address _rep, bool _isActive) external;
    function allowRepresentation(address _client, bool _allow) external;
    function isRepOf(address _account, address _rep) external view returns (bool isRep);
    function defendantOf(uint256 _disputeId) external view returns (address defendant);
    function challengerOf(uint256 _disputeId) external view returns (address challenger);
    function canRepresent(address _rep, address _client) external view returns (bool allowed);
    function canSubmitEvidenceFor(address _submitter, uint256 _disputeId)
        external view returns (bool canSubmit, address submittingFor);
}

// File: contracts/manifest/ArbitratorManifestCore.sol
pragma solidity ^0.8.4;

abstract contract ArbitratorManifestCore is IArbitratorManifest {
    mapping(address => mapping(address => bool)) public override isRepOf;
    mapping(address => mapping(address => bool)) public override canRepresent;
    mapping(uint256 => address) public override defendantOf;
    mapping(uint256 => address) public override challengerOf;

    function setPartiesOf(
        uint256 _disputeId,
        address _defendant,
        address _challenger
    )
        external override
    {
        require(msg.sender == _getSubjectOf(_disputeId), "ArbManifest: not subject");
        require(_defendant != _challenger, "ArbManifest: party conflict");
        defendantOf[_disputeId] = _defendant;
        challengerOf[_disputeId] = _challenger;
        emit PartiesSet(_disputeId, _defendant, _challenger);
    }

    /**
      Sets whether the `_client` is allowed to set the `msg.sender` as their
      representative. Potentially also resets the representative status to false

      @param _client the potential `_client` of the `msg.sender` for which to
      set the approval
      @param _allow whether the `msg.sender` is allowing the `_client` to set
      them as a representative
      @dev fires `AllowRepresentation` event
      @dev fires a `RepStateSet` if `_allow = false`
      @dev sets rep status to `false` if `_allow = false`
    */
    function allowRepresentation(address _client, bool _allow) external override {
        if (!_allow) {
            _setRepStatus(_client, msg.sender, false);
        }
        canRepresent[msg.sender][_client] = _allow;
        emit AllowRepresentation(msg.sender, _client, _allow);
    }

    /**
      Sets whether the `_rep` is to be a representative of the `msg.sender`

      @param _rep address of the representative for which to change the status
      @param _isActive whether `_rep` is to be a representative of `msg.sender`
      @dev fires a `RepStateSet` event
      @dev reverts if `canRepresent[_rep][msg.sender] = false`
    */
    function setRepStatus(address _rep, bool _isActive) external override {
        _setRepStatus(msg.sender, _rep, _isActive);
    }

    /**
      @dev will also return `false` if `_submitter` is a representative of both
      the defendant and challenger
    */
    function canSubmitEvidenceFor(address _submitter, uint256 _disputeId)
        public view override returns (bool, address)
    {
        address defendant = defendantOf[_disputeId];
        bool isDefendant = defendant == _submitter || isRepOf[defendant][_submitter];
        address challenger = challengerOf[_disputeId];
        bool isChallenger = challenger == _submitter || isRepOf[challenger][_submitter];
        if (isDefendant != isChallenger) {
            return (true, isDefendant ? defendant : challenger);
        }
        return (false, address(0));
    }

    function _setRepStatus(address _client, address _rep, bool _isActive) internal {
        require(!_isActive || canRepresent[_rep][_client], "ArbManifest: cannot rep");
        isRepOf[_client][_rep] = _isActive;
        emit RepStateSet(_client, _rep, _isActive);
    }

    function _getSubjectOf(uint256 _disputeId)
        internal view virtual returns (address subject);
}

// File: contracts/manifest/ArbitratorManifest.sol
pragma solidity ^0.8.4;

contract ArbitratorManifest is ArbitratorManifestCore {
    IDisputeManager public immutable disputeManager;

    constructor(IDisputeManager _disputeManager) {
        disputeManager = _disputeManager;
    }

    function _getSubjectOf(uint256 _disputeId)
        internal view override returns (address subject)
    {
        (subject,,,,,) = disputeManager.getDispute(_disputeId);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"contract IDisputeManager","name":"_disputeManager","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"rep","type":"address"},{"indexed":true,"internalType":"address","name":"client","type":"address"},{"indexed":false,"internalType":"bool","name":"allowed","type":"bool"}],"name":"AllowRepresentation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"disputeId","type":"uint256"},{"indexed":true,"internalType":"address","name":"defendant","type":"address"},{"indexed":true,"internalType":"address","name":"challenger","type":"address"}],"name":"PartiesSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"client","type":"address"},{"indexed":true,"internalType":"address","name":"rep","type":"address"},{"indexed":false,"internalType":"bool","name":"isActive","type":"bool"}],"name":"RepStateSet","type":"event"},{"inputs":[{"internalType":"address","name":"_client","type":"address"},{"internalType":"bool","name":"_allow","type":"bool"}],"name":"allowRepresentation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"canRepresent","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_submitter","type":"address"},{"internalType":"uint256","name":"_disputeId","type":"uint256"}],"name":"canSubmitEvidenceFor","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"challengerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"defendantOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"disputeManager","outputs":[{"internalType":"contract IDisputeManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"isRepOf","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_disputeId","type":"uint256"},{"internalType":"address","name":"_defendant","type":"address"},{"internalType":"address","name":"_challenger","type":"address"}],"name":"setPartiesOf","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rep","type":"address"},{"internalType":"bool","name":"_isActive","type":"bool"}],"name":"setRepStatus","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000bc9d027eb4b1d9622f217de10f07dc74b7c81eeb

-----Decoded View---------------
Arg [0] : _disputeManager (address): 0xbc9d027eb4b1d9622f217de10f07dc74b7c81eeb

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000bc9d027eb4b1d9622f217de10f07dc74b7c81eeb


Deployed ByteCode Sourcemap

11937:403:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9945:293;;;;;;:::i;:::-;;:::i;:::-;;8699:73;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3259:14:1;;3252:22;3234:41;;3222:2;3207:18;8699:73:0;;;;;;;;10607:131;;;;;;:::i;:::-;;:::i;10880:582::-;;;;;;:::i;:::-;;:::i;:::-;;;;3479:14:1;;3472:22;3454:41;;3543:42;3531:55;;;3526:2;3511:18;;3504:83;3427:18;10880:582:0;3409:184:1;8624:68:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;8779:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3039:42:1;3027:55;;;3009:74;;2997:2;2982:18;8779:55:0;2964:125:1;8906:479:0;;;;;;:::i;:::-;;:::i;8841:56::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;11998:47;;;;;9945:293;10038:6;10033:81;;10061:41;10075:7;10084:10;10096:5;10061:13;:41::i;:::-;10137:10;10124:24;;;;:12;:24;;;;;;;;;:33;;;;;;;;;;;;:42;;;;;;;;;;;;;10182:48;;3234:41:1;;;10124:33:0;;10137:10;10182:48;;3207:18:1;10182:48:0;;;;;;;9945:293;;:::o;10607:131::-;10688:42;10702:10;10714:4;10720:9;10688:13;:42::i;:::-;10607:131;;:::o;10880:582::-;10989:4;11040:23;;;:11;:23;;;;;;10989:4;;11040:23;;;;;10989:4;;11093:23;;;;;:57;;-1:-1:-1;11120:18:0;;;;:7;:18;;;;;;;;;;;:30;;;;;;;;;;;;11093:57;11161:18;11182:24;;;:12;:24;;;;;;11074:76;;-1:-1:-1;11182:24:0;;;;;11237;;;;;:59;;-1:-1:-1;11265:19:0;;;;:7;:19;;;;;;;;;;;:31;;;;;;;;;;;;11237:59;11217:79;;11326:12;11311:27;;:11;:27;;;11307:111;;11363:4;11369:11;:36;;11395:10;11369:36;;;11383:9;11369:36;11355:51;;;;;;;;;;11307:111;11436:5;11451:1;11428:26;;;;;;;;10880:582;;;;;;:::o;8906:479::-;9088:25;9102:10;9088:13;:25::i;:::-;9074:39;;:10;:39;;;9066:76;;;;;;;4054:2:1;9066:76:0;;;4036:21:1;4093:2;4073:18;;;4066:30;4132:26;4112:18;;;4105:54;4176:18;;9066:76:0;;;;;;;;;9175:11;9161:25;;:10;:25;;;;9153:65;;;;;;;4407:2:1;9153:65:0;;;4389:21:1;4446:2;4426:18;;;4419:30;4485:29;4465:18;;;4458:57;4532:18;;9153:65:0;4379:177:1;9153:65:0;9229:23;;;;:11;:23;;;;;;;;:36;;;;;;;;;;;;;;;9276:12;:24;;;;;;:38;;;;;;;;;;;;;9330:47;;9276:38;;9229:36;;9241:10;;9330:47;;;8906:479;;;:::o;11470:273::-;11569:9;11568:10;:41;;;-1:-1:-1;11582:18:0;;;;;;;;:12;:18;;;;;;;;:27;;;;;;;;;;;;11568:41;11560:77;;;;;;;4763:2:1;11560:77:0;;;4745:21:1;4802:2;4782:18;;;4775:30;4841:25;4821:18;;;4814:53;4884:18;;11560:77:0;4735:173:1;11560:77:0;11648:16;;;;:7;:16;;;;;;;;;;;:22;;;;;;;;;;;;;:34;;;;;;;;;;;;;11698:37;;3234:41:1;;;11698:37:0;;3207:18:1;11698:37:0;;;;;;;11470:273;;;:::o;12158:179::-;12292:37;;;;;;;;5059:25:1;;;12242:15:0;;12292:14;:25;;;;;5032:18:1;;12292:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;12275:54:0;;12158:179;-1:-1:-1;;;;;;12158:179:0:o;14:160:1:-;91:13;;144:4;133:16;;123:27;;113:2;;164:1;161;154:12;113:2;72:102;;;:::o;179:398::-;247:6;255;308:2;296:9;287:7;283:23;279:32;276:2;;;329:6;321;314:22;276:2;373:9;360:23;392:31;417:5;392:31;:::i;:::-;442:5;-1:-1:-1;499:2:1;484:18;;471:32;512:33;471:32;512:33;:::i;:::-;564:7;554:17;;;266:311;;;;;:::o;582:436::-;647:6;655;708:2;696:9;687:7;683:23;679:32;676:2;;;729:6;721;714:22;676:2;773:9;760:23;792:31;817:5;792:31;:::i;:::-;842:5;-1:-1:-1;899:2:1;884:18;;871:32;941:15;;934:23;922:36;;912:2;;977:6;969;962:22;1023:325;1091:6;1099;1152:2;1140:9;1131:7;1127:23;1123:32;1120:2;;;1173:6;1165;1158:22;1120:2;1217:9;1204:23;1236:31;1261:5;1236:31;:::i;:::-;1286:5;1338:2;1323:18;;;;1310:32;;-1:-1:-1;;;1110:238:1:o;1353:839::-;1479:6;1487;1495;1503;1511;1519;1572:3;1560:9;1551:7;1547:23;1543:33;1540:2;;;1594:6;1586;1579:22;1540:2;1631:9;1625:16;1650:31;1675:5;1650:31;:::i;:::-;1700:5;-1:-1:-1;1724:47:1;1767:2;1752:18;;1724:47;:::i;:::-;1714:57;;1816:2;1805:9;1801:18;1795:25;1851:1;1842:7;1839:14;1829:2;;1872:6;1864;1857:22;1829:2;1900:7;-1:-1:-1;1926:47:1;1969:2;1954:18;;1926:47;:::i;:::-;1916:57;;2013:3;2002:9;1998:19;1992:26;1982:36;;2063:3;2052:9;2048:19;2042:26;2112:18;2103:7;2099:32;2090:7;2087:45;2077:2;;2151:6;2143;2136:22;2077:2;2179:7;2169:17;;;1530:662;;;;;;;;:::o;2197:190::-;2256:6;2309:2;2297:9;2288:7;2284:23;2280:32;2277:2;;;2330:6;2322;2315:22;2277:2;-1:-1:-1;2358:23:1;;2267:120;-1:-1:-1;2267:120:1:o;2392:466::-;2469:6;2477;2485;2538:2;2526:9;2517:7;2513:23;2509:32;2506:2;;;2559:6;2551;2544:22;2506:2;2600:9;2587:23;2577:33;;2660:2;2649:9;2645:18;2632:32;2673:31;2698:5;2673:31;:::i;:::-;2723:5;-1:-1:-1;2780:2:1;2765:18;;2752:32;2793:33;2752:32;2793:33;:::i;:::-;2845:7;2835:17;;;2496:362;;;;;:::o;5095:154::-;5181:42;5174:5;5170:54;5163:5;5160:65;5150:2;;5239:1;5236;5229:12;5150:2;5140:109;:::o

Swarm Source

ipfs://bdb71fffc5320495c8cc227598155f1f1b02356f56f1fbe1e8e746d8eed90e20
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.