assembly/core/strategies/protocols/aave-v2/payback-and-withdraw.ts

189 lines
5.0 KiB
TypeScript
Raw Normal View History

2021-09-04 16:50:56 +00:00
import BigNumber from "bignumber.js";
2021-08-23 23:07:53 +00:00
import tokens from "~/constant/tokens";
2021-08-25 11:13:23 +00:00
import {
defineStrategy,
defineInput,
StrategyInputType,
StrategyProtocol
} from "../../helpers";
2021-08-23 23:07:53 +00:00
export default defineStrategy({
2021-08-25 11:13:23 +00:00
protocol: StrategyProtocol.AAVE_V2,
2021-08-23 23:07:53 +00:00
name: "Payback & Withdraw",
description: "Payback debt & withdraw collateral in a single txn.",
author: "Instadapp Team",
2021-09-04 16:50:56 +00:00
submitText: "Payback & Withdraw",
2021-08-25 11:13:23 +00:00
details: `<p class="text-center">This strategy executes:</p>
<ul>
<li>Payback debt</li>
<li>Withdraw collateral</li>
</ul>`,
2021-08-23 23:07:53 +00:00
inputs: [
defineInput({
type: StrategyInputType.INPUT_WITH_TOKEN,
name: "Debt",
2021-08-25 11:13:23 +00:00
placeholder: ({ input }) =>
input.token ? `${input.token.symbol} to Payback` : "",
2021-09-04 16:50:56 +00:00
validate: ({ input, toBN, dsaBalances }) => {
2021-08-23 23:07:53 +00:00
if (!input.token) {
2021-09-04 16:50:56 +00:00
return "Debt token is required";
2021-08-23 23:07:53 +00:00
}
2021-09-04 16:50:56 +00:00
const balance = toBN(dsaBalances[input.token.address]?.balance);
if (toBN(balance).lt(input.value)) {
return "You don't have enough balance to payback.";
2021-08-23 23:07:53 +00:00
}
},
2021-08-25 11:13:23 +00:00
defaults: ({ getTokenByKey }) => ({
token: getTokenByKey?.("dai")
})
2021-08-23 23:07:53 +00:00
}),
defineInput({
type: StrategyInputType.INPUT_WITH_TOKEN,
name: "Collateral",
2021-08-25 11:13:23 +00:00
placeholder: ({ input }) =>
input.token ? `${input.token.symbol} to Withdraw` : "",
2021-09-04 16:50:56 +00:00
validate: ({ input, position, toBN }) => {
if (!input.token) {
return "Collateral token is required";
}
if (!input.value) {
return "Collateral amount is required";
}
if (position) {
const collateralPosition = position.data.find(
item => item.key === input.token.key
);
if (collateralPosition) {
const collateralBalance = toBN(collateralPosition.supply);
if (collateralBalance.lt(input.value)) {
const collateralBalanceFormatted = collateralBalance.toFixed(2);
return `Your amount exceeds your maximum limit of ${collateralBalanceFormatted} ${input.token.symbol}`;
}
}
}
},
2021-08-25 11:13:23 +00:00
defaults: ({ getTokenByKey }) => ({
token: getTokenByKey?.("eth")
})
2021-08-23 23:07:53 +00:00
})
],
2021-09-04 16:50:56 +00:00
validate: async ({ position, inputs, toBN }) => {
if (toBN(inputs[0].value).isZero() && toBN(inputs[1].value).isZero()) {
return;
}
const newPositionData = position.data.map(position => {
const changedPosition = { ...position };
if (inputs[0].token.key === position.key) {
changedPosition.borrow = BigNumber.max(
toBN(position.borrow).minus(inputs[0].value),
"0"
).toFixed();
}
if (inputs[1].token.key === position.key) {
changedPosition.supply = BigNumber.max(
toBN(position.supply).minus(inputs[1].value),
"0"
).toFixed();
}
return changedPosition;
});
const stats = newPositionData.reduce(
(
stats,
{ key, supply, borrow, borrowStable, priceInEth, factor, liquidation }
) => {
if (key === "eth") {
stats.ethSupplied = supply;
}
const borrowTotal = toBN(borrow).plus(borrowStable);
stats.totalSupplyInEth = toBN(supply)
.times(priceInEth)
.plus(stats.totalSupplyInEth)
.toFixed();
stats.totalBorrowInEth = toBN(borrowTotal)
.times(priceInEth)
.plus(stats.totalBorrowInEth)
.toFixed();
stats.totalMaxBorrowLimitInEth = toBN(priceInEth)
.times(factor)
.times(supply)
.plus(stats.totalMaxBorrowLimitInEth)
.toFixed();
stats.totalMaxLiquidationLimitInEth = toBN(priceInEth)
.times(liquidation)
.times(supply)
.plus(stats.totalMaxLiquidationLimitInEth)
.toFixed();
return stats;
},
{
totalSupplyInEth: "0",
totalBorrowInEth: "0",
totalMaxBorrowLimitInEth: "0",
totalMaxLiquidationLimitInEth: "0"
}
);
let maxLiquidation = "0";
if (!toBN(stats.totalSupplyInEth).isZero()) {
maxLiquidation = BigNumber.max(
toBN(stats.totalMaxLiquidationLimitInEth).div(stats.totalSupplyInEth),
"0"
).toFixed();
}
const status = BigNumber.max(
toBN(stats.totalBorrowInEth).div(stats.totalSupplyInEth),
"0"
);
if (status.gt(toBN(maxLiquidation).minus("0.0001"))) {
return "Position will liquidate.";
}
},
2021-08-26 16:38:31 +00:00
spells: async ({ inputs, convertTokenAmountToWei }) => {
2021-08-23 23:07:53 +00:00
return [
{
connector: "aave_v2",
method: "payback",
2021-08-25 11:13:23 +00:00
args: [
inputs[0].token.address,
2021-09-04 16:50:56 +00:00
convertTokenAmountToWei(inputs[0].value, inputs[0].token.decimals),
2,
2021-08-25 11:13:23 +00:00
0,
0
]
2021-08-23 23:07:53 +00:00
},
{
connector: "aave_v2",
method: "withdraw",
2021-08-25 11:13:23 +00:00
args: [
inputs[1].token.address,
2021-09-04 16:50:56 +00:00
convertTokenAmountToWei(inputs[1].value, inputs[1].token.decimals),
2021-08-25 11:13:23 +00:00
0,
0
]
2021-08-23 23:07:53 +00:00
}
];
}
});