{ "contractName": "IReputationMiningCycle", "abi": [ { "anonymous": false, "inputs": [ { "indexed": false, "name": "_miner", "type": "address" }, { "indexed": false, "name": "_newHash", "type": "bytes32" }, { "indexed": false, "name": "_nNodes", "type": "uint256" }, { "indexed": false, "name": "_jrh", "type": "bytes32" }, { "indexed": false, "name": "_entryIndex", "type": "uint256" } ], "name": "ReputationRootHashSubmitted", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "_newHash", "type": "bytes32" }, { "indexed": false, "name": "_nNodes", "type": "uint256" }, { "indexed": false, "name": "_jrh", "type": "bytes32" } ], "name": "JustificationRootHashConfirmed", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "_newHash", "type": "bytes32" }, { "indexed": false, "name": "_nNodes", "type": "uint256" }, { "indexed": false, "name": "_jrh", "type": "bytes32" }, { "indexed": false, "name": "_firstDisagreeIdx", "type": "uint256" } ], "name": "BinarySearchConfirmed", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "_newHash", "type": "bytes32" }, { "indexed": false, "name": "_nNodes", "type": "uint256" }, { "indexed": false, "name": "_jrh", "type": "bytes32" } ], "name": "ChallengeCompleted", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "_newHash", "type": "bytes32" }, { "indexed": false, "name": "_nNodes", "type": "uint256" }, { "indexed": false, "name": "_jrh", "type": "bytes32" } ], "name": "HashInvalidated", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "previousNewReputationUID", "type": "uint256" }, { "indexed": false, "name": "_disagreeStateReputationUID", "type": "uint256" }, { "indexed": false, "name": "existingUID", "type": "bool" } ], "name": "ProveUIDSuccess", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "name": "_agreeStateReputationValue", "type": "int256" }, { "indexed": false, "name": "_disagreeStateReputationValue", "type": "int256" }, { "indexed": false, "name": "_originReputationValue", "type": "int256" } ], "name": "ProveValueSuccess", "type": "event" }, { "constant": true, "inputs": [ { "name": "_round", "type": "uint256" } ], "name": "getDisputeRound", "outputs": [ { "components": [ { "name": "firstSubmitter", "type": "address" }, { "name": "lastResponseTimestamp", "type": "uint256" }, { "name": "challengeStepCompleted", "type": "uint256" }, { "name": "intermediateReputationHash", "type": "bytes32" }, { "name": "intermediateReputationNNodes", "type": "uint256" }, { "name": "lowerBound", "type": "uint256" }, { "name": "upperBound", "type": "uint256" }, { "name": "provedPreviousReputationUID", "type": "uint256" }, { "name": "targetHashDuringSearch", "type": "bytes32" }, { "name": "hash1", "type": "bytes32" }, { "name": "hash2", "type": "bytes32" } ], "name": "submissions", "type": "tuple[]" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [ { "name": "_user", "type": "address" } ], "name": "getReputationHashSubmission", "outputs": [ { "components": [ { "name": "proposedNewRootHash", "type": "bytes32" }, { "name": "nNodes", "type": "uint256" }, { "name": "jrh", "type": "bytes32" }, { "name": "jrhNNodes", "type": "uint256" } ], "name": "submission", "type": "tuple" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [ { "name": "submitter", "type": "address" }, { "name": "entryIndex", "type": "uint256" }, { "name": "newHash", "type": "bytes32" } ], "name": "getEntryHash", "outputs": [ { "name": "entryHash", "type": "bytes32" } ], "payable": false, "stateMutability": "pure", "type": "function" }, { "constant": true, "inputs": [ { "name": "_miner", "type": "address" }, { "name": "_index", "type": "uint256" } ], "name": "minerSubmittedEntryIndex", "outputs": [ { "name": "result", "type": "bool" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": false, "inputs": [], "name": "resetWindow", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "newHash", "type": "bytes32" }, { "name": "nNodes", "type": "uint256" }, { "name": "jrh", "type": "bytes32" }, { "name": "entryIndex", "type": "uint256" } ], "name": "submitRootHash", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": true, "inputs": [ { "name": "round", "type": "uint256" } ], "name": "challengeRoundComplete", "outputs": [ { "name": "complete", "type": "bool" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": false, "inputs": [ { "name": "roundNumber", "type": "uint256" } ], "name": "confirmNewHash", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "round", "type": "uint256" }, { "name": "idx", "type": "uint256" } ], "name": "invalidateHash", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "round", "type": "uint256" }, { "name": "idx", "type": "uint256" }, { "name": "jhIntermediateValue", "type": "bytes" }, { "name": "branchMask", "type": "uint256" }, { "name": "siblings", "type": "bytes32[]" } ], "name": "respondToBinarySearchForChallenge", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "round", "type": "uint256" }, { "name": "idx", "type": "uint256" }, { "name": "jhIntermediateValue", "type": "bytes" }, { "name": "branchMask", "type": "uint256" }, { "name": "siblings", "type": "bytes32[]" } ], "name": "confirmBinarySearchResult", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "u", "type": "uint256[29]" }, { "name": "b32", "type": "bytes32[8]" }, { "name": "reputationSiblings", "type": "bytes32[]" }, { "name": "agreeStateSiblings", "type": "bytes32[]" }, { "name": "disagreeStateSiblings", "type": "bytes32[]" }, { "name": "previousNewReputationSiblings", "type": "bytes32[]" }, { "name": "userOriginReputationSiblings", "type": "bytes32[]" }, { "name": "childReputationSiblings", "type": "bytes32[]" }, { "name": "adjacentReputationSiblings", "type": "bytes32[]" } ], "name": "respondToChallenge", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "round", "type": "uint256" }, { "name": "index", "type": "uint256" }, { "name": "branchMask1", "type": "uint256" }, { "name": "siblings1", "type": "bytes32[]" }, { "name": "branchMask2", "type": "uint256" }, { "name": "siblings2", "type": "bytes32[]" } ], "name": "confirmJustificationRootHash", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": false, "inputs": [ { "name": "_user", "type": "address" }, { "name": "_amount", "type": "int256" }, { "name": "_skillId", "type": "uint256" }, { "name": "_colonyAddress", "type": "address" }, { "name": "_nParents", "type": "uint128" }, { "name": "_nChildren", "type": "uint128" } ], "name": "appendReputationUpdateLog", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": true, "inputs": [], "name": "getReputationUpdateLogLength", "outputs": [ { "name": "nUpdates", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [ { "name": "_id", "type": "uint256" } ], "name": "getReputationUpdateLogEntry", "outputs": [ { "components": [ { "name": "user", "type": "address" }, { "name": "amount", "type": "int256" }, { "name": "skillId", "type": "uint256" }, { "name": "colony", "type": "address" }, { "name": "nUpdates", "type": "uint128" }, { "name": "nPreviousUpdates", "type": "uint128" } ], "name": "reputationUpdateLogEntry", "type": "tuple" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": false, "inputs": [ { "name": "stakers", "type": "address[]" }, { "name": "weights", "type": "uint256[]" }, { "name": "metaColonyAddress", "type": "address" }, { "name": "reward", "type": "uint256" }, { "name": "miningSkillId", "type": "uint256" } ], "name": "rewardStakersWithReputation", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": true, "inputs": [], "name": "getReputationMiningWindowOpenTimestamp", "outputs": [ { "name": "timestamp", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": false, "inputs": [ { "name": "tokenLocking", "type": "address" }, { "name": "clnyToken", "type": "address" } ], "name": "initialise", "outputs": [], "payable": false, "stateMutability": "nonpayable", "type": "function" }, { "constant": true, "inputs": [], "name": "getNUniqueSubmittedHashes", "outputs": [ { "name": "nUniqueSubmittedHashes", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [], "name": "getNInvalidatedHashes", "outputs": [ { "name": "nInvalidatedHashes", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [], "name": "getMinStake", "outputs": [ { "name": "minStake", "type": "uint256" } ], "payable": false, "stateMutability": "pure", "type": "function" }, { "constant": true, "inputs": [], "name": "getMiningWindowDuration", "outputs": [ { "name": "miningWindowDuration", "type": "uint256" } ], "payable": false, "stateMutability": "pure", "type": "function" }, { "constant": true, "inputs": [], "name": "getDecayConstant", "outputs": [ { "name": "numerator", "type": "uint256" }, { "name": "denominator", "type": "uint256" } ], "payable": false, "stateMutability": "pure", "type": "function" }, { "constant": true, "inputs": [ { "name": "hash", "type": "bytes32" }, { "name": "nNodes", "type": "uint256" }, { "name": "jrh", "type": "bytes32" }, { "name": "index", "type": "uint256" } ], "name": "getSubmissionUser", "outputs": [ { "name": "user", "type": "address" } ], "payable": false, "stateMutability": "view", "type": "function" }, { "constant": true, "inputs": [ { "name": "hash", "type": "bytes32" }, { "name": "nNodes", "type": "uint256" }, { "name": "jrh", "type": "bytes32" } ], "name": "getNSubmissionsForHash", "outputs": [ { "name": "count", "type": "uint256" } ], "payable": false, "stateMutability": "view", "type": "function" } ], "devdoc": { "methods": { "appendReputationUpdateLog(address,int256,uint256,address,uint128,uint128)": { "params": { "_amount": "The amount by which the user's reputation is going to change. Can be positive or negative.", "_colonyAddress": "The address of the colony the reputation is being affected in", "_nChildren": "The number of child skills the skill defined by the skillId has", "_nParents": "The number of parent skills the skill defined by the skillId has", "_skillId": "The skillId of the reputation being affected", "_user": "The address of the user having their reputation changed by this log entry" } }, "challengeRoundComplete(uint256)": { "params": { "round": "The round number to check" }, "return": "complete Boolean indicating whether the given round challenge is complete" }, "confirmBinarySearchResult(uint256,uint256,bytes,uint256,bytes32[])": { "params": { "branchMask": "The branchMask of the Merkle proof that `jhIntermediateValue` is the value at key `targetNode`", "idx": "The index in the round that the hash we are responding on behalf of is in", "jhIntermediateValue": "The contents of the Justification Tree at the key given by `targetNode` (see function description). The value of `targetNode` is computed locally to establish what to submit to this function.", "round": "The round number the hash we are responding on behalf of is in", "siblings": "The siblings of the Merkle proof that `jhIntermediateValue` is the value at key `targetNode`" } }, "confirmJustificationRootHash(uint256,uint256,uint256,bytes32[],uint256,bytes32[])": { "details": "The majority of calls to this function will have `round` equal to `0`. The exception to this is when a submitted hash is given a bye, in which case `round` will be nonzero.Note that it is possible for this function to be required to be called in every round - the hash getting the bye can wait until they will also be awarded the bye in the next round, if one is going to exist. There is an incentive to do so from a gas-cost perspective, but they don't know for sure there's going to be a bye until the submission window has expired, so I think this is okay.", "params": { "branchMask1": "The branchmask for the Merkle proof that the currently accepted reputation state (given by `ColonyNetwork.getReputationRootHash()` + `ColonyNetwork.getReputationRootHashNNodes()`, where `+` is concatenation) is at key 0x000..000 in the submitted JRH", "branchMask2": "The branchmask for the Merkle proof that the proposed new reputation state is at the key corresponding to the number of transactions expected in this update in the submitted JRH. This key should be the number of decay transactions plus the number of transactions the log indicates are to happen.", "index": "The index in the round that the hash is currently in", "round": "The round that the hash is currently in.", "siblings1": "The siblings for the same Merkle proof", "siblings2": "The siblings for the same Merkle proof" } }, "confirmNewHash(uint256)": { "params": { "roundNumber": "The round number that the hash being confirmed is in as the only contendender. If only one hash was submitted, then this is zero." } }, "getDecayConstant()": { "return": "numerator The numerator of the decay constantdenominator The denominator of the decay constant" }, "getDisputeRound(uint256)": { "params": { "_round": "The dispute round to query" }, "return": "submissions An array of DisputedEntrys struct for the round. See ReputationMiningCycleDataTypes for the full description of the properties." }, "getEntryHash(address,uint256,bytes32)": { "params": { "entryIndex": "The index of the entry that they used to submit the hash", "newHash": "The hash that they submitted", "submitter": "The address that submitted the hash" }, "return": "entryHash The hash for the corresponding entry" }, "getMinStake()": { "return": "minStake The minimum stake amount" }, "getMiningWindowDuration()": { "return": "miningWindowDuration Duration of the reputation mining window in seconds" }, "getNInvalidatedHashes()": { "return": "nInvalidatedHashes Number of invalidated hashes in this mining cycle" }, "getNSubmissionsForHash(bytes32,uint256,bytes32)": { "params": { "hash": "The hash that was submitted", "jrh": "The JRH of that was submitted", "nNodes": "The number of nodes that was submitted" }, "return": "count The number of submissions - should be 0-12, as up to twelve submissions can be made" }, "getNUniqueSubmittedHashes()": { "return": "nUniqueSubmittedHashes Number of unique hash/nnodes/jrh sets in this cycle" }, "getReputationHashSubmission(address)": { "params": { "_user": "Address of the user" }, "return": "submission the Submission struct for the submission requested. See ReputationMiningCycleDataTypes.sol for the full description." }, "getReputationMiningWindowOpenTimestamp()": { "return": "timestamp The timestamp" }, "getReputationUpdateLogEntry(uint256)": { "params": { "_id": "The reputation log members array index of the entry to get" }, "return": "reputationUpdateLogEntry The Reputation Update Log Entry" }, "getReputationUpdateLogLength()": { "return": "nUpdates" }, "getSubmissionUser(bytes32,uint256,bytes32,uint256)": { "params": { "hash": "The hash that was submitted", "index": "The index of the submission - should be 0-11, as up to twelve submissions can be made.", "jrh": "The JRH of that was submitted", "nNodes": "The number of nodes that was submitted" }, "return": "user Address of the user that submitted the hash / nNodes/ jrh at index" }, "initialise(address,address)": { "details": "This will only be called once, by ColonyNetwork, in the same transaction that deploys this contract.", "params": { "clnyToken": "Address of the CLNY token", "tokenLocking": "Address of the TokenLocking contract" } }, "invalidateHash(uint256,uint256)": { "params": { "idx": "The index in the round that the hash being invalidated is in", "round": "The round number the hash being invalidated is in" } }, "minerSubmittedEntryIndex(address,uint256)": { "params": { "_index": "The index of the entry that they used to submit the hash", "_miner": "The address that submitted the hash" }, "return": "result Boolean whether the entryIndex was already submitted" }, "resetWindow()": { "details": "only allowed to be called by ColonyNetwork." }, "respondToBinarySearchForChallenge(uint256,uint256,bytes,uint256,bytes32[])": { "params": { "branchMask": "The branchMask of the Merkle proof that `jhIntermediateValue` is the value at key `targetNode`", "idx": "The index in the round that the hash we are responding on behalf of is in", "jhIntermediateValue": "The contents of the Justification Tree at the key given by `targetNode` (see function description). The value of `targetNode` is computed locally to establish what to submit to this function.", "round": "The round number the hash we are responding on behalf of is in", "siblings": "The siblings of the Merkle proof that `jhIntermediateValue` is the value at key `targetNode`" } }, "respondToChallenge(uint256[29],bytes32[8],bytes32[],bytes32[],bytes32[],bytes32[],bytes32[],bytes32[],bytes32[])": { "details": "note that these are all bytes32; the address should be left padded from 20 bytes to 32 bytes. Strictly, I do not believe the padding matters, but you should use 0s for your own sanity!If you know that the disagreement doesn't involve a new reputation being added, the arguments corresponding to the previous new reputation can be zeroed, as they will not be used. You must be sure that this is the case, however, otherwise you risk being found incorrect. Zeroed arguments will result in a cheaper call to this function.", "params": { "adjacentReputationSiblings": "Nonzero for updates involving insertion of a new skill. The siblings of the Merkle proof of a reputation in the agree state that ends adjacent to the new reputation", "agreeStateSiblings": "The siblings of the Merkle proof that the last reputation state the submitted hashes agreed on is in this submitted hash's justification tree", "b32": "A `bytes32[8]` array. The elements of this array, in order are: * 1. The colony address in the key of the reputation being changed that the disagreement is over. * 2. The skillid in the key of the reputation being changed that the disagreement is over. * 3. The user address in the key of the reputation being changed that the disagreement is over. * 4. The keccak256 hash of the key of the reputation being changed that the disagreement is over. * 5. The keccak256 hash of the key of the newest reputation added to the reputation tree in the last reputation state the submitted hashes agree on * 6. The keccak256 hash of the key for a reputation already in the tree adjacent to the new reputation being inserted, if required. * 7. The keccak256 hash of the key of the reputation that would be origin-adjacent that proves that the origin reputation does not exist in the tree * 8. The keccak256 hash of the key of the reputation that would be child-adjacent that proves that the child reputation does not exist in the tree", "childReputationSiblings": "Nonzero for child updates of a colony-wide global skill. The siblings of the Merkle proof of the child skill reputation of the user in the same skill this global update is for", "disagreeStateSiblings": "The siblings of the Merkle proof that the first reputation state the submitted hashes disagreed on is in this submitted hash's justification tree", "previousNewReputationSiblings": "The siblings of the Merkle proof of the newest reputation added to the reputation tree in the last reputation state the submitted hashes agree on", "reputationSiblings": "The siblings of the Merkle proof that the reputation corresponding to `_reputationKey` is in the reputation state before and after the disagreement", "u": "A `uint256[27]` array. The elements of this array, in order are: * 1. The current round of the hash being responded on behalf of * 2. The current index in the round of the hash being responded on behalf of * 3. The branchMask of the proof that the reputation is in the reputation state tree for the reputation with the disputed change * 4. The number of nodes in the last reputation state that both submitted hashes agree on * 5. The branchMask of the proof that the last reputation state the submitted hashes agreed on is in this submitted hash's justification tree * 6. The number of nodes this hash considers to be present in the first reputation state the two hashes in this challenge disagree on * 7. The branchMask of the proof that reputation root hash of the first reputation state the two hashes in this challenge disagree on is in this submitted hash's justification tree * 8. The branchMask of the proof for the most recently added reputation state in this hash's state tree in the last reputation state the two hashes in this challenge agreed on * 9. The index of the log entry that the update in question was implied by. Each log entry can imply multiple reputation updates, and so we expect the clients to pass the log entry index corresponding to the update to avoid us having to iterate over the log. * 10. A dummy variable that should be set to 0. If nonzero, transaction will still work but be slightly more expensive. For an explanation of why this is present, look at the corresponding solidity code. * 11. Origin skill reputation branch mask. Nonzero for child reputation updates. /// * 12. The amount of reputation that the entry in the tree under dispute has in the agree state * 13. The UID that the entry in the tree under dispute has in the agree state * 14. The amount of reputation that the entry in the tree under dispute has in the disagree state * 15. The UID that the entry in the tree under dispute has in the disagree state * 16. The amount of reputation that the most recently added entry in the tree has in the state being disputed * 17. The UID that the most recently added entry in the tree has in the state being disputed * 18. The amount of reputation that the user's origin reputation entry in the tree has in the state being disputed * 19. The UID that the user's origin reputation entry in the tree has in the state being disputed * 20. The branchMask of the proof that the child reputation for the user being updated is in the agree state * 21. The amount of reputation that the child reputation for the user being updated is in the agree state * 22. The UID of the child reputation for the user being updated in the agree state * 23. A dummy variable that should be set to 0. If nonzero, transaction will still work but be slightly more expensive. For an explanation of why this is present, look at the corresponding solidity code. * 24. The branchMask of the proof that the reputation adjacent to the new reputation being inserted is in the agree state * 25. The amount of reputation that the reputation adjacent to a new reputation being inserted has in the agree state * 26. The UID of the reputation adjacent to the new reputation being inserted * 27. A dummy variable that should be set to 0. If nonzero, transaction will still work but be slightly more expensive. For an explanation of why this is present, look at the corresponding solidity code. * 28. The value of the reputation that would be origin-adjacent that proves that the origin reputation does not exist in the tree * 29. The value of the reputation that would be child-adjacent that proves that the child reputation does not exist in the tree", "userOriginReputationSiblings": "Nonzero for child updates only. The siblings of the Merkle proof of the user's origin skill reputation added to the reputation tree in the last reputation state the submitted hashes agree on" } }, "rewardStakersWithReputation(address[],uint256[],address,uint256,uint256)": { "details": "Only callable by colonyNetwork. Note that the same address might be present multiple times in `stakers` - this is acceptable, and indicates the same address backed the same hash multiple times with different entries.", "params": { "metaColonyAddress": "The address of the meta colony, which the special mining skill is earned in", "miningSkillId": "Skill id of the special mining skill", "reward": "The amount of reputation to be rewarded to each staker", "stakers": "The array of stakers addresses to receive the reward.", "weights": "The array of weights determining the proportion of reward to go to each staker" } }, "submitRootHash(bytes32,uint256,bytes32,uint256)": { "params": { "entryIndex": "The entry number for the given `newHash` and `nNodes`", "jrh": "The justifcation root hash for this submission", "nNodes": "Number of nodes in tree with root `newHash`", "newHash": "The proposed new reputation root hash" } } } }, "userdoc": { "methods": { "appendReputationUpdateLog(address,int256,uint256,address,uint128,uint128)": { "notice": "Add a new entry to the reputation update log." }, "challengeRoundComplete(uint256)": { "notice": "Get whether a challenge round is complete." }, "confirmBinarySearchResult(uint256,uint256,bytes,uint256,bytes32[])": { "notice": "Confirm the result of a binary search - depending on how exactly the binary search finished, the saved binary search intermediate state might be incorrect.This function ensures that the intermediate hashes saved are correct." }, "confirmJustificationRootHash(uint256,uint256,uint256,bytes32[],uint256,bytes32[])": { "notice": "Verify the Justification Root Hash (JRH) for a submitted reputation hash is plausible." }, "confirmNewHash(uint256)": { "notice": "Confirm a new reputation hash. The hash in question is either the only one that was submitted this cycle, or the last one standing after all others have been proved wrong." }, "getDecayConstant()": { "notice": "Get the reputation decay constant." }, "getDisputeRound(uint256)": { "notice": "The getter for the disputeRounds mapping." }, "getEntryHash(address,uint256,bytes32)": { "notice": "Get the hash for the corresponding entry." }, "getMinStake()": { "notice": "Get the minimum stake of CLNY required to mine." }, "getMiningWindowDuration()": { "notice": "Get the length of the mining window in seconds." }, "getNInvalidatedHashes()": { "notice": "Get the number of hashes that have been invalidated this mining cycle." }, "getNSubmissionsForHash(bytes32,uint256,bytes32)": { "notice": "Get the number of submissions miners made of a particular hash / nNodes / jrh combination." }, "getNUniqueSubmittedHashes()": { "notice": "Get the number of unique hash/nnodes/jrh sets that have been submitted this mining cycle." }, "getReputationHashSubmission(address)": { "notice": "The getter for the hashSubmissions mapping, which keeps track of submissions by user." }, "getReputationMiningWindowOpenTimestamp()": { "notice": "Get the timestamp that the current reputation mining window opened." }, "getReputationUpdateLogEntry(uint256)": { "notice": "Get the `ReputationLogEntry` at index `_id`." }, "getReputationUpdateLogLength()": { "notice": "Get the length of the ReputationUpdateLog stored on this instance of the ReputationMiningCycle contract." }, "getSubmissionUser(bytes32,uint256,bytes32,uint256)": { "notice": "Get the address that made a particular submission." }, "initialise(address,address)": { "notice": "Initialise this reputation mining cycle." }, "invalidateHash(uint256,uint256)": { "notice": "Invalidate a hash that has timed out relative to its opponent its current challenge step. Note that this can be called to 'invalidate' a nonexistent hash, if the round has an odd number of entrants and so the last hash is being given a bye to the next round." }, "minerSubmittedEntryIndex(address,uint256)": { "notice": "Returns a boolean result of whether the miner has already submitted at this entry index." }, "resetWindow()": { "notice": "Resets the timestamp that the submission window opens to `now`." }, "respondToBinarySearchForChallenge(uint256,uint256,bytes,uint256,bytes32[])": { "notice": "Respond to a binary search step, to eventually discover where two submitted hashes differ in their Justification trees." }, "respondToChallenge(uint256[29],bytes32[8],bytes32[],bytes32[],bytes32[],bytes32[],bytes32[],bytes32[],bytes32[])": { "notice": "Respond to challenge, to establish which (if either) of the two submissions facing off are correct." }, "rewardStakersWithReputation(address[],uint256[],address,uint256,uint256)": { "notice": "Start the reputation log with the rewards for the stakers who backed the accepted new reputation root hash." }, "submitRootHash(bytes32,uint256,bytes32,uint256)": { "notice": "Submit a new reputation root hash." } } } }