# Deleveraging

#### Understanding Deleveraging

Deleveraging is the process of reducing your position's leverage by withdrawing collateral and repaying debt. This can be done in two ways:

1. **Partial deleveraging:** Reduce leverage while maintaining an active position.
2. **Full deleveraging:** Completely unwind the position by repaying all debt.

#### Preparing for Deleveraging

Before deleveraging, you need to:

1. **Understand your current position:** Review your collateral amount, debt amount, and health factor.
2. S**et an appropriate slippage tolerance:** Typically 0.5-2% depending on asset volatility.
3. **Calculate the optimal deleveraging amounts:** Determine how much collateral to withdraw and debt to repay.

#### Constructing the DeleverageAction struct

Deleveraging requires constructing a DeleverageAction struct that specifies how to unwind your position:

```javascript
// Define how much collateral to withdraw
const collateralAmount = ethers.utils.parseUnits('300', 18);
const repayAmount = ethers.utils.parseUnits('200', 18); // Amount of debt to repay

// Create swap data to convert collateral to borrow asset
// Note: This is an array of swaps, allowing for multi-hop routes
const swapData = [{
  target: '0x1111111254EEB25477B68fb85Ed929f73A960582', // 1inch router
  inputToken: underlyingAsset,
  outputToken: borrowUnderlying,
  inputAmount: ethers.utils.parseUnits('250', 18), // Amount needed to convert to repay debt
  call: '0x...', // Encoded swap call data
}];

// Construct deleverage struct
const deleverageAction = {
  cToken: COLLATERAL_CTOKEN,
  collateralAssets: collateralAmount,
  borrowedToken: BORROWED_CTOKEN,
  swapData: swapData,
  repayAmount: repayAmount,
  auxData: '0x' // Optional for specialized protocols
};
```

#### Executing the Deleverage Operation

With the DeleverageAction struct prepared, execute the deleverage operation:

```javascript
// Set slippage tolerance (1%)
const slippage = ethers.utils.parseUnits('0.01', 18);

// Execute the deleverage transaction
const tx = await positionManagement.deleverage(
  deleverageData, 
  slippage,
  2000000
);

const receipt = await tx.wait();
console.log(`Position deleveraged! Tx hash: ${receipt.transactionHash}`);
```

### Important Considerations

1. **Swap Data Configuration:**
   1. The `swapData` array can contain multiple swaps for complex routes.
   2. Each swap must specify the correct input/output tokens and amounts.
   3. Slippage tolerance should be set appropriately for each swap.
2. **Amount Calculations:**
   1. `collateralAmount`: The amount of position tokens to withdraw.
   2. `repayAmount`: The amount of debt to repay in the borrowed asset.
   3. Ensure these amounts are properly calculated to maintain desired position size.
3. **Protocol-Specific Features:**
   1. Some protocols may require additional data in the `auxData` field.
   2. Check protocol documentation for specific requirements.
   3. Consider using protocol-specific optimizations when available.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.curvance.com/app/developer-docs/quick-start-guides/leverage/deleveraging.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.