Cálculo automático para saber si conviene o no y saber qué ganancia se podría hacer haciendo Leverage en AAVE (aplicable tambíen a otros proyectos de lending/borrow)

calculate-leverage-aave .js

/**
* Cálculo automático para saber si conviene o no y saber qué ganancia se podría hacer haciendo Leverage en AAVE.
* También se podría aplicar a cualquier otro proyecto que haga lending/borrow (compound, venus, fortress, etc).
* El leverage en AAVE consiste en depositar, pedir prestado una parte (colateral) y volver a depositar. 
* Esto se puede repetir varias veces, lo óptimo es repetirlo 10 veces. Más de 10 veces no aumentan practicamente las ganancias.
* Haciendo esto podemos pasar de una ganancia de 9% a 40% aprox. Según los rewards que nos den por depositar y pedir prestado.
* (!) IMPORTANTE: es necesario saber que hacer esto implica el riesgo de que nos liquiden!!!
*/

/**
* Función que devuelve la ganancia por depositar en AAVE.
* Se le pasa como parametro la inversión, el apy y 
* el apy de distribución (ej: matic en polygon).
*/
let lend = (investment, apy, apyDistribution) => {
  return investment + (((1 + (apy / 100)) * investment) - investment) + (((1 + (apyDistribution / 100)) * investment) - investment);
}

let apr2apy = (apr) => (Math.pow((apr / 36500) + 1, 365) - 1) * 100;

/**
* Hace el calculo por depositar, pedir prestado, volver a depositar en AAVE.
* Para hacerlo más de una vez hay que pasarle como parámetro loops.
* colateral es el porcentaje que se pide prestado respecto a la investión. 
*   Ejemplo si tenemos colateral = 50 e investment = 1000, el prestamo inicial va a ser de 50% de 1000 = 500.
*/
let leverageAave = (investment , colateral, apyLend, apyLendMatic, apyBorrow, apyBorrowMatic, loops = 1) => {

  let total = 0,
    totalBorrow = 0,
    totalLendingBorrow = 0;

  let totalLending = lend(investment, apyLend, apyLendMatic) - investment;
  total += totalLending;
  
  for (let i = 0; i < loops; i++) {
    let invBorrow = investment * (colateral / 100);

    let borrow = lend(invBorrow, apyBorrow, apyBorrowMatic) - invBorrow;
    let lendingBorrow = lend(invBorrow, apyLend, apyLendMatic) - invBorrow;

    totalBorrow += borrow;
    totalLendingBorrow += lendingBorrow;

    total += borrow + lendingBorrow;
    investment = invBorrow;
  }

  return {
    totalLending,
    totalBorrow,
    totalLendingBorrow,
    total
  }
}

// Ejemplo de uso con DAI en Polygon hoy 25/11/2021

let investment = 1000; // 1000 DAI

/**
* 70% vamos a pedir prestado de $1000, luego 70% de $700, luego 70% de $490, 
* y asi sucesivamente hasta la cantidad de loops seteada.
*/
let colateral = 70; 

// Cantidad de veces que depositamos, pedimos prestado una parte (colateral) y depositamos lo prestado.
let loops = 10; 

let apy = 7.02; // APY que nos pagan por depositar DAI
let apyDistribution = apr2apy(2.4); // APR en Matic (en Polygon) que nos pagan por depositar DAI
let apyBorrow = -9.7; // APY que nos cobran (por eso negativo) por pedir prestado
let apyBorrowDistribution = apr2apy(4.42); // APR en Matic que nos pagan por pedir prestado en Matic (en Polygon)

let leverage = leverageAave(investment, colateral, apy, apyDistribution, apyBorrow, apyBorrowDistribution, loops)

console.log(`La ganancia anual por depositar ${investment} DAI es de: ${leverage.total.toFixed(2)} DAI`);
console.log(`La ganancia mensual por depositar ${investment} DAI es de: ${(leverage.total/12).toFixed(2)} DAI`);
console.log(`La ganancia diaria por depositar ${investment} DAI es de: ${(leverage.total/365).toFixed(2)} DAI`);
console.log(`La ganancia por hora por depositar ${investment} DAI es de: ${(leverage.total/365/24).toFixed(2)} DAI`);

Para la imagen los valores serían:

let apy = 7;
let apyDistribution = apr2apy(2.42);
let apyBorrow = -9.67;
let apyBorrowDistribution = apr2apy(4.47);