---
description: Describes the dispute management and other Native Athena features
---

# Native Athena Contract

The Native Athena Contract drives decentralised dispute resolution and skill verification using oracle member votes and fee incentives.

This table describes the features in more detail.

| Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | Implementation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Once created and active \[as described under the[ ](https://openwork.gitbook.io/openwork/smart-contract-details/openapi-1)[Main DAO](https://openwork.gitbook.io/openwork/smart-contract-details/openapi-1)] a skill oracle can add or remove members and also function for dispute resolution.                                                                                                                                                                                                                    | <p>isActive(oracle_name){<br>check if an Oracle has 20 members</p><p>}</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Jobs come to the oracle to resolve disputes with an incentive fee paid by the dispute raiser \[minimum being $50]. The dispute includes a description and an amount. \[For example, description: “The job is done, $100 USDT needs to come to me for the work I’ve done. Here’s the proof of it..”, amount: 100 USDT, to: \<job taker>                                                                                                                                                                             | <p>Struct:<br>Dispute {<br>JobID,<br>DisputedAmount,<br>Hash,<br>Dispute Raiser Address,<br>Votes for, Votes Against, Result,<br>isVotingActive, timeStamp}<br><br>Function:<br>raiseDispute(jobId, disputeHash, oracleName, fee) {<br>isOracleActive?<br>getJobDetails()<br>check if caller is involved in the job<br>create a new Dispute<br>}</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Members from the skill oracle vote for or against with an optional reason where more than 50%+ votes (calculated by staked amount) are sent an X amount either to the job giver or taker. Winning stakers receive the fee paid. The Athena contract \[linked to job contract] executes the decision made. There is a 4 day timer. If no votes are made, the funds are refunded.                                                                                                                                    | <p>The applicable Skill Oracle member will vote using the below function(exact implementation may change, but roughly this logic)<br><br>voteOnDispute(jobId, vote) {<br>check if caller is member of skill oracle<br>check if dispute/job exists<br>check if Dispute raised more than 4 days ago<br>add vote to "Votes for"/"Vote Against"<br>}<br><br>claimRefund(jobID) {<br>isDisputer?<br>DisputeExists?<br>see if dispute is more than 4 days old &#x26; there are no votes<br>refund fee to msg.sender }<br><br><br>claimFee(applicationID) {<br>check if caller is a voter on this application<br>calculate fee to be paid<br>pay fee<br>}</p>                                                                                                                                                                                      |
| Skill verification applications can come to the skill oracle for a min. $50 fee. These contain the skill and description of application including profile. Members from the skill oracle can vote for or against with an optional reason where more than 50%+ votes (calculated by staked amount) determines that the address gets the skill. Winning stakers receive the fee paid. The address is given the verified skill tag if verified. There is a 4 day timer. If no votes are made, the funds are refunded. | <p>Structs:<br><br>AllSkills { skillName :{ description, oracleMembers, qualifiedApplicants, isActive} }<br></p><p>skillApplication { skillName, applicant, applicationID application_hash, votes-for, votes-against, result timestamp}<br><br>Functions:<br><br>applyToSkill(skillName, application_hash, fee_amount) {<br>check if skillOracle is Active<br>create a Skill Application<br>deduct fee amount<br>}<br><br>voteOnSkillApplication(jobID, vote) {<br>see if caller is oracle member<br>see if dispute is more than 4 days older<br>add votes-for/against<br>}<br><br>claimRefund(applicationID) {<br>see if caller is applicant<br>see if dispute exists<br>see if dispute is more than 4 days old}<br>refund fee to msg.sender }<br><br>claimFee(applicationID) {<br>check if caller is a voter on this application<br>}</p> |
| If found malicious by the Skill oracle or DAO, the staker at any point can have all their tokens taken from them.                                                                                                                                                                                                                                                                                                                                                                                                  | this is done in the Native DAO                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| <p>Athena should be made upgradable so it’s compatible with future needs for programming jobs and making assessments based on other factors other than disputes.<br></p>                                                                                                                                                                                                                                                                                                                                           | <p>askAthena(description, fee) <br>A special type-of proposal which anyone can call by offering a fee and seek a yes/no answer from Athena.<br><br></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| <p>All rules must be upgradable.<br></p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | This is done through the Main DAO using the UUPS upgrade process. i.e. to upgrade the implementation contract.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
