mirror of
https://github.com/Instadapp/dsa-connectors.git
synced 2024-07-29 22:37:00 +00:00
442 lines
18 KiB
Solidity
442 lines
18 KiB
Solidity
pragma solidity ^0.7.0;
|
|
pragma experimental ABIEncoderV2;
|
|
|
|
/**
|
|
* @title Benqi.
|
|
* @dev Lending & Borrowing.
|
|
*/
|
|
|
|
import { TokenInterface } from "../../../common/interfaces.sol";
|
|
import { Stores } from "../../../common/stores.sol";
|
|
import { Helpers } from "./helpers.sol";
|
|
import { Events } from "./events.sol";
|
|
import { QiAVAXInterface, QiTokenInterface } from "./interface.sol";
|
|
|
|
abstract contract BenqiResolver is Events, Helpers {
|
|
/**
|
|
* @dev Deposit AVAX/ARC20_Token.
|
|
* @notice Deposit a token to Benqi for lending / collaterization.
|
|
* @param token The address of the token to deposit. (For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
|
|
* @param qiToken The address of the corresponding qiToken.
|
|
* @param amt The amount of the token to deposit. (For max: `uint256(-1)`)
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of tokens deposited.
|
|
*/
|
|
function depositRaw(
|
|
address token,
|
|
address qiToken,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) public payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
uint _amt = getUint(getId, amt);
|
|
|
|
require(token != address(0) && qiToken != address(0), "invalid token/qitoken address");
|
|
|
|
enterMarket(qiToken);
|
|
if (token == avaxAddr) {
|
|
_amt = _amt == uint(-1) ? address(this).balance : _amt;
|
|
QiAVAXInterface(qiToken).mint{value: _amt}();
|
|
} else {
|
|
TokenInterface tokenContract = TokenInterface(token);
|
|
_amt = _amt == uint(-1) ? tokenContract.balanceOf(address(this)) : _amt;
|
|
approve(tokenContract, qiToken, _amt);
|
|
require(QiTokenInterface(qiToken).mint(_amt) == 0, "deposit-failed");
|
|
}
|
|
setUint(setId, _amt);
|
|
|
|
_eventName = "LogDeposit(address,address,uint256,uint256,uint256)";
|
|
_eventParam = abi.encode(token, qiToken, _amt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Deposit AVAX/ARC20_Token using the Mapping.
|
|
* @notice Deposit a token to Benqi for lending / collaterization.
|
|
* @param tokenId The token id of the token to deposit.(For eg: AVAX-A)
|
|
* @param amt The amount of the token to deposit. (For max: `uint256(-1)`)
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of tokens deposited.
|
|
*/
|
|
function deposit(
|
|
string calldata tokenId,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) external payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
(address token, address qiToken) = qiMapping.getMapping(tokenId);
|
|
(_eventName, _eventParam) = depositRaw(token, qiToken, amt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Withdraw AVAX/ARC20_Token.
|
|
* @notice Withdraw deposited token from Benqi
|
|
* @param token The address of the token to withdraw. (For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
|
|
* @param qiToken The address of the corresponding qiToken.
|
|
* @param amt The amount of the token to withdraw. (For max: `uint256(-1)`)
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of tokens withdrawn.
|
|
*/
|
|
function withdrawRaw(
|
|
address token,
|
|
address qiToken,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) public payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
uint _amt = getUint(getId, amt);
|
|
|
|
require(token != address(0) && qiToken != address(0), "invalid token/qitoken address");
|
|
|
|
QiTokenInterface qiTokenContract = QiTokenInterface(qiToken);
|
|
if (_amt == uint(-1)) {
|
|
TokenInterface tokenContract = TokenInterface(token);
|
|
uint initialBal = token == avaxAddr ? address(this).balance : tokenContract.balanceOf(address(this));
|
|
require(qiTokenContract.redeem(qiTokenContract.balanceOf(address(this))) == 0, "full-withdraw-failed");
|
|
uint finalBal = token == avaxAddr ? address(this).balance : tokenContract.balanceOf(address(this));
|
|
_amt = finalBal - initialBal;
|
|
} else {
|
|
require(qiTokenContract.redeemUnderlying(_amt) == 0, "withdraw-failed");
|
|
}
|
|
setUint(setId, _amt);
|
|
|
|
_eventName = "LogWithdraw(address,address,uint256,uint256,uint256)";
|
|
_eventParam = abi.encode(token, qiToken, _amt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Withdraw AVAX/ARC20_Token using the Mapping.
|
|
* @notice Withdraw deposited token from Benqi
|
|
* @param tokenId The token id of the token to withdraw.(For eg: AVAX-A)
|
|
* @param amt The amount of the token to withdraw. (For max: `uint256(-1)`)
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of tokens withdrawn.
|
|
*/
|
|
function withdraw(
|
|
string calldata tokenId,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) external payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
(address token, address qiToken) = qiMapping.getMapping(tokenId);
|
|
(_eventName, _eventParam) = withdrawRaw(token, qiToken, amt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Borrow AVAX/ARC20_Token.
|
|
* @notice Borrow a token using Benqi
|
|
* @param token The address of the token to borrow. (For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
|
|
* @param qiToken The address of the corresponding qiToken.
|
|
* @param amt The amount of the token to borrow.
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of tokens borrowed.
|
|
*/
|
|
function borrowRaw(
|
|
address token,
|
|
address qiToken,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) public payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
uint _amt = getUint(getId, amt);
|
|
|
|
require(token != address(0) && qiToken != address(0), "invalid token/qitoken address");
|
|
|
|
enterMarket(qiToken);
|
|
require(QiTokenInterface(qiToken).borrow(_amt) == 0, "borrow-failed");
|
|
setUint(setId, _amt);
|
|
|
|
_eventName = "LogBorrow(address,address,uint256,uint256,uint256)";
|
|
_eventParam = abi.encode(token, qiToken, _amt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Borrow AVAX/ARC20_Token using the Mapping.
|
|
* @notice Borrow a token using Benqi
|
|
* @param tokenId The token id of the token to borrow.(For eg: DAI-A)
|
|
* @param amt The amount of the token to borrow.
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of tokens borrowed.
|
|
*/
|
|
function borrow(
|
|
string calldata tokenId,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) external payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
(address token, address qiToken) = qiMapping.getMapping(tokenId);
|
|
(_eventName, _eventParam) = borrowRaw(token, qiToken, amt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Payback borrowed AVAX/ARC20_Token.
|
|
* @notice Payback debt owed.
|
|
* @param token The address of the token to payback. (For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
|
|
* @param qiToken The address of the corresponding qiToken.
|
|
* @param amt The amount of the token to payback. (For max: `uint256(-1)`)
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of tokens paid back.
|
|
*/
|
|
function paybackRaw(
|
|
address token,
|
|
address qiToken,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) public payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
uint _amt = getUint(getId, amt);
|
|
|
|
require(token != address(0) && qiToken != address(0), "invalid token/qitoken address");
|
|
|
|
QiTokenInterface qiTokenContract = QiTokenInterface(qiToken);
|
|
_amt = _amt == uint(-1) ? qiTokenContract.borrowBalanceCurrent(address(this)) : _amt;
|
|
|
|
if (token == avaxAddr) {
|
|
require(address(this).balance >= _amt, "not-enough-avax");
|
|
QiAVAXInterface(qiToken).repayBorrow{value: _amt}();
|
|
} else {
|
|
TokenInterface tokenContract = TokenInterface(token);
|
|
require(tokenContract.balanceOf(address(this)) >= _amt, "not-enough-token");
|
|
approve(tokenContract, qiToken, _amt);
|
|
require(qiTokenContract.repayBorrow(_amt) == 0, "repay-failed.");
|
|
}
|
|
setUint(setId, _amt);
|
|
|
|
_eventName = "LogPayback(address,address,uint256,uint256,uint256)";
|
|
_eventParam = abi.encode(token, qiToken, _amt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Payback borrowed AVAX/ARC20_Token using the Mapping.
|
|
* @notice Payback debt owed.
|
|
* @param tokenId The token id of the token to payback.(For eg: BENQI-A)
|
|
* @param amt The amount of the token to payback. (For max: `uint256(-1)`)
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of tokens paid back.
|
|
*/
|
|
function payback(
|
|
string calldata tokenId,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) external payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
(address token, address qiToken) = qiMapping.getMapping(tokenId);
|
|
(_eventName, _eventParam) = paybackRaw(token, qiToken, amt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Deposit AVAX/ARC20_Token.
|
|
* @notice Same as depositRaw. The only difference is this method stores qiToken amount in set ID.
|
|
* @param token The address of the token to deposit. (For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
|
|
* @param qiToken The address of the corresponding qiToken.
|
|
* @param amt The amount of the token to deposit. (For max: `uint256(-1)`)
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of qiTokens received.
|
|
*/
|
|
function depositQiTokenRaw(
|
|
address token,
|
|
address qiToken,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) public payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
uint _amt = getUint(getId, amt);
|
|
|
|
require(token != address(0) && qiToken != address(0), "invalid token/qitoken address");
|
|
|
|
enterMarket(qiToken);
|
|
|
|
QiTokenInterface qitokenContract = QiTokenInterface(qiToken);
|
|
uint initialBal = qitokenContract.balanceOf(address(this));
|
|
|
|
if (token == avaxAddr) {
|
|
_amt = _amt == uint(-1) ? address(this).balance : _amt;
|
|
QiAVAXInterface(qiToken).mint{value: _amt}();
|
|
} else {
|
|
TokenInterface tokenContract = TokenInterface(token);
|
|
_amt = _amt == uint(-1) ? tokenContract.balanceOf(address(this)) : _amt;
|
|
approve(tokenContract, qiToken, _amt);
|
|
require(qitokenContract.mint(_amt) == 0, "deposit-qitoken-failed.");
|
|
}
|
|
|
|
uint _cAmt;
|
|
|
|
{
|
|
uint finalBal = qitokenContract.balanceOf(address(this));
|
|
_cAmt = sub(finalBal, initialBal);
|
|
|
|
setUint(setId, _cAmt);
|
|
}
|
|
|
|
_eventName = "LogDepositQiToken(address,address,uint256,uint256,uint256,uint256)";
|
|
_eventParam = abi.encode(token, qiToken, _amt, _cAmt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Deposit AVAX/ARC20_Token using the Mapping.
|
|
* @notice Same as deposit. The only difference is this method stores qiToken amount in set ID.
|
|
* @param tokenId The token id of the token to depositQiToken.(For eg: DAI-A)
|
|
* @param amt The amount of the token to deposit. (For max: `uint256(-1)`)
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of qiTokens received.
|
|
*/
|
|
function depositQiToken(
|
|
string calldata tokenId,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) external payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
(address token, address qiToken) = qiMapping.getMapping(tokenId);
|
|
(_eventName, _eventParam) = depositQiTokenRaw(token, qiToken, amt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Withdraw QiAVAX/QiARC20_Token using qiToken Amt.
|
|
* @notice Same as withdrawRaw. The only difference is this method fetch qiToken amount in get ID.
|
|
* @param token The address of the token to withdraw. (For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
|
|
* @param qiToken The address of the corresponding qiToken.
|
|
* @param qiTokenAmt The amount of qiTokens to withdraw
|
|
* @param getId ID to retrieve qiTokenAmt
|
|
* @param setId ID stores the amount of tokens withdrawn.
|
|
*/
|
|
function withdrawQiTokenRaw(
|
|
address token,
|
|
address qiToken,
|
|
uint qiTokenAmt,
|
|
uint getId,
|
|
uint setId
|
|
) public payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
uint _cAmt = getUint(getId, qiTokenAmt);
|
|
require(token != address(0) && qiToken != address(0), "invalid token/qitoken address");
|
|
|
|
QiTokenInterface qiTokenContract = QiTokenInterface(qiToken);
|
|
TokenInterface tokenContract = TokenInterface(token);
|
|
_cAmt = _cAmt == uint(-1) ? qiTokenContract.balanceOf(address(this)) : _cAmt;
|
|
|
|
uint withdrawAmt;
|
|
{
|
|
uint initialBal = token != avaxAddr ? tokenContract.balanceOf(address(this)) : address(this).balance;
|
|
require(qiTokenContract.redeem(_cAmt) == 0, "redeem-failed");
|
|
uint finalBal = token != avaxAddr ? tokenContract.balanceOf(address(this)) : address(this).balance;
|
|
|
|
withdrawAmt = sub(finalBal, initialBal);
|
|
}
|
|
|
|
setUint(setId, withdrawAmt);
|
|
|
|
_eventName = "LogWithdrawQiToken(address,address,uint256,uint256,uint256,uint256)";
|
|
_eventParam = abi.encode(token, qiToken, withdrawAmt, _cAmt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Withdraw QiAVAX/QiARC20_Token using qiToken Amt & the Mapping.
|
|
* @notice Same as withdraw. The only difference is this method fetch qiToken amount in get ID.
|
|
* @param tokenId The token id of the token to withdraw QiToken.(For eg: AVAX-A)
|
|
* @param qiTokenAmt The amount of qiTokens to withdraw
|
|
* @param getId ID to retrieve qiTokenAmt
|
|
* @param setId ID stores the amount of tokens withdrawn.
|
|
*/
|
|
function withdrawQiToken(
|
|
string calldata tokenId,
|
|
uint qiTokenAmt,
|
|
uint getId,
|
|
uint setId
|
|
) external payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
(address token, address qiToken) = qiMapping.getMapping(tokenId);
|
|
(_eventName, _eventParam) = withdrawQiTokenRaw(token, qiToken, qiTokenAmt, getId, setId);
|
|
}
|
|
|
|
/**
|
|
* @dev Liquidate a position.
|
|
* @notice Liquidate a position.
|
|
* @param borrower Borrower's Address.
|
|
* @param tokenToPay The address of the token to pay for liquidation.(For AVAX: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)
|
|
* @param qiTokenPay Corresponding qiToken address.
|
|
* @param tokenInReturn The address of the token to return for liquidation.
|
|
* @param qiTokenColl Corresponding qiToken address.
|
|
* @param amt The token amount to pay for liquidation.
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of paid for liquidation.
|
|
*/
|
|
function liquidateRaw(
|
|
address borrower,
|
|
address tokenToPay,
|
|
address qiTokenPay,
|
|
address tokenInReturn,
|
|
address qiTokenColl,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) public payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
uint _amt = getUint(getId, amt);
|
|
require(tokenToPay != address(0) && qiTokenPay != address(0), "invalid token/qitoken address");
|
|
require(tokenInReturn != address(0) && qiTokenColl != address(0), "invalid token/qitoken address");
|
|
|
|
QiTokenInterface qiTokenContract = QiTokenInterface(qiTokenPay);
|
|
|
|
{
|
|
(,, uint shortfal) = troller.getAccountLiquidity(borrower);
|
|
require(shortfal != 0, "account-cannot-be-liquidated");
|
|
_amt = _amt == uint(-1) ? qiTokenContract.borrowBalanceCurrent(borrower) : _amt;
|
|
}
|
|
|
|
if (tokenToPay == avaxAddr) {
|
|
require(address(this).balance >= _amt, "not-enough-avax");
|
|
QiAVAXInterface(qiTokenPay).liquidateBorrow{value: _amt}(borrower, qiTokenColl);
|
|
} else {
|
|
TokenInterface tokenContract = TokenInterface(tokenToPay);
|
|
require(tokenContract.balanceOf(address(this)) >= _amt, "not-enough-token");
|
|
approve(tokenContract, qiTokenPay, _amt);
|
|
require(qiTokenContract.liquidateBorrow(borrower, _amt, qiTokenColl) == 0, "liquidate-failed");
|
|
}
|
|
|
|
setUint(setId, _amt);
|
|
|
|
_eventName = "LogLiquidate(address,address,address,uint256,uint256,uint256)";
|
|
_eventParam = abi.encode(
|
|
address(this),
|
|
tokenToPay,
|
|
tokenInReturn,
|
|
_amt,
|
|
getId,
|
|
setId
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @dev Liquidate a position using the mapping.
|
|
* @notice Liquidate a position using the mapping.
|
|
* @param borrower Borrower's Address.
|
|
* @param tokenIdToPay token id of the token to pay for liquidation.(For eg: AVAX-A)
|
|
* @param tokenIdInReturn token id of the token to return for liquidation.(For eg: USDC-A)
|
|
* @param amt token amount to pay for liquidation.
|
|
* @param getId ID to retrieve amt.
|
|
* @param setId ID stores the amount of paid for liquidation.
|
|
*/
|
|
function liquidate(
|
|
address borrower,
|
|
string calldata tokenIdToPay,
|
|
string calldata tokenIdInReturn,
|
|
uint256 amt,
|
|
uint256 getId,
|
|
uint256 setId
|
|
) external payable returns (string memory _eventName, bytes memory _eventParam) {
|
|
(address tokenToPay, address qiTokenToPay) = qiMapping.getMapping(tokenIdToPay);
|
|
(address tokenInReturn, address qiTokenColl) = qiMapping.getMapping(tokenIdInReturn);
|
|
|
|
(_eventName, _eventParam) = liquidateRaw(
|
|
borrower,
|
|
tokenToPay,
|
|
qiTokenToPay,
|
|
tokenInReturn,
|
|
qiTokenColl,
|
|
amt,
|
|
getId,
|
|
setId
|
|
);
|
|
}
|
|
}
|
|
|
|
contract ConnectV2BenqiAvalanche is BenqiResolver {
|
|
string public constant name = "Benqi-v1";
|
|
}
|