# Adding and removing collateral

### Vault Interface

For ease of understanding and interactions, here's the interface for the current Protocol Vault implementation:

```solidity
//SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

interface IVault {
    function vaultOwner() external view returns (address);
    function debt() external view returns (uint256);
    function transferVaultOwnership(address _newOwner) external;
    function setName(string memory _name) external;
    function containsCollateral(address _collateral) external view returns (bool);
    function collateralsLength() external view returns (uint256);
    function collateralAt(uint256 _index) external view returns (address);
    function collaterals() external view returns (address[] memory);
    function collateral(address _collateral) external view returns (uint256);
    function factory() external view returns (address);
    function addCollateral(address _collateral, uint256 _amount) external;
    function removeCollateral(address _collateral, uint256 _amount, address _to) external;
    function addBadDebt(uint256 _amount) external;
    function borrowable() external view returns (uint256 _maxBorrowable, uint256 _borrowable);
    function borrow(uint256 _amount) external;
    function repay(uint256 _amount) external;
    function calcRedeem(
        address _collateral,
        uint256 _collateralAmount
    ) external view returns (uint256 _stableAmountNeeded, uint256 _redemptionFee);
    function redeem(
        address _collateral,
        uint256 _collateralAmount
    ) external returns (uint256 _debtRepaid, uint256 _feeCollected);
    function healthFactor(bool _useMlr) external view returns (uint256 _healthFactor);
    function newHealthFactor(uint256 _newDebt, bool _useMlr) external view returns (uint256 _newHealthFactor);
    function borrowableWithDiff(
        address _collateral,
        uint256 _diffAmount,
        bool _isAdd,
        bool _useMlr
    ) external view returns (uint256 _maxBorrowable, uint256 _borrowable);
    function liquidate() external returns (uint256 _forgivenDebt);
}
```

***

### Adding collaterals

\
In order to borrow EURO3 from the Protocol, you'll need to add some collateral in your vault.\
The [VaultFactory](/3a-protocol/technical-documentation/smart-contracts/interacting-with-contracts/creating-a-vault.md) provides two methods that lets you do this, depending on the collateral type.\
\
For example, you may want to add MATIC, without wrapping WMATIC yourself.\
The protocol can do it automatically on your behalf, since we'll treat MATIC as a regular ERC20.

```solidity
import "./IVaultFactory.sol";
// --- core contract logic ---
IVaultFactory vaultFactory = IVaultFactory(0x.....0);
address vaultAddress = vaultFactory.createVault("customName"); 
uint256 MATIC_AMOUNT = 1e18;
vaultFactory.addCollateralNative(vaultAddress, { value: MATIC_AMOUNT });
```

In case of regular ERC20s the interface looks slightly different and requires an approval step first:

```solidity
import "./IVaultFactory.sol";
import "./IERC20.sol";
// --- core contract logic ---
IVaultFactory vaultFactory = IVaultFactory(0x.....0);

address vaultAddress = vaultFactory.createVault("customName"); 
uint256 USDC_AMOUNT = 1e18;

IERC20 usdc = IERC20(USDC_ADDRESS);
usdc.approve(vaultAddress, USDC_AMOUNT);

vaultFactory.addCollateral(vaultAddress, address(usdc), USDC_AMOUNT);
```

Vaults are multi-collateral by default, so you'll be able to add different types of collateral in the same `Vault`

***

### Removing collateral

\
While adding collateral is unrestricted, removing collateral from a vault can only be done by its `vaultOwner()`,\
\
Removing native collateral, for example MATIC, has its own specific method:

```solidity
import "./IVaultFactory.sol";
import "./IERC20.sol";
// --- core contract logic ---
IVaultFactory vaultFactory = IVaultFactory(0x.....0);

address vaultAddress = vaultFactory.lastVault();
address destinationAddress = msg.sender;

uint256 maticAmount = 1e18;

vaultFactory.removeCollateralNative(vaultAddress, maticAmount, destinationAddress);
```

In case of regular ERC20s the interface looks like the following:

```solidity
import "./IVaultFactory.sol";
import "./IERC20.sol";
// --- core contract logic ---
IVaultFactory vaultFactory = IVaultFactory(0x.....0);

address vaultAddress = vaultFactory.createVault("customName"); 
uint256 USDC_AMOUNT = 1e18;
address destinationAddress = msg.sender;

IERC20 usdc = IERC20(USDC_ADDRESS);

vaultFactory
    .removeCollateral(vaultAddress, 
                        address(usdc), 
                        USDC_AMOUNT, 
                        destinationAddress);
```

Keep in mind that if you have a debt position opened you can only withdraw up to a target Health Factor of `1.0`


---

# 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.3adao.org/3a-protocol/technical-documentation/smart-contracts/interacting-with-contracts/adding-and-removing-collateral.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.