# Introduction
Athena is a decentralized, non-custodial liquidity protocol that allows users to participate either as liquidity providers or cover seekers. Liquidity providers supply funds to the market to earn passive income, while cover seekers can subscribe to insurance services.
This documentation outlines the core principles of the protocol and explains how to engage with it. We invite you to join the Athena community—our team and fellow members are excited to support you in building on top of Athena.
The protocol is implemented as a set of smart contracts on top of the Arbitrum blockchain. Smart contracts guarantee safety and do not require a middleman.
# Protocol Overview
Athena is a decentralized insurance protocol that uses innovative tokenization to manage liquidity positions and cover contracts. Our system revolves around two main types of ERC-721 (NFT) tokens, each representing a unique user "contract" within the protocol.
The use of ERC-721 tokens allows Athena to incorporate detailed and customized parameters for each cover and liquidity position while maintaining a familiar token-based interaction for users. Unlike standard ERC-20 tokens, these NFTs can store complex, individualized data structures, enabling specific coverage limits, or unique liquidity allocation strategies.
This approach combines the flexibility of customized contracts with the user-friendly experience of token management, making sophisticated insurance and liquidity provision accessible through everyday blockchain interactions. Additionally, it ensures unique identification and seamless transferability of user rights within the protocol, enhancing both security and convenience for Athena's users.
## Tokenized Contracts in Athena
1. **Liquidity Position NFT**: Represents a user's stake in the protocol's cover pools.
2. **Cover NFT**: Represents a user's insurance coverage.
These NFTs serve as proof of ownership for liquidity positions and cover contracts, enabling easy identification and interaction with the protocol.
## Key Protocol Interactions
### For Cover Buyers
1. Users request to open a cover by depositing ERC-20 tokens as premiums.
2. Athena checks cover requirements and mints an ERC-721 Cover NFT to the user.
3. To claim, users request to open a claim using their Cover NFT.
4. Athena verifies ownership and processes the claim, refunding ERC-20 tokens if valid.
### For Liquidity Providers
1. Users request to open a position by depositing ERC-20 tokens as liquidity.
2. Athena adds liquidity to cover pools, places it in DeFi strategies, and mints an ERC-721 Position NFT to the user.
3. Users can request withdrawals or take interests using their Position NFT.
# Why Athena ?
Athena is revolutionizing the DeFi insurance landscape, offering a decentralized, efficient, and rewarding cover system for both users and liquidity providers.
It is born from the experiences of DeFi enthusiasts who recognized the shortcomings of existing insurance options. We are convinced Athena addresses the key challenges in the space while introducing innovative features that benefit all participants.
## The Athena Pillars
### 1. Truly Decentralized Protection
Unlike many existing insurance options that rely on centralized decision-making, Athena embraces the core principles of DeFi. Our system is built on smart contracts and community governance, ensuring transparency, fairness, and resistance to censorship.
### 2. Enhanced Liquidity
We've tackled the persistent problem of low liquidity in DeFi insurance pools. By allowing liquidity providers to use yield bearing LP tokens and leverage, we've created a system that enables deeper liquidity. This ensures that cover buyers always have access to the protection they need.
### 3. Rewarding Liquidity Provision
Athena makes it profitable to be a liquidity provider:
* **Base Yield**: Liquidity providers earn a base yield from the underlying LP tokens, ensuring consistent returns even in periods of low cover demand.
* **Cover Rewards**: On top of the base yield, providers earn additional rewards from cover premiums.
* **Leverage Opportunities**: Unique to Athena, providers can increase their rewards by leveraging their liquidity across multiple pools, balancing higher returns with manageable risk.
* **Farming Rewards**: Athena's farming program offers additional incentives to liquidity providers, ensuring that they are rewarded for their commitment to the system.
### 4. Affordable Coverage
By optimizing our liquidity and reward systems, we're able to offer competitive pricing on cover products. DeFi users can protect their assets without breaking the bank, making insurance an accessible option for a broader range of participants.
### 5. Flexible Risk Management
Our multi-pool leverage system allows liquidity providers to tailor their risk exposure. Whether you're risk-averse or seeking higher returns, Athena's system lets you adjust your strategy to match your goals.
### 6. Efficient Claims Process
We've streamlined the claims process to ensure quick and fair resolutions:
* **Transparent Evaluation**: All claims are evaluated based on publicly available evidence.
* **Community Involvement**: Our prosecution system allows the community to challenge fraudulent claims, maintaining the integrity of the system.
* **Quick Payouts**: Valid claims are processed swiftly, providing peace of mind to cover holders.
## Join Athena
We've combined the best aspects of DeFi to create a cover system that truly serves its users. Protect your assets, earn rewards, and become part of a system that's reshaping the landscape of risk management in the decentralized world.
Ready to get started?
* [Learn how to protect your assets](/guides/cover-buy)
* [Learn how to become a liquidity provider](/guides/liquidity-provide)
# Virtual Pools
The Athena Virtual Pool system is an innovative solution designed to optimize liquidity management, risk coverage, and capital efficiency in decentralized finance (DeFi).
This system forms the backbone of Athena's protocol, enabling a unique approach to handling liquidity provisions, cover pools, and leveraged positions.
By abstracting the complexities of cover pools and liquidity management, we can introduce the concept of leveraged positions. This flexible solution provides users with better control over their risk exposure and potential returns.
## Overview
At its core, the Virtual Pool system is a sophisticated library utilized by Athena's main contract, the Liquidity Manager. This system creates an abstraction layer between liquidity providers and cover pools, allowing for efficient capital allocation, risk management, and the creation of leveraged positions.
## Key Features
### Liquidity Abstraction
The Virtual Pool system allows liquidity providers to earn interest through various strategies managed by the Strategy Manager, while simultaneously supporting multiple cover pools. This abstraction ensures that capital is not idle and can be productively deployed across different risk pools.
### Dynamic Cover Pricing
The system implements a dynamic pricing model for cover premiums. This model adjusts based on the utilization rate of the pool, ensuring that premiums accurately reflect the current risk and liquidity conditions.
### Efficient Capital Utilization
By separating the concept of liquidity provision from the actual cover pools, Athena can maximize capital efficiency. Liquidity can be directed to yield-generating strategies while still being available for potential cover payouts across multiple pools.
### Scalable Risk Management
The Virtual Pool system allows for the creation and management of multiple cover pools without the need for separate liquidity pools for each. This scalability enables Athena to offer a wide range of coverage options without fragmenting liquidity.
### Leveraged Positions
One of the most powerful features of the Virtual Pool system is its ability to manage leveraged positions. Liquidity providers can allocate their capital across several cover pools, effectively creating a leveraged position. This allows them to potentially earn higher rewards in exchange for covering more risk.
## How It Works
1. **Virtual Pool Creation**: The system creates virtual representations of multiple cover pools.
2. **Liquidity Provision**: Users provide liquidity to the Athena protocol.
3. **Strategy Deployment**: The actual liquidity is deployed into yield-generating strategies.
4. **Leveraged Positions**: Users can opt to spread their liquidity across multiple Virtual Pools, creating leveraged positions.
5. **Cover Management**: Each Virtual Pool handles cover pricing, premium calculations, and reward distributions for its respective risk pool.
6. **Dynamic Adjustments**: The system continuously adjusts parameters based on utilization rates and market conditions across all pools.
## Benefits
* **Enhanced Yields**: Liquidity providers can earn from both strategy yields and cover premiums, with the potential for higher returns through leveraged positions.
* **Flexible Risk Coverage**: The protocol can offer various types of coverage without liquidity constraints, and users can choose their risk exposure.
* **Optimized Capital Efficiency**: Funds are always productively deployed, either backing covers in multiple pools or generating yields.
* **Scalable Infrastructure**: The system can easily accommodate new cover types or strategies without major restructuring.
* **Risk-Reward Customization**: Users can tailor their risk exposure and potential rewards by choosing how to allocate their capital across different Virtual Pools.
# Cover Duration
## What are Ticks?
In the Athena protocol, the duration of covers is tracked using ticks. Ticks are like markers on a timeline. They help us track the passage of time for covers and manage the pool's resources efficiently. Think of ticks as checkpoints in the life of a cover.
## How Ticks Relate to Cover Durations
When you purchase a cover in Athena, its duration isn't set in stone with a fixed end date. Instead, it's measured in ticks. This flexible approach allows the protocol to adapt to changing market conditions.
### Dynamic Duration
The time between ticks (called "seconds per tick") can change based on how busy the pool is:
* When the pool is less busy, ticks are further apart. This means your cover lasts longer in real time.
* When the pool is busier, ticks are closer together. Your cover might not last as long in real time, but this reflects the increased risk in the pool.
## Visualizing Cover Durations
Imagine your cover as a span on this tick timeline:
* It starts at the tick when you buy the cover.
* It ends at a future tick, determined by how many premiums you've paid.
As the pool's activity changes, you might see your cover's real-time duration stretch or shrink, but the number of ticks it spans remains the same.
## Why This Matters for Users
1. **Flexibility**: Your cover adapts to market conditions automatically.
2. **Fairness**: The system ensures that all users' covers are treated equally as pool conditions change.
3. **Transparency**: You can always see how many ticks your cover has left, giving you a clear idea of your protection status.
## Key Takeaways
* Ticks are Athena's way of measuring time for covers.
* Your cover's duration in real time can change, but its tick duration remains constant.
* This system allows Athena to balance user protection with pool health dynamically.
# Arbitration
Athena's claim process is designed to be fair, transparent, and efficient by leveraging decentralized arbitration to ensure just outcomes for all parties involved.
## Key Strengths
1. **User-Centric Design**: The process is structured to protect both cover holders and the liquidity providers.
2. **Decentralized Arbitration**: Utilizes Kleros for impartial dispute resolution.
3. **Incentivized Fairness**: Collateral requirements discourage frivolous claims.
4. **Transparent Timeline**: Clear periods for challenges and resolutions.
## Process Overview
## Important Information for Users
1. **Claim Initiation**:
* Ensure you have sufficient funds for the required collateral and arbitration costs.
* Prepare any documents you wish to submit as evidence if you think it is necessary.
2. **Challenge Period**:
* Be aware of the challenge period duration.
* Undisputed claims are automatically accepted after this period.
3. **Claim Prosecution**:
* Prepare and submit comprehensive evidence to support your case.
* Athena may provide additional information to strengthen you case.
4. **Claim Resolution**:
* Accepted claims lead to compensation withdrawal.
* Rejected claims may result in loss of collateral.
5. **Overrule Period**:
* This is a temporary measure to support the launch of Athena.
* There's a window for intervention in case of clear arbitration mistakes.
* This adds an extra layer of protection against erroneous decisions.
# Computations
This page outlines the major computations that occur within the Athena protocol. These calculations are crucial for understanding the mechanics of cover pricing, liquidity provision, and reward distribution.
{% hint style="warning" %}
This page is still being expanded. Information might be incomplete.
{% endhint %}
## Utilization Rate
The utilization rate (U) is a key metric that influences many aspects of the protocol. It represents the percentage of liquidity in a pool that is currently locked as a guarantee for bought covers.
$$U = \frac{\text{Total covered amount}}{\text{Total liquidity}} \times 100%$$
Example:
```
Total liquidity in pool = $10,000
Total covered amount in pool = $3,500
U = (3,500 / 10,000) × 100% = 35%
```
## Premium Rate
The premium rate (P\_r) is calculated using a bi-linear curve based on the utilization rate. It determines the cost of covers and rewards for liquidity providers.
Let:
* u\_optimal = optimal utilization rate
* r\_0 = base premium rate at 0% utilization
* r\_slope1 = premium slope below optimal utilization
* r\_slope2 = premium slope above optimal utilization
Then:
For U ≤ u\_optimal: $$P\_r = r\_0 + \frac{U}{u\_{optimal}} \cdot r\_{slope1}$$
For U > u\_optimal: $$P\_r = r\_0 + r\_{slope1} + \frac{U - u\_{optimal}}{1 - u\_{optimal}} \cdot r\_{slope2}$$
Example:
```
u_optimal = 80%
r_0 = 2%
r_slope1 = 6%
r_slope2 = 15%
For U = 40%:
P_r = 2% + (40% / 80%) × 6% = 5%
For U = 90%:
P_r = 2% + 6% + ((90% - 80%) / (100% - 80%)) × 15% = 15.5%
```
## Reward Rate
The reward rate (R\_r) for liquidity providers is calculated by multiplying the utilization rate and the premium rate:
$$R\_r = U \times P\_r$$
Example:
```
U = 50%
P_r = 8%
R_r = 50% × 8% = 4%
```
## Cover Duration and Tick Spacing
The duration of a cover is measured in ticks, with the time between ticks (seconds per tick) varying based on pool utilization. The maximum seconds per tick is 86,400 (1 day), and the minimum is calculated as:
$$\text{min seconds per tick} = 86400 \times \frac{r\_0}{r\_0 + r\_{slope1} + r\_{slope2}}$$
The actual seconds per tick (s\_t) at a given utilization is:
$$s\_t = 86400 - (86400 - \text{min seconds per tick}) \times U$$
## Liquidity Index Computation
The liquidity index (L\_i) tracks the accumulation of premium rewards. For a given period:
$$L\_i = \text{capital} \times R\_r \times \frac{\text{elapsed time}}{\text{one year}}$$
Example:
```
capital = $10,000
R_r = 4%
elapsed time = 10 days
L_i = 10,000 × 4% × (10 / 365) = $10.96
```
## Compensation Impact on Leveraged Positions
When a compensation occurs in a pool, it affects the liquidity of other pools with shared (leveraged) liquidity. The impact is calculated as:
$$\text{Impact ratio} = \frac{\text{Compensation amount}}{\text{Total pool liquidity}}$$
For the pool where the compensation occurs: $$\text{New liquidity} = \text{Old liquidity} \times (1 - \text{Impact ratio})$$
For pools with shared liquidity: $$\text{New shared liquidity} = \text{Old shared liquidity} \times (1 - \text{Impact ratio})$$
Example:
```
Pool A liquidity = $3,000 (including $1,000 shared with Pool B)
Pool B liquidity = $2,000 (including $1,000 shared with Pool A)
Compensation in Pool A = $1,000
Impact ratio = 1,000 / 3,000 = 33.33%
New Pool A liquidity = 3,000 × (1 - 0.3333) = $2,000
New Pool B liquidity = 2,000 - (1,000 × 0.3333) = $1,667
```
These computations form the backbone of Athena's risk assessment, pricing, and reward distribution mechanisms. Understanding them is crucial for analysts and users looking to deeply engage with the protocol.
# Terminology
{% hint style="warning" %}
This page is still being expanded. Information might be incomplete.
{% endhint %}
## ATEN
The native token of the Athena protocol, used for governance and staking.
## Claim
A request for compensation submitted by a cover holder when they believe the conditions for a payout have been met.
## Compensation
The payout made to cover holders when a valid claim is approved.
## Cover
Protection purchased by users to insure their assets against specific risks in DeFi protocols.
## Cover Pool
A pool of liquidity dedicated to providing coverage for a specific DeFi protocol or asset.
## Deductible
A small portion of cover refunds used to buy back and burn ATEN tokens, helping to stabilize token value during high claim activity periods.
## Leverage (in positions)
When a liquidity provider allocates their capital across multiple cover pools, potentially increasing their rewards but also their risk exposure.
## Liquidity Provider
Users who deposit assets into Athena's cover pools, earning rewards in exchange for underwriting risk.
## Overlaps
The shared liquidity between two or more cover pools, resulting from leveraged positions.
## Pool
A combination of a covered protocol (the insured DeFi protocol) and a strategy protocol (where liquidity is invested for extra rewards).
## Position
Represents a liquidity provider's stake in one or more cover pools, recorded as an ERC-721 token.
## Premium
The fee paid by cover buyers to maintain their protection.
## Premium Rate
The annualized cost of holding a cover in a given pool, expressed as a percentage.
## Prosecutor
A user who challenges a claim by providing evidence that the claim is invalid.
## Ray
A unit used for precise calculations in the protocol, equal to 1e27 (27 decimal places).
## Reward Rate
The annualized return for liquidity providers in a pool, calculated by multiplying the utilization rate and the premium rate.
## Staking
The process of locking up ATEN tokens to earn additional rewards and participate in governance.
## Strategy Protocol
The DeFi protocol where pool liquidity is invested to generate additional yields.
## Tick
A point on the timeline used to track cover durations and pool states. The distance between ticks (seconds per tick) can vary based on pool utilization.
## Utilization Rate
The percentage of a pool's liquidity currently allocated to active covers.
## vATEN
Voting ATEN, representing both governance voting power and share in protocol revenues, obtained by staking ATEN through the DAO.
## Virtual Pool
Athena's method of managing pool liquidity and cover data without creating separate contracts for each pool, allowing for efficient capital allocation.
# Cover - Buy
## How to Buy Cover Protection
This guide will walk you through the process of purchasing cover protection to shield your assets in the DeFi space. Cover protection acts as a safety net, allowing you to claim a payout in case of unexpected incidents or vulnerabilities.
## Steps to Buy Cover
### 1. Connect Your Wallet and Navigate to the Market Page
First, ensure your wallet is connected to the DApp and you're on the correct network. This is crucial for interacting with the smart contracts and accessing the cover pools.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. Navigate to the Market page to view available cover pools.
### 2. Select Your Desired Cover Pool
Browse through the available cover pools and choose the one that best suits your needs.
1. Review the cover pools, considering factors like asset coverage, premium rates, and pool liquidity.
2. Click on your chosen cover pool.
3. Select the "Buy Cover" button to proceed.
### 3. Enter Cover Details
Now, you'll specify the amount of protection you want and the premiums you're willing to deposit.
1. Enter the amount of funds you want to protect. This is the maximum payout you can claim if an incident occurs.
2. Specify the amount of premiums you want to deposit. These funds will be used to pay for your cover and keep it active.
{% hint style="info" %}
* You can deposit as many premiums as you want.
* Unused premiums can be withdrawn later.
* If your cover runs out of premiums, it will automatically close.
* Some pools may require you to deposit the insured assets when creating your cover. In these cases, rewards from the protected assets will finance the cover protection indefinitely. These pools will only require you to specify the amount of protection you want.
{% endhint %}
### 4. Approve the Smart Contract (if necessary)
Depending on the token you're using, you may need to approve the Athena smart contract to interact with your funds.
1. If an "Approve Token" button appears, click it to proceed.
2. If no approval is needed, skip to the next step.
### 5. Wait for Approval Transaction
If you needed to approve the smart contract, wait for the approval transaction to be validated on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 6. Confirm Cover Purchase
Once approved (or if approval wasn't necessary), you can finalize your cover purchase.
1. Review the cover details one last time.
2. Click the "Confirm" button to create the cover.
### 7. Wait for Transaction Validation
The cover purchase transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 8. View Your New Cover
Once the transaction is validated, your new cover will be active and visible in your dashboard.
1. Navigate to your dashboard.
2. Locate your newly purchased cover in the list of active covers.
3. Review the details to ensure everything is correct.
Congratulations! You've successfully purchased cover protection for your assets. Remember to keep an eye on your premium balance and top it up when necessary to maintain continuous coverage.
# Cover - Modify
## How to Modify Your Cover Protection
This guide will walk you through the process of modifying an existing cover protection. You can adjust the amount of protection you have and manage your premium balance, giving you flexibility as your needs change in the DeFi space.
## Steps to Modify a Cover
### 1. Access Your Dashboard
First, ensure you're connected to the DApp and can view your active covers.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. Navigate to the Dashboard page to view your active covers.
### 2. Select the Cover to Modify
From your list of active covers, choose the one you want to adjust.
1. Review your active covers in the dashboard.
2. Click on the specific cover you want to modify.
3. Locate and select the "Modify" button associated with that cover.
### 3. Adjust Cover Details
Now you can modify your cover protection amount and premium balance.
1. Set the new amount of cover protection you desire.
2. Set the new amount of premiums you want.
3. Review the changes carefully before proceeding.
{% hint style="info" %}
* If you remove all premiums, this will permanently close your cover.
* Some pools may require you to deposit the insured assets when increasing your cover. In these cases, rewards from the protected assets will finance the cover protection indefinitely. These pools will only require you to specify the amount of protection you want.
* Consider the impact of your changes on your overall protection and premium costs.
{% endhint %}
### 4. Approve the Smart Contract (if necessary)
If you're adding premiums to your cover, you may need to approve the Athena smart contract to interact with your funds.
1. If an "Approve Token" button appears, click it to proceed.
2. If no approval is needed, skip to the next step.
### 5. Wait for Approval Transaction
If you needed to approve the smart contract, wait for the approval transaction to be validated on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 6. Confirm Cover Modification
Once approved (or if approval wasn't necessary), you can finalize your cover modification.
1. Review the updated cover details one last time.
2. Click the "Confirm" button to modify the cover.
### 7. Wait for Transaction Validation
The cover modification transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 8. Verify Updated Cover
Once the transaction is validated, your cover should reflect the updated amounts.
1. Check your dashboard to see the modified cover details.
2. If the changes don't appear immediately, try refreshing the page.
3. Verify that all modifications (protection amount and premium balance) are correct.
## Important Considerations
* Increasing your cover amount may result in higher premium costs.
* Decreasing your cover amount could leave some of your assets unprotected.
* Removing all premiums will close your cover, leaving you without protection.
* Some modifications may affect your cover's duration or terms. Always review the updated terms after modification.
By following these steps, you've successfully modified your cover protection. Regularly reviewing and adjusting your covers ensures that your protection aligns with your current DeFi activities and risk tolerance.
# Cover - Close
## How to Close a Cover Protection
This guide will walk you through the process of closing a cover protection before its expiration date. Closing a cover early can be useful if you no longer need the protection or want to reallocate your funds.
## Steps to Close a Cover
### 1. Access Your Dashboard
First, ensure you're connected to the DApp and can view your active covers.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. Navigate to the Dashboard page to view your active covers.
### 2. Select the Cover to Close
From your list of active covers, choose the one you want to close.
1. Review your active covers in the dashboard.
2. Click on the specific cover you want to close.
3. Locate and select the "Close" button associated with that cover.
### 3. Confirm Closure
Before finalizing the closure, you'll be presented with important information about closing your cover.
1. Carefully read the information provided. This may include:
* The amount of unspent premiums you'll receive back
2. If you agree and want to proceed, click on the "Confirm" button.
### 4. Wait for Transaction Validation
The cover closure transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
3. Do not close the browser or disconnect your wallet during this process.
### 5. Verify Closure and Refund
Once the transaction is validated, your cover will be officially closed.
1. The cover status in your dashboard will update to "Closed".
2. All unspent premiums will be automatically refunded to your wallet.
3. Verify that you've received the refunded premiums in your wallet.
## Important Notes
* Closing a cover early means you'll no longer be protected against potential incidents.
* The refund amount depends on how much of your premium was unused at the time of closure.
* If you think you might need coverage again soon, consider keeping the cover active for a very low cover amount to avoid the network fees required when new covers are created.
By following these steps, you've successfully closed your cover protection. Remember to regularly review your active covers and adjust them according to your current needs in the DeFi space.
# Liquidity - Provide
## How to Open a Liquidity Position
This guide will walk you through the process of creating a liquidity position in cover pools. By providing liquidity, you can earn both cover and strategy rewards, potentially increasing your overall yield in the DeFi ecosystem.
## Steps to Open a Liquidity Position
### 1. Access the Market Page
First, ensure you're connected to the DApp and can view available cover pools.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. Navigate to the Market page to view the available cover pools.
### 2. Select Your First Pool
Choose a cover pool to begin creating your liquidity position.
1. Review the available cover pools, considering factors like APR, risk level, and underlying assets.
2. Click the "Add to Position" button on your chosen pool to start the position creation process.
### 3. Build Your Position
After selecting your first pool, you can add multiple pools to optimize your position.
1. Review the details of your current selection in the overlay.
2. Consider adding multiple pools to increase your APR. Remember:
* Each additional pool increases your leverage and the corresponding risk fee applied to your cover rewards.
* All pools in your position must use the same strategy.
* Some pools may be incompatible if they have the same underlying protocol risks.
3. Click the "Details" button to view your APR composition and remove pools if needed.
4. Once satisfied with your pool selection, click the "Open Position" button.
### 4. Choose Deposit Token and Amount
Specify the token and amount you want to add to your position.
1. If the pool allows it, choose between depositing the underlying asset or the strategy LP token.
* Underlying tokens are automatically converted to strategy LP tokens during deposit.
2. Enter the amount of tokens you want to add to your position.
3. Review the estimated rewards and risks associated with your deposit.
### 5. Approve the Smart Contract (if necessary)
You may need to approve the Athena smart contract to interact with your funds.
1. If an "Approve Token" button appears, click it to proceed.
2. If no approval is needed, skip to the next step.
### 6. Wait for Approval Transaction
If you needed to approve the smart contract, wait for the approval transaction to be validated on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 7. Confirm Liquidity Addition
Once approved (or if approval wasn't necessary), you can finalize adding liquidity to your position.
1. Review all details of your position one last time.
2. Click the "Confirm" button to add the liquidity to your position.
### 8. Wait for Transaction Validation
The liquidity addition transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 9. Verify Your New Position
Once the transaction is validated, your new liquidity position will be active.
1. Navigate to your Dashboard.
2. Locate your newly created position in the list of active positions.
3. Review the details to ensure everything is correct, including:
* Pools included in your position
* Amount of liquidity provided
* Estimated rewards and APR
## Important Considerations
* Providing liquidity comes with risks, including potential losses in cover pools you provide liquidity to.
* Your actual returns may vary from estimated APRs due to market conditions and pool performance.
* Monitor your position regularly and adjust as needed based on your investment strategy and risk tolerance.
* Be aware of the commit period before withdrawal can be made.
By following these steps, you've successfully opened a liquidity position in one or more cover pools. Remember to stay informed about the performance of your chosen pools and the overall DeFi market conditions to make informed decisions about your investments.
# Liquidity - Add
## How to Add Liquidity to an Existing Position
This guide will walk you through the process of increasing the amount of assets held in your existing liquidity position. By adding more liquidity, you can potentially increase your rewards and strengthen your position in the cover pools.
## Steps to Add Liquidity
### 1. Access Your Dashboard
First, ensure you're connected to the DApp and can view your existing liquidity positions.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. Navigate to the Dashboard page to view your liquidity positions.
### 2. Select the Position to Modify
Choose the liquidity position you want to add more assets to.
1. Review your active liquidity positions in the dashboard.
2. Click on the specific position you want to modify.
3. Locate and select the "Add Liquidity" button associated with that position.
{% hint style="info" %}
If your position has been committed for withdrawal, the "Add Liquidity" action will not be available. You'll need to wait for the withdrawal process to complete or cancel it before adding more liquidity.
{% endhint %}
### 3. Choose Deposit Token and Amount
Specify the token and amount you want to add to your existing position.
1. If the pool allows it, choose between depositing the underlying asset or the strategy LP token.
* Underlying tokens are automatically converted to strategy LP tokens during deposit.
2. Enter the amount of tokens you want to add to your position.
3. Review the impact of this addition on your position, including:
* New total liquidity amount
* Updated estimated rewards
* Any changes in APR or risk profile
### 4. Approve the Smart Contract (if necessary)
You may need to approve the Athena smart contract to interact with your funds, especially if you're using a new token or have increased your allowance.
1. If an "Approve Token" button appears, click it to proceed.
2. If no approval is needed, skip to the next step.
### 5. Wait for Approval Transaction
If you needed to approve the smart contract, wait for the approval transaction to be validated on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 6. Confirm Liquidity Addition
Once approved (or if approval wasn't necessary), you can finalize adding liquidity to your position.
1. Review all details of your liquidity addition one last time, including:
* Amount being added
* Any fees associated with the transaction
* Expected impact on your position
2. Click the "Confirm" button to add the liquidity to your position.
### 7. Wait for Transaction Validation
The liquidity addition transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
3. Do not close the browser or disconnect your wallet during this process.
### 8. Verify Updated Position
Once the transaction is validated, your position should reflect the added liquidity.
1. Check your dashboard to see the updated position details.
2. If the changes don't appear immediately, try refreshing the page.
3. Verify that the new liquidity amount is correct and that your rewards are being calculated based on the new total.
## Important Considerations
* Providing liquidity comes with risks, including potential losses in cover pools you provide liquidity to.
* Your actual returns may vary from estimated APRs due to market conditions and pool performance.
* Monitor your position regularly and adjust as needed based on your investment strategy and risk tolerance.
* Be aware of the commit period before withdrawal can be made.
By following these steps, you've successfully added liquidity to your existing position. Remember to regularly review your positions and adjust your strategy as needed based on market conditions and your financial objectives.
# Liquidity - Withdraw
## How to Withdraw Liquidity from Your Position
This guide will walk you through the process of removing liquidity from your position. It's important to note that this is a two-step process designed to protect cover buyers by ensuring they have a certain delay to claim a refund following an incident. We'll cover the full process in this guide.
## Steps to Withdraw Liquidity
### 1. Access Your Dashboard
First, ensure you're connected to the DApp and can view your existing liquidity positions.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. Navigate to the Dashboard page to view your liquidity positions.
### 2. Initiate the Withdrawal Process
Choose the liquidity position from which you want to withdraw and start the process.
1. Review your active liquidity positions in the dashboard.
2. Click on the specific position you want to withdraw from.
3. Locate and select the "Commit Withdraw" button associated with that position.
{% hint style="info" %}
If your position is already committed for withdrawal, this action will not be available.
{% endhint %}
### 3. Commit to Withdrawal
Before executing the commit transaction, carefully review all the information provided.
1. Read through the details provided, which may include:
* The length of the commit period
* Any implications on rewards or position status during the commit period
2. If you agree with the terms and want to proceed, press the "Confirm" button to execute the commit transaction.
### 4. Wait for Commit Transaction Validation
The commit transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 5. Verify Commit Status and Await Delay Period
Once the commit transaction is validated, your position should reflect the change.
1. Check your dashboard to see the updated position status.
2. Note the delay countdown before you can withdraw your liquidity.
3. Remember that during this commit period, you cannot add liquidity or take interests from your position.
If the changes don't appear immediately, try refreshing the page.
### 6. Initiate Final Withdrawal
Once the delay period has elapsed, you can finalize the withdrawal process.
1. Return to your dashboard and locate the committed position.
2. The "Withdraw" button should now be unlocked. Click it to start the final withdrawal.
### 7. Choose Withdrawal Options
Specify how you want to receive your withdrawn liquidity.
1. If the pool allows, choose between withdrawing the underlying asset or the strategy LP token.
2. Enter the amount of tokens you want to remove from your position.
### 8. Confirm Final Withdrawal
Review all details one last time before executing the final withdrawal.
1. Carefully read all the information about the action you are about to undertake.
2. Double-check the withdrawal amount and token type.
3. Press "Confirm" to execute the final withdrawal transaction.
### 9. Wait for Final Transaction Validation
The final withdrawal transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 10. Verify Received Assets and Updated Position
Once the transaction is validated, you should see the withdrawn assets in your wallet and the changes reflected in your dashboard.
1. Check your wallet balance to confirm the received assets.
2. Review your dashboard to see the updated position details or its removal if you've withdrawn all liquidity.
3. If the changes don't appear immediately, try refreshing the page.
## Important Considerations
* The commit period is crucial for the security of the protocol. Be prepared for this waiting period when planning your withdrawals.
* If you're withdrawing strategy LP tokens instead of the underlying asset, make sure you understand how to handle or exchange these tokens if needed.
By following these steps, you've successfully withdrawn liquidity from your position. Remember to regularly assess your investment strategy and make withdrawals in line with your financial goals and market conditions.
# Liquidity - Uncommit
## How to Uncommit a Withdrawal from Your Position
This guide will walk you through the process of cancelling a previously committed withdrawal from your liquidity position. This action allows you to reverse your decision to withdraw if your investment strategy changes or if market conditions shift.
## Steps to Uncommit a Withdrawal
### 1. Access Your Dashboard
First, ensure you're connected to the DApp and can view your existing liquidity positions.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. Navigate to the Dashboard page to view your liquidity positions.
### 2. Select the Position to Uncommit
Choose the liquidity position from which you want to cancel the withdrawal commitment.
1. Review your active liquidity positions in the dashboard.
2. Identify the position that is currently committed for withdrawal.
3. Click on the specific position you want to uncommit.
4. Locate and select the "Uncommit Withdrawal" button associated with that position.
{% hint style="info" %}
If your position has not been committed for withdrawal, the "Uncommit Withdrawal" action will not be available.
{% endhint %}
### 3. Review and Confirm the Uncommit Action
Before executing the uncommit transaction, carefully review all the information provided about the action you are about to undertake.
1. Read through the details provided, which may include:
* Any implications on rewards or position status after uncommitting
* Any fees associated with the uncommit action
2. If you agree with the terms and want to proceed, press the "Confirm" button to execute the uncommit transaction.
### 4. Wait for Transaction Validation
The uncommit transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
3. Do not close the browser or disconnect your wallet during this process.
### 5. Verify Updated Position Status
Once the transaction is validated, your position should reflect the change in status.
1. Check your dashboard to see the updated position details, including:
* The removal of any withdrawal countdown timers
* The restoration of your ability to add liquidity or take interests
2. Confirm that your full liquidity amount is once again active in the position.
3. If the changes don't appear immediately, try refreshing the page.
## Important Considerations
* Uncommitting a withdrawal may have implications on your rewards. You do not accrue reward during the commit period, so be sure to understand how committing & uncommitting affects your earnings.
By following these steps, you've successfully uncommitted a withdrawal from your liquidity position. Your liquidity will remain in the position, continuing to earn rewards according to the protocol's rules. Remember to regularly assess your investment strategy and make decisions that align with your financial objectives and risk tolerance.
# Liquidity - Take Interests
## How to Take Interests from Your Liquidity Position
This guide will walk you through the process of withdrawing cover and strategy rewards from your liquidity position. Taking interests allows you to realize the gains from your investment while keeping your principal invested.
{% hint style="info" %}
Some strategies might not allow taking interests from strategy rewards, in which case you will only receive the cover rewards.
{% endhint %}
## Steps to Take Interests
### 1. Access Your Dashboard
First, ensure you're connected to the DApp and can view your existing liquidity positions.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. Navigate to the Dashboard page to view your liquidity positions.
### 2. Select the Position to Take Interests From
Choose the liquidity position from which you want to withdraw rewards.
1. Review your active liquidity positions in the dashboard.
2. Click on the specific position you want to take interests from.
3. Locate and select the "Take Interests" button associated with that position.
{% hint style="info" %}
If your position has been committed for withdrawal, the "Take Interests" action will not be available. You'll need to wait for the withdrawal process to complete or cancel it before taking interests.
{% endhint %}
### 3. Review and Confirm the Take Interests Action
Before executing the transaction, carefully review all the information provided about the interests-taking action.
1. Read through the details provided, which may include:
* The amount of cover rewards available
* Any strategy rewards available (if applicable)
* Any fees or taxes that may be deducted
* The impact on your position after taking interests
2. If you agree with the terms and want to proceed, press the "Confirm" button to execute the take interests transaction.
### 4. Wait for Transaction Validation
The take interests transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
3. Do not close the browser or disconnect your wallet during this process.
### 5. Verify Received Rewards and Updated Position
Once the transaction is validated, you should see the rewards in your wallet and the changes reflected in your dashboard.
1. Check your wallet balance to confirm the received rewards.
2. Review your dashboard to see the updated position details.
3. If the changes don't appear immediately, try refreshing the page.
## Important Considerations
* Frequent interests-taking might impact your overall returns due to transaction fees.
* If you're only receiving cover rewards and not strategy rewards, make sure you understand why this is the case for your chosen strategy.
By following these steps, you've successfully taken interests from your liquidity position. Remember to regularly assess your investment strategy and take interests in line with your financial goals and market conditions.
# Claim - Create
## How to Create a Claim for Compensation
This guide will walk you through the process of seeking compensation after an incident for which you have cover. Creating a claim is a crucial step in utilizing your DeFi insurance coverage.
## Steps to Create a Claim
### 1. Access the Claim Page
First, ensure you're connected to the DApp and navigate to the claim creation area.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. Navigate to the Claim page to start the claim process.
### 2. Select the Relevant Cover
Choose the specific cover for which you are creating a claim.
1. Review the list of covers associated with your account.
2. Select the cover that corresponds to the incident for which you're seeking compensation.
3. Ensure that the selected cover is valid and was active at the time of the incident.
### 3. Specify the Claim Amount
Determine and enter the amount for which you wish to file a claim.
1. Review the terms of your cover to understand the maximum claimable amount.
2. Enter the amount you wish to claim, ensuring it doesn't exceed your cover limit.
3. Double-check the entered amount for accuracy.
### 4. Review and Submit the Claim
Before creating the claim, ensure you have the necessary funds for fees and collateral.
1. Check that you have enough ETH (or the chain's equivalent) for:
* The arbitration fee
* The claim collateral
2. Understand that these amounts will be returned unless your claim is challenged and proven fraudulent.
3. Review all claim details one last time.
4. When ready, click the "Open Claim" button to submit your claim.
{% hint style="info" %}
These deposits ensure that claimants do not spam the arbitration system and are acting in good faith.
{% endhint %}
### 5. Wait for Transaction Validation
The claim creation transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 6. Consider Adding Evidence (Optional)
While most claims don't require additional evidence, you may choose to reinforce your case.
1. Evaluate whether additional evidence would strengthen your claim.
2. If needed, click the "Add evidence to my claim" button.
3. Follow the Add Evidence guide for detailed instructions on submitting evidence.
{% hint style="warning" %}
You can add evidence at any point as long as your claim has not been challenged. If challenged, you'll have a 48-hour window to add additional evidence before juror review.
{% endhint %}
### 7. Monitor Your Claim Status
Keep track of your claim's progress through your dashboard.
1. Locate your newly created claim in your dashboard.
2. Monitor the "Status" tab of your claim regularly.
3. Be prepared to respond if your claim is challenged.
4. Once the challenge period has elapsed, your claim should be automatically validated and made available for withdrawal.
## Important Considerations
* Accuracy is crucial when filing a claim. Ensure all information provided is truthful and verifiable.
* Be aware of the timeline for claim processing and potential challenges.
* Familiarize yourself with the protocol's dispute resolution process in case your claim is challenged.
* Keep all relevant documentation and evidence related to your claim, even if not initially submitted.
* Understand the potential outcomes of the claim process, including payout deductibles or claim rejections.
* Be prepared for the possibility of a longer resolution process if your claim is challenged or complex.
By following these steps, you've successfully created a claim for compensation. Remember to stay engaged with the process, respond promptly to any requests for additional information, and be patient as your claim is processed. If you have any doubts or questions during the process, don't hesitate to seek clarification from the protocol's support channels or community forums.
# Claim - Add Evidence
## How to Add Evidence to a Claim or Prosecution
This guide will walk you through the process of adding evidence to support your claim or prosecution case. Proper evidence submission is crucial for a fair evaluation of your case.
## Important Reminders
* As a claimant, you may add evidence at any point as long as the claim is not challenged.
* If the claim is challenged, both the claimant and prosecutor have 48 hours to upload and register evidence before the case is forwarded to the court for evaluation by jurors.
* Only registered evidence will be taken into account in a case's evaluation.
## Steps to Add Evidence
### 1. Access the Appropriate Page
First, ensure you're connected to the DApp and navigate to the correct page for your situation.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. If you're adding evidence to your claim, go to the Dashboard page.
4. If you're adding evidence to a claim you're prosecuting, go to the Court page.
### 2. Locate the Relevant Claim
Find the specific claim for which you want to add evidence.
1. Browse through the list of claims on your chosen page.
2. Once you've found the relevant claim, click the "View claim details" button.
### 3. Navigate to the Evidence Tab
Access the area where you can view existing evidence and add new evidence.
1. On the claim details page, locate and click on the "Evidence" tab.
2. Review any existing evidence that has been registered on-chain.
3. Note that only registered evidence will be used to evaluate the claim or its prosecution.
### 4. Upload Your Evidence
Prepare and upload the files you want to submit as evidence.
1. Scroll down to the "Upload Evidence" section.
2. Either drag and drop your files into the designated drop zone, or click the zone to select files from your device.
3. Ensure your files are uploaded successfully to the IPFS servers.
{% hint style="warning" %}
The evidence you upload is public. Be sure to remove any personal information from the documents if necessary.
{% endhint %}
### 5. Review and Select Evidence for Registration
After uploading, review your evidence and prepare it for on-chain registration.
1. Once your files have been uploaded to IPFS, they will be available for selection.
2. Click on the evidence name to view the document and ensure it's properly saved on IPFS.
3. Select the evidence you want to register on-chain.
4. Remember, if your evidence is not registered within 24 hours, it will be erased from the IPFS server.
5. You can register multiple documents at the same time.
### 6. Register Your Evidence
Finalize the evidence submission by registering it on-chain.
1. Double-check all selected evidence for accuracy and relevance.
2. When you're ready to link the evidence to the claim, click the "Register Evidence" button.
### 7. Wait for Transaction Validation
The evidence registration transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
### 8. Verify Registered Evidence
Once the transaction is validated, confirm that your evidence has been successfully registered.
{% hint style="warning" %}
Evidence may take up to 20min before being displayed post registration.
{% endhint %}
1. The registered evidence should now appear in the appropriate case exhibits table.
2. If the table doesn't update automatically, refresh the page.
3. Review the registered evidence to ensure all intended documents are listed and accessible.
## Important Considerations
* Quality over quantity: Submit evidence that directly supports your claim or prosecution, rather than overwhelming the system with irrelevant information. Evidence spamming may negatively impact your case.
* Timeliness: Be aware of the 48-hour window for evidence submission in challenged cases. Plan accordingly to ensure all your evidence is uploaded and registered within this timeframe.
* Privacy: Remember that all submitted evidence becomes public. Redact or remove any sensitive personal information before uploading.
* File formats: Ensure your evidence is in a commonly accessible format to facilitate easy review by jurors.
* Document integrity: Once uploaded and registered, evidence cannot be altered. Double-check all documents before registration.
* Relevance: Each piece of evidence should be directly related to the claim or prosecution. Irrelevant evidence may weaken your case.
* Clarity: If necessary, provide clear explanations or annotations with your evidence to help jurors understand its significance.
* Backup: Keep copies of all submitted evidence for your own records.
By following these steps, you've successfully added evidence to support your claim or prosecution case. Remember that the quality and relevance of your evidence can significantly impact the outcome of your case. If you have any doubts about the evidence submission process, consult the protocol's guidelines or seek advice from the community or legal professionals.
# Claim - Prosecute
## How to Prosecute a Claim
This guide will walk you through the process of prosecuting a claim that you believe to be fraudulent or invalid. Prosecution is a crucial part of maintaining the integrity of the insurance system.
## Steps to Prosecute a Claim
### 1. Access the Court Page
First, ensure you're connected to the DApp and navigate to the area where ongoing claims are listed.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. Navigate to the Court page to view the list of ongoing claims.
### 2. Locate the Claim to Prosecute
Identify the specific claim you wish to challenge.
1. Browse through the list of ongoing claims.
2. You can prosecute directly from this list by pressing the "Prosecute" button if available.
3. For a more detailed view, click the "View claim details" button to access the claim's detail page.
{% hint style="info" %}
We strongly advise against prosecuting a claim without carefully examining the evidence, as this action cannot be cancelled.
{% endhint %}
### 3. Review Claim Details and Navigate to Prosecution Tab
Before initiating the prosecution, thoroughly review all available information about the claim.
1. On the claim details page, carefully examine all provided evidence and claim information.
2. Navigate to the "Prosecute" tab within the claim details page.
### 4. Prepare for Prosecution
Before prosecuting the claim, ensure you're fully prepared both financially and evidentially.
1. Check that you have enough ETH (or the chain's equivalent) to deposit the arbitration fee.
* This amount will be returned unless your prosecution is lost and proven to be unfounded.
2. Prepare all counter-evidence you plan to use to disprove the claim.
* Remember, there will be a 48-hour window for evidence to be uploaded and registered once the prosecution begins.
3. Carefully consider your decision to prosecute, as it cannot be undone.
4. When you're fully prepared and confident in your decision, click the "Challenge" button.
{% hint style="info" %}
The arbitration fee deposit ensures that prosecutions are not spammed and are made in good faith.
{% endhint %}
### 5. Confirm Prosecution
Review all details one last time before executing the prosecution transaction.
1. Carefully read all the information about the action you are about to undertake.
2. Ensure you understand the potential outcomes and responsibilities of prosecution.
3. If you agree with all terms and are ready to proceed, press "Confirm" to execute the prosecution transaction.
### 6. Wait for Transaction Validation
The prosecution transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
3. Do not close the browser or disconnect your wallet during this process.
### 7. Add Counter-Evidence
Once the prosecution is initiated, you should submit your counter-evidence promptly.
1. Click the "Add evidence to my prosecution" button.
2. Follow the Add Evidence guide for detailed instructions on submitting evidence.
3. Remember, you have a 48-hour window to upload and register all your evidence.
## Important Considerations
* Prosecution is a serious action. Only proceed if you have strong evidence that the claim is fraudulent or invalid.
* Be prepared to present a compelling case with solid evidence. The burden of proof is on you as the prosecutor.
* Understand the timeline for the prosecution process, including evidence submission deadlines and potential juror review periods.
* Be aware that if your prosecution is found to be unfounded, you may lose your arbitration fee deposit.
* Familiarize yourself with the protocol's dispute resolution process and potential outcomes.
* Consider seeking advice if you're unsure about any aspect of the prosecution process.
* Remember that your actions impact the overall integrity and efficiency of the insurance system. Act responsibly and in good faith.
By following these steps, you've initiated the prosecution of a claim you believe to be fraudulent or invalid. Remember to stay engaged with the process, submit your evidence promptly, and be prepared for potential further steps in the dispute resolution process. If you have any doubts or questions during the process, don't hesitate to seek clarification from the protocol's support channels.
# Claim - Payout
## How to Payout or Withdraw an Accepted Claim
This guide will walk you through the process of releasing payment for a claim that has been accepted, whether you're the claimant withdrawing your own payout or a third party triggering payment for someone else's claim.
## Steps to Payout or Withdraw a Claim
### 1. Access the Appropriate Page
First, ensure you're connected to the DApp and navigate to the correct page for your situation.
1. Connect your wallet to the DApp.
2. Confirm you're on the appropriate network (e.g., Ethereum mainnet, Polygon, etc.).
3. If you're withdrawing a payout from your own claim, go to the Dashboard page.
4. If you're triggering a payment for someone else's claim, go to the Court page.
### 2. Locate the Relevant Claim
Find the specific claim for which you want to trigger the payout or withdrawal.
1. Browse through the list of claims on your chosen page.
2. If the claim has been accepted, you may see a "Withdraw" or "Pay" button directly next to it.
3. For a more detailed process, click the "View claim details" button to access the claim's detail page.
### 3. Navigate to the Payment Tab
Access the area where you can initiate the payout process.
1. On the claim details page, locate and click on the "Payment" tab.
2. Review any relevant information about the claim and its accepted status.
### 4. Initiate the Payout Process
Begin the process of releasing the payment for the accepted claim.
1. Locate the "Pay Claim" button within the Payment tab.
2. Click the "Pay Claim" button to start the payout process.
### 5. Review and Confirm the Payment
Carefully review all details before finalizing the payment transaction.
1. Read all the information provided about the action you are about to undertake. This may include:
* The total amount to be paid out
* Any deductibles or fees that will be subtracted
* The final amount the claimant will receive
2. Ensure you understand and agree with all terms of the payout.
3. If everything is correct and you're ready to proceed, press "Confirm" to execute the payment transaction.
### 6. Wait for Transaction Validation
The payment transaction will now be processed on the blockchain.
1. Keep your wallet open and connected.
2. Wait for the transaction to be confirmed (this may take a few minutes depending on network congestion).
3. Do not close the browser or disconnect your wallet during this process.
### 7. Verify Successful Payment
Once the transaction is validated, confirm that the payment has been successfully processed.
1. The claim status should update to reflect that payment has been made.
2. The claimant should now have received the claimed amount, minus any deductibles and other due amounts.
3. If you're the claimant, check your wallet to confirm receipt of the funds.
## Important Considerations
* Deductibles and Fees: Understand that the final payout amount may be less than the original claim amount due to deductibles, fees, or other contractual terms.
By following these steps, you've successfully initiated or received the payout for an accepted claim. This process ensures that valid claims are compensated efficiently, maintaining the integrity and effectiveness of the insurance system. If you encounter any issues during the payout process, don't hesitate to seek assistance from the protocol's support channels or community resources.
# Markets Overview
On every chain, Athena enables a set of markets that are available for users to interact with. Each market is the combination of a cover pool, the protected protocol or asset and a liquidity strategy, the protocol where the liquidity for covers is invested. Markets on different chains are expected to offer different covers & strategies, depending on their ecosystem.
The following section defines what cover pools and liquidity strategies are available on each chain where Athena is deployed.
***
##  Arbitrum One
You can browse Arbitrum One's cover pools, liquidity strategies & active courts here:
{% content-ref url="/pages/MAnJjPLcYNfMUaUyKhJC" %}
[Arbitrum](/markets/arbitrum-market)
{% endcontent-ref %}
***
##  Ethereum Mainnet
You can browse Ethereum's cover pools, liquidity strategies & active courts here:
{% content-ref url="/pages/9JfgLs4FmkYaCoMhoVTo" %}
[Ethereum](/markets/ethereum-market)
{% endcontent-ref %}
# Arbitrum
This page provides an overview of the market parameters for the Arbitrum blockchain ecosystem, including cover markets, liquidity strategies, and courts.
## Cover Markets
| Pool ID | Cover | Strategy | Court | Cover Type | Action |
| ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | ---------- | --------------------------------------------------- |
| 0 |  Eigen |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/0) |
| 1 |  Pendle |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/1) |
| 2 |  Renzo |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/2) |
| 3 |  Ether.fi |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/3) |
| 4 |  Amphor |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/4) |
| 5 |  Kelp DAO |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/5) |
| 6 |  Puffer Finance |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/6) |
| 7 |  Karak |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/7) |
| 8 |  Zircuit |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/8) |
| 9 |  Mellow |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/9) |
| 10 |  Symbiotic |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/10) |
| 11 |  Eigen + Pendle + Ether.fi + Zircuit |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/11) |
| 12 |  Eigen + Pendle + Ether.fi + Karak |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/12) |
| 13 |  Eigen + Pendle + Kelp DAO + Zircuit |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/13) |
| 14 |  Eigen + Pendle + Renzo + Zircuit |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/14) |
| 15 |  Ethena USDe |  AAVE v3 - USDC | Athena v0 | Depeg | [View Pool](https://app.athenains.io/42161/pool/15) |
| 16 |  Liquity LUSD |  AAVE v3 - USDC | Athena v0 | Depeg | [View Pool](https://app.athenains.io/42161/pool/16) |
| 17 |  crvUSD |  AAVE v3 - USDC | Athena v0 | Depeg | [View Pool](https://app.athenains.io/42161/pool/17) |
| 18 |  USDT |  AAVE v3 - USDC | Athena v0 | Depeg | [View Pool](https://app.athenains.io/42161/pool/18) |
| 19 |  Angle USDa |  AAVE v3 - USDC | Athena v0 | Depeg | [View Pool](https://app.athenains.io/42161/pool/19) |
| 20 |  Curve |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/20) |
| 21 |  Compound |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/21) |
| 22 |  Balancer |  AAVE v3 - USDC | Athena v0 | Exploit | [View Pool](https://app.athenains.io/42161/pool/22) |
## Liquidity Strategies
| Strategy | Category | Action |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
|  AAVE v3 - USDC | Lending | [View Strategy](https://app.aave.com/reserve-overview/?underlyingAsset=0xaf88d065e77c8cc2239327c5edb3a432268e5831\&marketName=proto_arbitrum_v3) |
## Courts
| Court |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|  Athena v0 |
|  Kleros (soon) |
# Ethereum
This page provides an overview of the market parameters for the Ethereum blockchain ecosystem, including cover markets, liquidity strategies, and courts.
## Cover Markets
| Pool ID | Cover | Strategy | Court | Cover Type | Action |
| ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | ---------- | ---------------------------------------------- |
| 0 |  amphrETH |  Amphor Restaked ETH | Athena v0 | Exploit | [View Pool](https://app.athenains.io/1/pool/0) |
| 1 |  amphrLRT |  Amphor Symbiotic LRT Vault | Athena v0 | Exploit | [View Pool](https://app.athenains.io/1/pool/1) |
## Liquidity Strategies
| Strategy | Category | Action |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | --------------------------------------- |
|  Amphor Restaked ETH | Restaking | [View Strategy](https://app.amphor.io/) |
|  Amphor Symbiotic LRT Vault | Restaking | [View Strategy](https://app.amphor.io/) |
## Courts
| Court |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
|  Athena v0 |
|  Kleros (soon) |
# Tokenomics
The ATEN token is the native ERC-20 cryptocurrency of the Athena Insurance platform. Key details include:
Name: Athena Token Symbol: ATEN Decimals: 18 Supply Type: Fixed Total Supply: 3,000,000,000 ATEN Current Network Deployment: Arbitrum
## Governance and Staking
ATEN serves as the governance token for the Athena ecosystem. Token holders can:
* Stake their ATEN tokens with the DAO (Decentralized Autonomous Organization)
* Participate in revenue sharing based on their staked amount
* Vote on important protocol decisions, influencing the future direction of Athena
* Hedge DeFi turbulence through the buybacks funded by claim deductibles
By staking ATEN, users actively contribute to the platform's governance and can benefit from its success through revenue sharing. This model aligns the interests of token holders with the long-term growth and sustainability of the Athena Insurance protocol.
## Token Burn
Holders of ATEN tokens benefit from a unique value-creation mechanism during periods of high claim activity. When cover claims are processed, a deductible is applied and used to buy back and burn ATEN tokens.
This process effectively increases demand for ATEN during challenging times in the DeFi space, such as during protocol exploits or asset depegs. As a result, simply holding ATEN can serve as a hedge against DeFi market turbulence, potentially preserving or increasing value for token holders when other DeFi assets may be struggling. This aligns the interests of ATEN holders with the overall health and resilience of the DeFi ecosystem.
## Token Allocations
| Name | Percentage | Token Amount | Status | Description | Vesting |
| ---------------------------------- | ---------- | ------------- | ------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------- |
| Presale | 5% | 150,000,000 | Completed | Platform building and audit completion capital | 5% at TGE, 12-month vesting after 2-month cliff |
| Strategic Partners / Strategic VCs | 5% | 150,000,000 | Ongoing discussions | Reserved for partners providing initial liquidity during first 6 months | 5% at TGE, No cliff, linear vesting over 18 months |
| LBP or Launchpool | 10% | 300,000,000 | Planned | For raising additional capital through public token sale | 20% at TGE, No cliff, linear vesting overr 3 months |
| Team | 12% | 360,000,000 | 8% allocated, 4% reserved | Designated for core team members who built Athena Ins | 24-month vesting with 12 months cliff |
| Advisors / KOLs | 3% | 90,000,000 | Ongoing | Reserved for strategic advisors and Key Opinion Leaders | 18-month vesting with no cliff |
| Liquidity Incentives | 42% | 1,260,000,000 | Planned | For incentivizing users through staking and rewards | Distributed over 60-month period |
| Treasury | 13% | 390,000,000 | Reserved | Serves as reserve fund for Athena Ins DAO | 180-months vesting |
| Liquidity | 10% | 300,000,000 | Planned | Set aside to provide liquidity on decentralized exchanges | 36-month vesting, 10% release at TGE |
# Voting
Athena is set to introduce a Decentralized Autonomous Organization (DAO) to foster open governance and community-driven decision-making. This DAO will enable token holders to vote on crucial aspects of the protocol, including covered protocols and assets, liquidity pool strategies, and key protocol configurations and parameters.
The governance mechanism will be based on vATEN holdings, which are obtained by staking ATEN tokens. An on-chain proposal and voting system will ensure transparency and fairness in decision-making. The transition to full decentralization will be gradual, allowing for a smooth shift of power to the community.
This move towards DAO governance brings several benefits. It aligns protocol development with community needs, enhances risk management through collective decision-making, and increases the protocol's resilience and fairness. By empowering users to actively shape the protocol's future, Athena ensures it remains responsive to user needs & expectations.
# Staking
## Staking Mechanism
Athena's staking mechanism allows users to deposit ATEN tokens to earn more ATEN. This feature helps token holders hedge against inflation from liquidity farming campaigns, maintaining their proportional ownership of the protocol.
## DAO Staking and Governance
Users can stake through the DAO, choosing a lock duration for their tokens. Longer locks yield more vATEN tokens, representing both voting power and revenue shares. This system rewards long-term commitment with greater influence and benefits.
## Importance of the Mechanism
This staking model is crucial for Athena's tokenomics and governance. It balances inflationary pressures, encourages active participation, and aligns user interests with the protocol's long-term success. By linking voting power and revenue sharing to locked tokens, Athena fosters a community of engaged stakeholders.
# Coverage Types
Our platform currently offers two types of cover protection for DeFi users:
1. Protocol Exploit Cover
2. Stablecoin Protection Cover
Each cover type is designed to protect users against different risks in the DeFi ecosystem. Below, you'll find an overview of what each cover includes and excludes.
## Protocol Exploit Cover
This cover protects against losses resulting from exploits or failures in DeFi protocols.
### What's Covered
* Exploits or hacks of smart contracts
* Critical oracle failures
* Major liquidation issues
* Governance attacks
### What's Excluded
* Losses from the depegging of any asset
* Losses due to bridge infrastructure
* Losses due to compromised websites with no impact on the protocol
For full details, please refer to the full terms:
{% file src="/files/OfTGJS0fc0hUNM6QgcUh" %}
## Stablecoin Protection Cover
This cover protects against losses resulting from stablecoin depegging events and related issues.
### What's Covered
* Losses from the depegging of the covered asset
* Exploits or hacks of the covered asset smart contracts
* Governance attacks on the covered asset issuer
### What's Excluded
* Exploits or hacks of protocols using the asset
* Critical oracle failures or major liquidation issues
* Losses due to bridge infrastructure
* Losses due to compromised websites with no impact on the protocol
For full details, please refer to the full terms:
{% file src="/files/tvZO0AlbhqC0LjfEQTng" %}
## Additional Coverage Details
Each cover pool may have additional documents that further detail the coverage when necessary or relevant. These documents provide specific information about claim processes, exclusions, and other important details that may affect your coverage.
Always review the full terms and conditions for each cover type before purchasing to ensure you understand the extent of your protection.
If there is pool specific annex, you can find it in the Pool Terms and Conditions section of the cover pool's details page or in the cover purchase modal.
# Liquidity
The liquidity of the Athena protocol is measured by the availability of assets in cover pools for key protocol operations such as providing insurance coverage and paying out claims. It is a critical metric, as insufficient liquidity could impair the protocol's ability to offer adequate coverage or settle valid claims. At any given time, the liquidity of the protocol can be assessed through the utilization ratio (i.e., the share of the pool that is currently committed to active cover policies versus the total assets in each cover pool).
## Dynamic Premium Pricing in Athena
Athena's premium pricing algorithm is calibrated to manage liquidity risk and optimize utilization of cover pools. The cover premiums are derived from the Utilization Rate (U) of each pool.
U is an indicator of the availability of capital within the pool. The premium pricing model manages liquidity risk in the protocol through user incentives to support liquidity:
* When capital is abundant: lower premiums to encourage cover purchases.
* When capital is scarce: higher premiums to encourage additional liquidity provision.
### Premium Pricing Model
Liquidity risk materializes when utilization is high, becoming more problematic as U approaches 100%. To address this constraint, the premium pricing curve is split into two parts around an optimal utilization rate (U\_optimal). Before U\_optimal, the slope is gentle; after it, the slope rises sharply.
The premium rate (P\_r) follows the model:
For U ≤ U\_optimal: $$P\_r = r\_0 + \frac{U}{U\_{optimal}} \cdot r\_{slope1}$$
For U > U\_optimal: $$P\_r = r\_0 + r\_{slope1} + \frac{U - U\_{optimal}}{1 - U\_{optimal}} \cdot r\_{slope2}$$
Where:
* r\_0 is the base premium rate
* r\_slope1 is the premium slope below optimal utilization
* r\_slope2 is the premium slope above optimal utilization
This model ensures:
* When U ≤ uOptimal, premiums increase slowly with utilization
* When U > uOptimal, premiums increase sharply to discourage over-utilization and incentivize liquidity provision
### Model Parameters
The premium pricing model incorporates various factors to ensure accurate risk assessment and fair pricing for DeFi protocol coverage. Protocol risk profile plays a crucial role, with higher-risk protocols typically requiring higher premiums to account for increased potential for exploits or failures.
Market conditions are also factored in, as Athena's premiums must align with current risk perceptions and comparable cover products in the DeFi insurance market. For multi-protocol positions, a leverage factor is applied in the risk fee calculation to account for the increased risk associated with covering multiple protocols simultaneously.
The model is calibrated differently for various types of DeFi protocols. Protection pools for riskier protocols, such as newer or more complex DeFi applications, are set with a low Optimal Utilization Ratio to ensure fairer pricing evolution. Established protocols with strong security track records may have a higher Optimal Utilization Ratio. Well-audited, battle-tested protocols are calibrated to lower rates to encourage coverage purchases while maintaining appropriate risk management.
Ultimately, the premium rate is dynamically determined by the interplay between cover demand from buyers and liquidity supply from providers, reflecting real-time market conditions and risk assessments within the Athena protocol.
### Liquidity Provider Rewards
The premiums paid by cover buyers are distributed as rewards to liquidity providers who have supplied assets to the protocol, excluding a share sent to the protocol treasury defined by the reserve factor.
The Liquidity Provider APY (LP\_Y) is calculated as the sum of the yields from each pool the position provided liquidity to, plus the strategy's base APR:
$$LP\_Y = \sum\_{i=1}^{n} (U\_i \cdot P\_{r\_i}) + S\_y$$
Where:
* n is the number of pools the position provided liquidity to
* U\_i is the utilization ratio of pool i
* P\_r\_i is the premium rate of pool i
* S\_y is the strategy's base yield from the underlying LP tokens
This model ensures that liquidity providers are rewarded both for the risk they're underwriting across multiple pools and for the base yield of their supplied assets. The summation allows for a comprehensive reward calculation that accounts for varying utilization and premium rates across different pools within a single position.
# External Audits
Athena's expansion will lead to increased financial stakes, elevating its appeal as a potential target. Prioritizing security is paramount. While internal best practices and automated testing are in place, the Athena ecosystem also undergoes evaluation by independent specialists to ensure robust protection.
Audit reports available on [GitHub](https://github.com/Athena-ins/athena-contracts).
| Auditor | Athena v0 |
| ----------- | --------- |
| CD Security | X |
# Architecture
This illustration provides a high-level overview of the Athena protocol's core contracts and their interactions.
***
## Core Contracts
### ATEN Token
The ATEN token follows the standard ERC-20 specification with an added `transferAndCall` feature. This enables direct smart contract interactions without relying on the typical `approve`/`transferFrom` mechanism. You can review the details of this function here:
* [transferAndCall()](/smart-contracts/athenapositiontoken#transferandcall)
{% content-ref url="/pages/qzFTvSX1yJmDBaLbxbTS" %}
[ATEN Token](/smart-contracts/athenatoken)
{% endcontent-ref %}
{% hint style="info" %}
If you are looking for information about the tokenomics of the ATEN token, you can find them in the [dedicated page](/protocol-governance/tokenomics).
{% endhint %}
### AthenaPositionToken
The AthenaPositionToken tokens implements most of the ERC-721 (NFT) standard methods with slight modifications, as well as Athena specific methods including:
* [tokensOf()](/smart-contracts/athenapositiontoken#tokensof)
All Liquidity Position Tokens also implement ERC721Enumerable, which adds enumerability of all the token IDs in the contract as well as all token IDs owned by each account.
{% content-ref url="/pages/zCBc5M9T19uw7VjizsDv" %}
[AthenaPositionToken](/smart-contracts/athenapositiontoken)
{% endcontent-ref %}
### AthenaCoverToken
The AthenaCoverToken tokens implements most of the ERC-721 (NFT) standard methods with slight modifications, as well as Athena specific methods including:
* [tokensOf()](/smart-contracts/athenacovertoken#tokensof)
All Cover Tokens also implement ERC721Enumerable, which adds enumerability of all the token IDs in the contract as well as all token IDs owned by each account.
{% content-ref url="/pages/xmfuA4kEmiWQOWO8z0et" %}
[AthenaCoverToken](/smart-contracts/athenacovertoken)
{% endcontent-ref %}
### LiquidityManager
The Liquidity Manager serves as the primary entry point for users interacting with the Athena protocol. It monitors the states of insurance pools, liquidity positions, and covers, facilitating core contract interactions.
Key functions of the Liquidity Manager include:
* [openPosition()](/smart-contracts/liquiditymanager#openposition)
* [addLiquidity()](/smart-contracts/liquiditymanager#addliquidity)
* [takeInterests()](/smart-contracts/liquiditymanager#takeinterests)
* [commitRemoveLiquidity()](/smart-contracts/liquiditymanager#commitremoveliquidity)
* [uncommitRemoveLiquidity()](/smart-contracts/liquiditymanager#uncommitremoveliquidity)
* [removeLiquidity()](/smart-contracts/liquiditymanager#removeliquidity)
* [openCover()](/smart-contracts/liquiditymanager#opencover)
* [updateCover()](/smart-contracts/liquiditymanager#updatecover)
{% content-ref url="/pages/Y989zT8e4u42m3Kgi1IF" %}
[LiquidityManager](/smart-contracts/liquiditymanager)
{% endcontent-ref %}
### StrategyManager
The Strategy Manager functions as an abstraction layer between the Liquidity Manager and liquidity strategies. It ensures that deposits and withdrawals are processed uniformly across all strategies.
### ClaimManager
The Claim Manager handles all claim-related interactions between users, the Liquidity Manager, and arbitration courts. It monitors the status of claims and manages the cover compensation process.
Key functions of the Liquidity Manager include:
* [submitEvidenceForClaim()](/smart-contracts/claimmanager#submitevidenceforclaim)
* [initiateClaim()](/smart-contracts/claimmanager#initiateclaim)
* [disputeClaim()](/smart-contracts/claimmanager#disputeclaim)
* [withdrawCompensation()](/smart-contracts/claimmanager#withdrawcompensation)
{% content-ref url="/pages/nzBDCPLaCwEDEEBAZuwe" %}
[ClaimManager](/smart-contracts/claimmanager)
{% endcontent-ref %}
***
## External Contracts
The Athena protocol integrates with various external contracts to generate yield for its liquidity providers and facilitate claim dispute resolutions.
For a comprehensive list of these protocols, refer to the Markets section:
{% content-ref url="/pages/jHsBiThU0lmrqRV5fMDw" %}
[Markets Overview](/markets/markets-overview)
{% endcontent-ref %}
### Liquidity Strategies
When users provide liquidity to the Athena protocol, they can allocate their funds across a range of decentralized finance (DeFi) protocols to generate base yield. These protocols, known as strategies, are managed by the `StrategyManager` contract. Strategies may include lending protocols, yield farming, staking, or liquidity vaults.
### Arbitration Courts
If a claim is contested by a prosecutor, it is escalated to an on-chain court for arbitration. Standard Athena liquidity pools utilize the decentralized Kleros court system to ensure impartial rulings. Certain specialized insurance pools may have their own dedicated courts. To determine which court is assigned to a specific pool, you can review the pool’s jurisdiction on its details page.
{% hint style="info" %}
All courts use the [ERC-792 Arbitration Standard](https://developer.kleros.io/en/latest/) as well as the [ERC-1497 Evidence Standard](https://developer.kleros.io/en/latest/).
{% endhint %}
You can learn more about Kleros and its arbitration system here:
{% embed url="" %}
***
## Libraries
Athena integrates several libraries across the protocol. Below are some of the core libraries in use:
### VirtualPool
Defines an internal interface for managing multiple pools within a single contract. This module is utilized by the `LiquidityManager` to streamline interactions with all pools.
### AthenaDataProvider
Standardizes the protocol's key data structures. It is leveraged by the `LiquidityManager` to retrieve real-time data on pool states, liquidity positions, and active covers.
### PoolMath
Performs essential computations related to pool states based on given parameters. The `LiquidityManager` relies on this module to determine the current conditions of the pools.
### TickBitmap
Maintains a record of cover creation and expiration within the pools. It is employed by the `LiquidityManager` to efficiently track the lifecycle of covers.
A complete list of the libraries used in the Athena protocol can be found on our [Github here](https://github.com/Athena-ins).
# Deployments
The following table provides an overview of Athena's core smart-contracts. Each contract is linked to its corresponding documentation page for more details as well as their respective deployment addresses.
***
## Ethereum Mainnet
* **Chain ID**: 1
* **Native Coin**: ETH (Ethereum)
* **Consensus Mechanism**: Proof-of-Stake
* **Type of Chain**: Layer 1 blockchain
* **Official Explorer**: [Etherscan](https://etherscan.io/)
| Name | Address |
| ------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------- |
| [AthenaPositionToken](/smart-contracts/athenapositiontoken) | [0x0f91759a2a56c50ef45a9ebb6b022f28f1cb4e5a](https://etherscan.io/address/0x0f91759a2a56c50ef45a9ebb6b022f28f1cb4e5a) |
| [AthenaCoverToken](/smart-contracts/athenacovertoken) | [0x69a3d9c2a61157d5796cc83bc8e09b99afa42453](https://etherscan.io/address/0x69a3d9c2a61157d5796cc83bc8e09b99afa42453) |
| [AthenaArbitrator](https://github.com/Athena-ins/athena-gitbook/blob/prod/src/smart-contracts/AthenaArbitrator.md) | [0xf519b11948ffec6c2a2b7a38bc9ff4bd6533bf24](https://etherscan.io/address/0xf519b11948ffec6c2a2b7a38bc9ff4bd6533bf24) |
| [ClaimManager](/smart-contracts/claimmanager) | [0x8a440da566b74c811e6ad1df6d36f888db451a31](https://etherscan.io/address/0x8a440da566b74c811e6ad1df6d36f888db451a31) |
| [LiquidityManager](/smart-contracts/liquiditymanager) | [0xbc69d8d072fa7f7b2d6a3773f915e497917a22d9](https://etherscan.io/address/0xbc69d8d072fa7f7b2d6a3773f915e497917a22d9) |
| [StrategyManager](https://github.com/Athena-ins/athena-gitbook/blob/prod/src/smart-contracts/StrategyManager.md) | [0x3f80B7b8065E5CA1Cb5dB0B4360f722965e65571](https://etherscan.io/address/0x3f80B7b8065E5CA1Cb5dB0B4360f722965e65571) |
| WrappedTokenGateway | [0x624dc86874d5376dDE0fBBcBee3f3140062840E9](https://etherscan.io/address/0x624dc86874d5376dDE0fBBcBee3f3140062840E9) |
| AthenaDataProvider | [0x6affa1c136dfaa81c980724130056fa8b7b7daf1](https://etherscan.io/address/0x6affa1c136dfaa81c980724130056fa8b7b7daf1) |
| PoolMath | [0x1c98f659c0f293cdf2d7bc98cac1f11ca4e8fb37](https://etherscan.io/address/0x1c98f659c0f293cdf2d7bc98cac1f11ca4e8fb37) |
| VirtualPool | [0x7c0ca0e6d4ad499706a7433fa4b69bc969294282](https://etherscan.io/address/0x7c0ca0e6d4ad499706a7433fa4b69bc969294282) |
You can browse Ethereum Mainnet's cover pools, liquidity strategies & active courts here:
{% content-ref url="/pages/9JfgLs4FmkYaCoMhoVTo" %}
[Ethereum](/markets/ethereum-market)
{% endcontent-ref %}
***
## Arbitrum One
* **Chain ID**: 42161
* **Native Coin**: ETH (Ethereum)
* **Consensus Mechanism**: Optimistic Rollup
* **Type of Chain**: Layer 2 scaling solution for Ethereum
* **Official Explorer**: [Arbiscan](https://arbiscan.io/)
* **Offical Bridge**: [Arbitrum Bridge](https://bridge.arbitrum.io/)
| Name | Address |
| ------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- |
| [AthenaPositionToken](/smart-contracts/athenapositiontoken) | [0x0f91759a2a56c50ef45a9ebb6b022f28f1cb4e5a](https://arbiscan.io/address/0x0f91759a2a56c50ef45a9ebb6b022f28f1cb4e5a) |
| [AthenaCoverToken](/smart-contracts/athenacovertoken) | [0x69a3d9c2a61157d5796cc83bc8e09b99afa42453](https://arbiscan.io/address/0x69a3d9c2a61157d5796cc83bc8e09b99afa42453) |
| [LiquidityManager](/smart-contracts/liquiditymanager) | [0xdfd097cd3fe208fcbbee09b4bef79442f5693071](https://arbiscan.io/address/0xdfd097cd3fe208fcbbee09b4bef79442f5693071) |
| [StrategyManager](https://github.com/Athena-ins/athena-gitbook/blob/prod/src/smart-contracts/StrategyManager.md) | [0x8a440da566b74c811e6ad1df6d36f888db451a31](https://arbiscan.io/address/0x8a440da566b74c811e6ad1df6d36f888db451a31) |
| [ClaimManager](/smart-contracts/claimmanager) | [0x0adca246213398db35bcdd5676784dc9f5662f54](https://arbiscan.io/address/0x0adca246213398db35bcdd5676784dc9f5662f54) |
| [AthenaArbitrator](https://github.com/Athena-ins/athena-gitbook/blob/prod/src/smart-contracts/AthenaArbitrator.md) | [0xe239082dd5a34354764dcd5e927045ba52f46f1e](https://arbiscan.io/address/0xe239082dd5a34354764dcd5e927045ba52f46f1e) |
| AthenaDataProvider | [0x6affa1c136dfaa81c980724130056fa8b7b7daf1](https://arbiscan.io/address/0x6affa1c136dfaa81c980724130056fa8b7b7daf1) |
| PoolMath | [0x1c98f659c0f293cdf2d7bc98cac1f11ca4e8fb37](https://arbiscan.io/address/0x1c98f659c0f293cdf2d7bc98cac1f11ca4e8fb37) |
| VirtualPool | [0x7c0ca0e6d4ad499706a7433fa4b69bc969294282](https://arbiscan.io/address/0x7c0ca0e6d4ad499706a7433fa4b69bc969294282) |
You can browse Arbitrum One's cover pools, liquidity strategies & active courts here:
{% content-ref url="/pages/MAnJjPLcYNfMUaUyKhJC" %}
[Arbitrum](/markets/arbitrum-market)
{% endcontent-ref %}
# ATEN Token
The ATEN token contract follows the standard ERC-20 specification, including the use of 18 decimal places. The contract also includes an additional `transferAndCall` feature, which allows direct smart contract interactions without relying on the typical `approve`/`transferFrom` mechanism.
## TransferAndCall
Besides the standard ERC20 token features (transfer(), balanceOf(), allowance(), etc), the following `transferAndCall` feature is also available:
```solidity
function transferAndCall(
address to,
uint256 amount,
bytes calldata data
) public returns (bool)
```
Send tokens to a contract address along with call data
Parameters:
| Name | Type | Description |
| ------ | ------- | ----------------------------------------------------------- |
| to | address | destination address for the transfer |
| amount | uint256 | amount to be sent |
| data | bytes | supplementary data to be provided to the receiving contract |
The receiving contract must implement the `ITokenCallReceiver` interface in order to receive the tokens and execute the desired call.
```solidity
interface ITokenCallReceiver {
function onTokenTransfer(
address from,
uint256 amount,
bytes calldata data
) external returns (bool);
}
```
### Example
The following example demonstrates how to use the `transferAndCall` function to send tokens to a contract and execute a specific function:
```ts
import { ethers } from 'ethers';
// Placeholder values
const providerUrl = 'YOUR_RPC_PROVIDER_URL';
const privateKey = 'YOUR_PRIVATE_KEY';
const contractAddress = '0xYourContractAddress';
const recipientAddress = '0xRecipientAddress';
const transferAmount = ethers.BigNumber.from('1000000000000000000'); // 1 ETH
const stakeAmount = ethers.BigNumber.from('500000000000000000'); // 0.5 ETH
// Setup provider and wallet
const provider = new ethers.providers.JsonRpcProvider(providerUrl);
const wallet = new ethers.Wallet(privateKey, provider);
// ABI definitions
const transferAndCallAbi = [
"function transferAndCall(address to, uint256 amount, bytes calldata data) public returns (bool)"
];
const stakeAbi = [
"function stake(uint256 amount) public"
];
// Encode stake data
const stakeInterface = new ethers.utils.Interface(stakeAbi);
const stakeData = stakeInterface.encodeFunctionData('stake', [stakeAmount]);
// Encode transferAndCall data
const transferAndCallInterface = new ethers.utils.Interface(transferAndCallAbi);
const calldata = transferAndCallInterface.encodeFunctionData('transferAndCall', [recipientAddress, transferAmount, stakeData]);
// Create contract instance
const contract = new ethers.Contract(contractAddress, transferAndCallAbi, wallet);
async function sendTransaction() {
try {
const tx = await contract.transferAndCall(recipientAddress, transferAmount, stakeData);
const receipt = await tx.wait();
console.log("Transaction confirmed");
} catch (error) {
console.error('Transaction failed:', error);
}
}
// Send the transaction
sendTransaction();
```
On the receiving contract side, the `onTokenTransfer` function should be implemented to handle the incoming tokens and execute the desired logic:
```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;
interface ITokenCallReceiver {
function onTokenTransfer(
address from,
uint256 amount,
bytes calldata data
) external returns (bool);
}
contract TokenReceiver is ITokenCallReceiver {
// Define function selectors as constants
bytes4 private constant STAKE_SELECTOR = bytes4(keccak256("stake(uint256)"));
// Implement the onTokenTransfer function
function onTokenTransfer(
address from,
uint256 amount,
bytes calldata data
) external override returns (bool) {
// Extract the function selector
bytes4 selector;
assembly {
selector := calldataload(data.offset)
}
// Decode the function call data based on the selector
if (selector == STAKE_SELECTOR) {
// Extract the parameters for the stake function
(uint256 stakeAmount) = abi.decode(data[4:], (uint256)); // Skip the 4-byte function selector
// Handle the stake function logic
stake(stakeAmount);
} else {
revert("Unsupported function selector");
}
// Return success
return true;
}
// Example stake function that could be called
function stake(uint256 amount) public {
// Handle the staking logic here
}
}
```
# AthenaCoverToken
The AthenaCoverToken contract is a slightly modified ERC-721 token representing a cover in the Athena protocol. The contract includes the ERC721Enumerable extension, which adds enumerability of all the token IDs in the contract as well as all token IDs owned by each account. An additional Athena-specific method, [tokensOf()](#tokensof), is also included to easily retrieve all the token IDs owned by an account.
{% hint style="info" %}
The Athena cover ID is equivalent to the token's ERC-721 token ID.
{% endhint %}
***
## State variables info
### baseDataURI
```solidity
string baseDataURI
```
The base URI for the token metadata. The metadata does NOT include the cover's parameters. To retrieve the cover's parameters, use the LiquidityManager contract's [coverInfo()](/smart-contracts/liquiditymanager#coverinfo) function.
### nextCoverId
```solidity
uint256 nextCoverId
```
The ID of the next cover to be minted.
***
## Read Functions info
### name
```solidity
function name() external view returns (string memory)
```
Returns the token collection name.
### symbol
```solidity
function symbol() external view returns (string memory)
```
Returns the token collection symbol.
### tokenURI
```solidity
function tokenURI(uint256 tokenId) external view returns (string memory)
```
Returns the Uniform Resource Identifier (URI) for `tokenId` token.
### balanceOf
```solidity
function balanceOf(address owner) external view returns (uint256 balance)
```
Returns the number of tokens in `owner`'s account.
### ownerOf
```solidity
function ownerOf(uint256 tokenId) external view returns (address owner)
```
Returns the owner of the `tokenId` token.
Requirements:
* `tokenId` must exist.
### getApproved
```solidity
function getApproved(uint256 tokenId) external view returns (address operator)
```
Returns the account approved for `tokenId` token.
Requirements:
* `tokenId` must exist.
### isApprovedForAll
```solidity
function isApprovedForAll(
address owner,
address operator
) external view returns (bool)
```
Returns if the `operator` is allowed to manage all of the assets of `owner`.
See {setApprovalForAll}
### totalSupply
```solidity
function totalSupply() external view returns (uint256)
```
Returns the total amount of tokens stored by the contract.
### tokenOfOwnerByIndex
```solidity
function tokenOfOwnerByIndex(
address owner,
uint256 index
) external view returns (uint256)
```
Returns a token ID owned by `owner` at a given `index` of its token list. Use along with {balanceOf} to enumerate all of `owner`'s tokens.
### tokenByIndex
```solidity
function tokenByIndex(uint256 index) external view returns (uint256)
```
Returns a token ID at a given `index` of all the tokens stored by the contract. Use along with {totalSupply} to enumerate all tokens.
### tokensOf
```solidity
function tokensOf(
address account_
) external view returns (uint256[] memory tokens)
```
Returns the token IDs owned by an account
Parameters:
| Name | Type | Description |
| --------- | ------- | -------------------- |
| account\_ | address | The account to query |
Return values:
| Name | Type | Description |
| ------ | ---------- | ---------------------------------- |
| tokens | uint256\[] | The token IDs owned by the account |
***
## Write Functions info
### safeTransferFrom
```solidity
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external
```
Safely transfers `tokenId` token from `from` to `to`.
Requirements:
* `from` cannot be the zero address.
* `to` cannot be the zero address.
* `tokenId` token must exist and be owned by `from`.
* If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
Emits a {Transfer} event.
### transferFrom
```solidity
function transferFrom(address from, address to, uint256 tokenId) external
```
Transfers `tokenId` token from `from` to `to`.
WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a re-entrancy vulnerability.
Requirements:
* `from` cannot be the zero address.
* `to` cannot be the zero address.
* `tokenId` token must be owned by `from`.
* If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
Emits a {Transfer} event.
### approve
```solidity
function approve(address to, uint256 tokenId) external
```
Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred.
Only a single account can be approved at a time, so approving the zero address clears previous approvals.
Requirements:
* The caller must own the token or be an approved operator.
* `tokenId` must exist.
Emits an {Approval} event.
### setApprovalForAll
```solidity
function setApprovalForAll(address operator, bool approved) external
```
Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
Requirements:
* The `operator` cannot be the address zero.
Emits an {ApprovalForAll} event.
***
## Events info
### Transfer
```solidity
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)
```
Emitted when `tokenId` token is transferred from `from` to `to`.
### Approval
```solidity
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)
```
Emitted when `owner` enables `approved` to manage the `tokenId` token.
### ApprovalForAll
```solidity
event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
```
Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
# AthenaPositionToken
The AthenaPositionToken contract is a slightly modified ERC-721 token representing a liquidity position in the Athena protocol. The contract includes the ERC721Enumerable extension, which adds enumerability of all the token IDs in the contract as well as all token IDs owned by each account. An additional Athena-specific method, [tokensOf()](#tokensof), is also included to easily retrieve all the token IDs owned by an account.
{% hint style="info" %}
The Athena position ID is equivalent to the token's ERC-721 token ID.
{% endhint %}
***
## State variables info
### baseDataURI
```solidity
string baseDataURI
```
The base URI for the token metadata. The metadata does NOT include the position's parameters. To retrieve the position's parameters, use the LiquidityManager contract's [positionInfo()](/smart-contracts/liquiditymanager#positioninfo) function.
### nextPositionId
```solidity
uint256 nextPositionId
```
The ID of the next position to be minted.
***
## Read Functions info
### name
```solidity
function name() external view returns (string memory)
```
Returns the token collection name.
### symbol
```solidity
function symbol() external view returns (string memory)
```
Returns the token collection symbol.
### tokenURI
```solidity
function tokenURI(uint256 tokenId) external view returns (string memory)
```
Returns the Uniform Resource Identifier (URI) for `tokenId` token.
### balanceOf
```solidity
function balanceOf(address owner) external view returns (uint256 balance)
```
Returns the number of tokens in `owner`'s account.
### ownerOf
```solidity
function ownerOf(uint256 tokenId) external view returns (address owner)
```
Returns the owner of the `tokenId` token.
Requirements:
* `tokenId` must exist.
### getApproved
```solidity
function getApproved(uint256 tokenId) external view returns (address operator)
```
Returns the account approved for `tokenId` token.
Requirements:
* `tokenId` must exist.
### isApprovedForAll
```solidity
function isApprovedForAll(
address owner,
address operator
) external view returns (bool)
```
Returns if the `operator` is allowed to manage all of the assets of `owner`.
See {setApprovalForAll}
### totalSupply
```solidity
function totalSupply() external view returns (uint256)
```
Returns the total amount of tokens stored by the contract.
### tokenOfOwnerByIndex
```solidity
function tokenOfOwnerByIndex(
address owner,
uint256 index
) external view returns (uint256)
```
Returns a token ID owned by `owner` at a given `index` of its token list. Use along with {balanceOf} to enumerate all of `owner`'s tokens.
### tokenByIndex
```solidity
function tokenByIndex(uint256 index) external view returns (uint256)
```
Returns a token ID at a given `index` of all the tokens stored by the contract. Use along with {totalSupply} to enumerate all tokens.
### tokensOf
```solidity
function tokensOf(
address account_
) external view returns (uint256[] memory tokens)
```
Returns the token IDs owned by an account
Parameters:
| Name | Type | Description |
| --------- | ------- | -------------------- |
| account\_ | address | The account to query |
Return values:
| Name | Type | Description |
| ------ | ---------- | ---------------------------------- |
| tokens | uint256\[] | The token IDs owned by the account |
***
## Write Functions info
### safeTransferFrom
```solidity
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external
```
Safely transfers `tokenId` token from `from` to `to`.
Requirements:
* `from` cannot be the zero address.
* `to` cannot be the zero address.
* `tokenId` token must exist and be owned by `from`.
* If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
Emits a {Transfer} event.
### transferFrom
```solidity
function transferFrom(address from, address to, uint256 tokenId) external
```
Transfers `tokenId` token from `from` to `to`.
WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must understand this adds an external call which potentially creates a re-entrancy vulnerability.
Requirements:
* `from` cannot be the zero address.
* `to` cannot be the zero address.
* `tokenId` token must be owned by `from`.
* If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
Emits a {Transfer} event.
### approve
```solidity
function approve(address to, uint256 tokenId) external
```
Gives permission to `to` to transfer `tokenId` token to another account. The approval is cleared when the token is transferred.
Only a single account can be approved at a time, so approving the zero address clears previous approvals.
Requirements:
* The caller must own the token or be an approved operator.
* `tokenId` must exist.
Emits an {Approval} event.
### setApprovalForAll
```solidity
function setApprovalForAll(address operator, bool approved) external
```
Approve or remove `operator` as an operator for the caller. Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
Requirements:
* The `operator` cannot be the address zero.
Emits an {ApprovalForAll} event.
***
## Events info
### Transfer
```solidity
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)
```
Emitted when `tokenId` token is transferred from `from` to `to`.
### Approval
```solidity
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)
```
Emitted when `owner` enables `approved` to manage the `tokenId` token.
### ApprovalForAll
```solidity
event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
```
Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
# LiquidityManager
The LiquidityManager contract is the main component of Athena's decentralized cover protocol. It serves as the core liquidity and cover management system, enabling users to provide liquidity, purchase cover, and participate in the protocol's risk-sharing mechanism.
The diamond proxy pattern is used to access its computation and storage manipulation libraries. Its VirtualPool library allows it to manage several liquidity layers within its storage in order to handle cross-pool liquidity distribution.
***
## Structs info
### CoverRead
```solidity
struct CoverRead {
uint256 coverId;
uint64 poolId;
uint256 coverAmount;
bool isActive;
uint256 premiumsLeft;
uint256 dailyCost;
uint256 premiumRate;
uint32 lastTick;
}
```
### PositionRead
```solidity
struct PositionRead {
uint256 positionId;
uint256 supplied;
uint256 suppliedWrapped;
uint256 commitWithdrawalTimestamp;
uint256 strategyRewardIndex;
uint64[] poolIds;
uint256 newUserCapital;
uint256 newUserCapitalWrapped;
uint256[] coverRewards;
uint256 strategyRewards;
}
```
### Position
```solidity
struct Position {
uint256 supplied;
uint256 commitWithdrawalTimestamp;
uint256 strategyRewardIndex;
uint64[] poolIds;
}
```
### PoolOverlap
```solidity
struct PoolOverlap {
uint64 poolId;
uint256 amount;
}
```
### VPoolRead
```solidity
struct VPoolRead {
uint64 poolId;
uint256 feeRate;
uint256 leverageFeePerPool;
IEcclesiaDao dao;
IStrategyManager strategyManager;
PoolMath.Formula formula;
DataTypes.Slot0 slot0;
uint256 strategyId;
uint256 strategyRewardRate;
address paymentAsset;
address underlyingAsset;
address wrappedAsset;
bool isPaused;
uint64[] overlappedPools;
uint256 ongoingClaims;
uint256[] compensationIds;
uint256[] overlappedCapital;
uint256 utilizationRate;
uint256 totalLiquidity;
uint256 availableLiquidity;
uint256 strategyRewardIndex;
uint256 lastOnchainUpdateTimestamp;
uint256 premiumRate;
uint256 liquidityIndexLead;
}
```
***
## State variables info
### positionToken
```solidity
contract IAthenaPositionToken positionToken
```
### coverToken
```solidity
contract IAthenaCoverToken coverToken
```
### ecclesiaDao
```solidity
contract IEcclesiaDao ecclesiaDao
```
### strategyManager
```solidity
contract IStrategyManager strategyManager
```
### claimManager
```solidity
address claimManager
```
### yieldRewarder
```solidity
address yieldRewarder
```
### withdrawDelay
```solidity
uint256 withdrawDelay
```
The delay after commiting before a position can be withdrawn
### maxLeverage
```solidity
uint256 maxLeverage
```
The maximum amount of pools a position can supply liquidity to
### leverageFeePerPool
```solidity
uint256 leverageFeePerPool
```
The fee paid out to the DAO for each leveraged pool in a position
### arePoolCompatible
```solidity
mapping(uint64 => mapping(uint64 => bool)) arePoolCompatible
```
### coverToPool
```solidity
mapping(uint256 => uint64) coverToPool
```
Maps a cover ID to the ID of the pool storing the cover data
### nextCompensationId
```solidity
uint256 nextCompensationId
```
The ID of the next claim to be
### nextPoolId
```solidity
uint64 nextPoolId
```
The token ID position data
***
## Read Functions info
### positions
```solidity
function positions(
uint256 tokenId_
) external view returns (Position memory)
```
### positionInfo
```solidity
function positionInfo(
uint256 positionId_
) external view returns (PositionRead memory)
```
Returns the up to date position data of a token
Parameters:
| Name | Type | Description |
| ------------ | ------- | ---------------------- |
| positionId\_ | uint256 | The ID of the position |
Return values:
| Name | Type | Description |
| ---- | ------------------- | ----------------- |
| -- | struct PositionRead | The position data |
### coverInfo
```solidity
function coverInfo(
uint256 coverId_
) external view returns (CoverRead memory)
```
Returns the up to date cover data of a token
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------------- |
| coverId\_ | uint256 | The ID of the cover |
Return values:
| Name | Type | Description |
| ---- | ---------------- | ------------------------------------ |
| -- | struct CoverRead | The cover data formatted for reading |
### poolInfo
```solidity
function poolInfo(
uint64 poolId_
) external view returns (VPoolRead memory)
```
Returns the virtual pool's storage
Parameters:
| Name | Type | Description |
| -------- | ------ | ------------------ |
| poolId\_ | uint64 | The ID of the pool |
Return values:
| Name | Type | Description |
| ---- | ---------------- | -------------------------- |
| -- | struct VPoolRead | The virtual pool's storage |
### positionInfos
```solidity
function positionInfos(
uint256[] calldata positionIds
) external view returns (PositionRead[] memory)
```
Returns the up to date data of an array of positions
Moved to LiquidityManager since cannot pass array of storage pointers in memory
Parameters:
| Name | Type | Description |
| ----------- | ---------- | ------------------------ |
| positionIds | uint256\[] | The IDs of the positions |
Return values:
| Name | Type | Description |
| ---- | ---------------------- | ------------------ |
| -- | struct PositionRead\[] | The positions data |
### coverInfos
```solidity
function coverInfos(
uint256[] calldata coverIds
) external view returns (CoverRead[] memory)
```
Returns up to date data for an array of covers
Parameters:
| Name | Type | Description |
| -------- | ---------- | --------------------- |
| coverIds | uint256\[] | The IDs of the covers |
Return values:
| Name | Type | Description |
| ---- | ------------------- | ------------------------ |
| -- | struct CoverRead\[] | The array of covers data |
### poolInfos
```solidity
function poolInfos(
uint256[] calldata poolIds
) external view returns (VPoolRead[] memory)
```
Returns up to date data for an array of pools
Parameters:
| Name | Type | Description |
| ------- | ---------- | -------------------- |
| poolIds | uint256\[] | The IDs of the pools |
Return values:
| Name | Type | Description |
| ---- | ------------------- | ----------------------- |
| -- | struct VPoolRead\[] | The array of pools data |
### isCoverActive
```solidity
function isCoverActive(uint256 coverId_) public view returns (bool)
```
Returns if the cover is still active or has expired
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------------- |
| coverId\_ | uint256 | The ID of the cover |
Return values:
| Name | Type | Description |
| ---- | ---- | -------------------------------------------------- |
| -- | bool | True if the cover is still active, otherwise false |
### poolOverlaps
```solidity
function poolOverlaps(
uint64 poolIdA_,
uint64 poolIdB_
) public view returns (uint256)
```
Returns amount liquidity overlap between two pools
The overlap is always stored in the pool with the lowest ID
Parameters:
| Name | Type | Description |
| --------- | ------ | ------------------------- |
| poolIdA\_ | uint64 | The ID of the first pool |
| poolIdB\_ | uint64 | The ID of the second pool |
Return values:
| Name | Type | Description |
| ---- | ------- | ------------------------------- |
| -- | uint256 | The amount of liquidity overlap |
***
## Write Functions info
### openPosition
```solidity
function openPosition(
uint256 amount,
bool isWrapped,
uint64[] calldata poolIds
) external nonReentrant
```
Creates a new LP position
Wrapped tokens are tokens representing a position in a strategy, it allows the user to reinvest DeFi liquidity without having to withdraw
Parameters:
| Name | Type | Description |
| --------- | --------- | ------------------------------------------------------- |
| amount | uint256 | The amount of tokens to supply |
| isWrapped | bool | True if the user can & wants to provide strategy tokens |
| poolIds | uint64\[] | The IDs of the pools to provide liquidity to |
### addLiquidity
```solidity
function addLiquidity(
uint256 positionId_,
uint256 amount,
bool isWrapped
) external onlyPositionOwner(positionId_) nonReentrant
```
Increases the position's provided liquidity
Wrapped tokens are tokens representing a position in a strategy, it allows the user to reinvest DeFi liquidity without having to withdraw
Parameters:
| Name | Type | Description |
| ------------ | ------- | ------------------------------------------------------- |
| positionId\_ | uint256 | The ID of the position |
| amount | uint256 | The amount of tokens to supply |
| isWrapped | bool | True if the user can & wants to provide strategy tokens |
### takeInterests
```solidity
function takeInterests(
uint256 positionId_
) public onlyPositionOwner(positionId_) nonReentrant
```
Takes the interests of a position
Parameters:
| Name | Type | Description |
| ------------ | ------- | ---------------------- |
| positionId\_ | uint256 | The ID of the position |
### commitRemoveLiquidity
```solidity
function commitRemoveLiquidity(
uint256 positionId_
) external onlyPositionOwner(positionId_) nonReentrant
```
Commits to withdraw the position's liquidity
Ongoing claims must be resolved before being able to commit
Parameters:
| Name | Type | Description |
| ------------ | ------- | ---------------------- |
| positionId\_ | uint256 | The ID of the position |
### uncommitRemoveLiquidity
```solidity
function uncommitRemoveLiquidity(
uint256 positionId_
) external onlyPositionOwner(positionId_) nonReentrant
```
Cancels a position's commit to withdraw its liquidity
Parameters:
| Name | Type | Description |
| ------------ | ------- | ---------------------- |
| positionId\_ | uint256 | The ID of the position |
### removeLiquidity
```solidity
function removeLiquidity(
uint256 positionId_,
uint256 amount_,
bool keepWrapped_
) external onlyPositionOwner(positionId_) nonReentrant
```
Closes a position and withdraws its liquidity
The position must be committed and the delay elapsed to withdrawal
Parameters:
| Name | Type | Description |
| ------------- | ------- | -------------------------------------------------- |
| positionId\_ | uint256 | The ID of the position |
| keepWrapped\_ | bool | True if the user wants to keep the strategy tokens |
### openCover
```solidity
function openCover(
uint64 poolId_,
uint256 coverAmount_,
uint256 premiums_
) external nonReentrant
```
Buys a cover
Parameters:
| Name | Type | Description |
| ------------- | ------- | ----------------------------- |
| poolId\_ | uint64 | The ID of the pool |
| coverAmount\_ | uint256 | The amount of cover to buy |
| premiums\_ | uint256 | The amount of premiums to pay |
### updateCover
```solidity
function updateCover(
uint256 coverId_,
uint256 coverToAdd_,
uint256 coverToRemove_,
uint256 premiumsToAdd_,
uint256 premiumsToRemove_
) external onlyCoverOwner(coverId_) nonReentrant
```
Updates or closes a cover
If premiumsToRemove\_ is max uint256 then withdraw premiums & closes the cover
Parameters:
| Name | Type | Description |
| ------------------ | ------- | -------------------------------- |
| coverId\_ | uint256 | The ID of the cover |
| coverToAdd\_ | uint256 | The amount of cover to add |
| coverToRemove\_ | uint256 | The amount of cover to remove |
| premiumsToAdd\_ | uint256 | The amount of premiums to add |
| premiumsToRemove\_ | uint256 | The amount of premiums to remove |
***
## Events info
### PoolCreated
```solidity
event PoolCreated(uint64 indexed poolId)
```
Emitted when a new pool is created
### PositionOpenned
```solidity
event PositionOpenned(uint256 indexed positionId)
```
Emitted when a position is opened
### InterestsTaken
```solidity
event InterestsTaken(uint256 indexed positionId)
```
Emitted when a position's liquidity is updated
### PositionLiquidityUpdated
```solidity
event PositionLiquidityUpdated(uint256 indexed positionId, uint256 amountAdded, uint256 amountRemoved)
```
Emitted when a position's liquidity is updated
### CoverOpenned
```solidity
event CoverOpenned(uint64 indexed poolId, uint256 indexed coverId)
```
Emits when a new cover is bought
### CoverUpdated
```solidity
event CoverUpdated(uint256 indexed coverId)
```
Emits when a cover is updated
### CoverClosed
```solidity
event CoverClosed(uint256 indexed coverId)
```
Emits when a cover is closed
### CompensationPaid
```solidity
event CompensationPaid(uint256 indexed poolId, uint256 indexed compensationId)
```
Compensation is paid out for a claim
# ClaimManager
The ClaimManager contract manages the lifecycle of claims from initiation to resolution. It coordinates interactions between users, the Liquidity Manager, and arbitration courts. This contracts ensures a fair and transparent system for cover holders to submit claims and receive compensation when eligible.
***
## Enums info
### ClaimStatus
```solidity
enum ClaimStatus {
Initiated,
Accepted,
Compensated,
Disputed,
RejectedByOverrule,
RejectedByRefusalToArbitrate,
RejectedByCourtDecision,
AcceptedByCourtDecision,
CompensatedAfterDispute
}
```
### RulingOptions
```solidity
enum RulingOptions {
RefusedToArbitrate,
PayClaimant,
RejectClaim
}
```
The neutral "refuse to arbitrate" option IS ALWAYS 0
***
## Structs info
### ClaimRead
```solidity
struct ClaimRead {
uint256 claimId;
address claimant;
string[] evidence;
string[] counterEvidence;
uint256[] relatedClaimIds;
uint64 poolId;
uint256 coverAmount;
bool isCoverActive;
uint64 createdAt;
uint64 rulingTimestamp;
uint64 challengedTimestamp;
ClaimManager.ClaimStatus status;
uint256 coverId;
uint256 disputeId;
string metaEvidenceURI;
uint256 amount;
address prosecutor;
uint256 deposit;
}
```
### Claim
```solidity
struct Claim {
uint64 createdAt;
uint64 rulingTimestamp;
uint64 challengedTimestamp;
ClaimManager.ClaimStatus status;
uint256 coverId;
uint256 disputeId;
uint256 amount;
address claimant;
address prosecutor;
uint256 deposit;
}
```
***
## State variables info
### baseMetaEvidenceURI
```solidity
string baseMetaEvidenceURI
```
### coverToken
```solidity
contract IAthenaCoverToken coverToken
```
### liquidityManager
```solidity
contract ILiquidityManager liquidityManager
```
### arbitrator
```solidity
contract IArbitrator arbitrator
```
### evidenceGuardian
```solidity
address evidenceGuardian
```
### overruleGuardian
```solidity
address overruleGuardian
```
### nextClaimId
```solidity
uint256 nextClaimId
```
### claims
```solidity
mapping(uint256 => struct ClaimManager.Claim) claims
```
### disputeIdToClaimId
```solidity
mapping(uint256 => uint256) disputeIdToClaimId
```
### claimIdToEvidence
```solidity
mapping(uint256 => string[]) claimIdToEvidence
```
### claimIdToCounterEvidence
```solidity
mapping(uint256 => string[]) claimIdToCounterEvidence
```
### claimCollateral
```solidity
uint256 claimCollateral
```
### klerosExtraData
```solidity
bytes klerosExtraData
```
### challengePeriod
```solidity
uint64 challengePeriod
```
### overrulePeriod
```solidity
uint64 overrulePeriod
```
### evidenceUploadPeriod
```solidity
uint64 evidenceUploadPeriod
```
### numberOfRulingOptions
```solidity
uint64 immutable numberOfRulingOptions = 2
```
### courtClosed
```solidity
bool courtClosed
```
## Modifiers info
### onlyArbitrator
```solidity
modifier onlyArbitrator()
```
Check that the caller is the arbitrator contract
### coverExists
```solidity
modifier coverExists(uint256 coverId_)
```
Check that the cover exists
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------ |
| coverId\_ | uint256 | The cover ID |
### claimsExists
```solidity
modifier claimsExists(uint256 claimId_)
```
Check that the claim exists
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------ |
| claimId\_ | uint256 | The claim ID |
***
## Read Functions info
### arbitrationCost
```solidity
function arbitrationCost() public view returns (uint256)
```
Returns the cost of arbitration for a Kleros dispute.
Return values:
| Name | Type | Description |
| ---- | ------- | -------------------- |
| -- | uint256 | The arbitration cost |
### metaEvidenceURI
```solidity
function metaEvidenceURI(uint256 claimId) public view returns (string memory)
```
Returns the URI of the meta-evidence for a claim
Parameters:
| Name | Type | Description |
| ------- | ------- | ------------ |
| claimId | uint256 | The claim ID |
Return values:
| Name | Type | Description |
| ---- | ------ | ---------------------------- |
| -- | string | The URI of the meta-evidence |
### coverIdToClaimIds
```solidity
function coverIdToClaimIds(
uint256 coverId_
) external view coverExists(coverId_) returns (uint256[] memory)
```
Returns all claim IDs associated with a cover.
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------ |
| coverId\_ | uint256 | The cover ID |
Return values:
| Name | Type | Description |
| ---- | ---------- | ------------------------------------------- |
| -- | uint256\[] | All the claim IDs associated with the cover |
### claimInfo
```solidity
function claimInfo(
uint256 claimId_
) external view returns (ClaimManager.ClaimRead memory)
```
Get a claim by its ID.
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------ |
| claimId\_ | uint256 | The claim ID |
Return values:
| Name | Type | Description |
| ---- | ----------------------------- | ---------------- |
| -- | struct ClaimManager.ClaimRead | The claim's data |
### claimInfos
```solidity
function claimInfos(
uint256[] memory claimIds_
) public view returns (ClaimManager.ClaimRead[] memory result)
```
Returns multiple claims by their IDs.
Parameters:
| Name | Type | Description |
| ---------- | ---------- | ------------- |
| claimIds\_ | uint256\[] | The claim IDs |
Return values:
| Name | Type | Description |
| ------ | -------------------------------- | -------------------- |
| result | struct ClaimManager.ClaimRead\[] | All the claims' data |
### claimsByCoverId
```solidity
function claimsByCoverId(
uint256 coverId_
) public view returns (ClaimManager.ClaimRead[] memory)
```
Returns all the claims associated with a cover.
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------ |
| coverId\_ | uint256 | The cover ID |
Return values:
| Name | Type | Description |
| ---- | -------------------------------- | ---------------------- |
| -- | struct ClaimManager.ClaimRead\[] | All the cover's claims |
### claimsByAccount
```solidity
function claimsByAccount(
address account_
) external view returns (ClaimManager.ClaimRead[] memory result)
```
Returns all the claims of a user.
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------------ |
| account\_ | address | The user's address |
Return values:
| Name | Type | Description |
| ------ | -------------------------------- | --------------------- |
| result | struct ClaimManager.ClaimRead\[] | All the user's claims |
### getClaimEvidence
```solidity
function getClaimEvidence(
uint256 claimId_
) external view claimsExists(claimId_) returns (string[] memory)
```
Returns the evidence submitted by claimant for a claim.
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------ |
| claimId\_ | uint256 | The claim ID |
Return values:
| Name | Type | Description |
| ---- | --------- | ----------------- |
| -- | string\[] | The evidence CIDs |
### getClaimCounterEvidence
```solidity
function getClaimCounterEvidence(
uint256 claimId_
) external view claimsExists(claimId_) returns (string[] memory)
```
Returns the counter-evidence submitted by prosecutor or Athena for a claim.
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------ |
| claimId\_ | uint256 | The claim ID |
Return values:
| Name | Type | Description |
| ---- | --------- | ------------------------- |
| -- | string\[] | The counter-evidence CIDs |
***
## Write Functions info
### submitEvidenceForClaim
```solidity
function submitEvidenceForClaim(
uint256 claimId_,
string[] calldata ipfsEvidenceCids_
) external claimsExists(claimId_)
```
Adds evidence IPFS CIDs for a claim.
Parameters:
| Name | Type | Description |
| ------------------ | --------- | ----------------------------- |
| claimId\_ | uint256 | The claim ID |
| ipfsEvidenceCids\_ | string\[] | The IPFS CIDs of the evidence |
### initiateClaim
```solidity
function initiateClaim(
uint256 coverId_,
uint256 amountClaimed_
) external payable nonReentrant
```
Initiates a payment claim to Kleros by a cover holder.
Parameters:
| Name | Type | Description |
| --------------- | ------- | -------------------------------------- |
| coverId\_ | uint256 | The cover ID |
| amountClaimed\_ | uint256 | The amount claimed by the cover holder |
### disputeClaim
```solidity
function disputeClaim(
uint256 claimId_
) external payable claimsExists(claimId_) nonReentrant
```
Allows a user to challenge a pending claim by creating a dispute in Kleros.
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------ |
| claimId\_ | uint256 | The claim ID |
### withdrawCompensation
```solidity
function withdrawCompensation(
uint256 claimId_
) external claimsExists(claimId_) nonReentrant
```
Allows the claimant to withdraw the compensation after a dispute has been resolved in their favor or the challenge period has elapsed.
Intentionally public to prevent claimant from indefinitely blocking withdrawals from a pool by not executing the claims ruling.
Parameters:
| Name | Type | Description |
| --------- | ------- | ------------ |
| claimId\_ | uint256 | The claim ID |
***
## Events info
### ClaimCreated
```solidity
event ClaimCreated(address indexed claimant, uint256 indexed coverId, uint256 claimId)
```
### DisputeResolved
```solidity
event DisputeResolved(uint256 claimId, uint256 disputeId, uint256 ruling)
```
### MetaEvidence
```solidity
event MetaEvidence(uint256 indexedmetaEvidenceID_, stringevidence_)
```
To be emitted when meta-evidence is submitted.
Parameters:
| Name | Type | Description |
| ---------------- | ------- | ------------------------------------------------------------------------------------------------------------ |
| metaEvidenceID\_ | uint256 | Unique identifier of meta-evidence. |
| evidence\_ | string | IPFS path to metaevidence, example: '/ipfs/Qmarwkf7C9RuzDEJNnarT3WZ7kem5bk8DZAzx78acJjMFH/metaevidence.json' |
### Evidence
```solidity
event Evidence(IArbitrator indexedarbitrator_, uint256 indexedevidenceGroupID_, address indexedparty_, stringevidence_)
```
To be raised when evidence is submitted. Should point to the resource (evidences are not to be stored on chain due to gas considerations).
Parameters:
| Name | Type | Description |
| ----------------- | -------------------- | ------------------------------------------------------------------------------------------------------------- |
| arbitrator\_ | contract IArbitrator | The arbitrator of the contract. |
| evidenceGroupID\_ | uint256 | Unique identifier of the evidence group the evidence belongs to. |
| party\_ | address | The address of the party submiting the evidence. Note that 0x0 refers to evidence not submitted by any party. |
| evidence\_ | string | IPFS path to evidence, example: '/ipfs/Qmarwkf7C9RuzDEJNnarT3WZ7kem5bk8DZAzx78acJjMFH/evidence.json' |
### Dispute
```solidity
event Dispute(IArbitrator indexedarbitrator_, uint256 indexeddisputeID_, uint256metaEvidenceID_, uint256evidenceGroupID_)
```
To be emitted when a dispute is created to link the correct meta-evidence to the disputeID.
Parameters:
| Name | Type | Description |
| ----------------- | -------------------- | ----------------------------------------------------------------------- |
| arbitrator\_ | contract IArbitrator | The arbitrator of the contract. |
| disputeID\_ | uint256 | ID of the dispute in the Arbitrator contract. |
| metaEvidenceID\_ | uint256 | Unique identifier of meta-evidence. |
| evidenceGroupID\_ | uint256 | Unique identifier of the evidence group that is linked to this dispute. |
# Socials
Stay up-to-date with the latest news, updates, and community discussions by following us on our social media channels.
## 💬 Telegram
Join our vibrant community on Telegram:
* [📢 Athena Announcements](https://t.me/Athenainsoff) - Get the latest news and updates
* [💬 Athena Community Chat](https://t.me/athenains_official) - Discuss, ask questions, and connect with other members
## 🐦 Twitter
Follow us on Twitter for real-time updates, insights, and more:
[](https://x.com/Athenains_off)
## 💻 GitHub
Explore our open-source code and contribute to our projects:
[](https://github.com/Athena-ins)
# Court House
The Court House is an upcoming space designed to streamline the claims process and foster community engagement. We want claim prosecution to be an engaging and rewarding activity for participants who contribute to the security of the Athena Protocol. This exciting addition will provide:
🛠️ Tools: Advanced resources to assist in claim analysis and resolution. 🤝 Support: A dedicated space for community members to collaborate on claim investigations.
The Court House aims to create a more transparent, efficient, and participatory claims environment. By leveraging the collective wisdom of our community, we won't just be resolving claims, we'll be building a stronger, fairer and more secure DeFi ecosystem for all.
Follow our social media for more details on how you can get involved.
