rome-keeper.ride

{-# STDLIB_VERSION 6 #-}
{-# CONTENT_TYPE DAPP #-}
{-# SCRIPT_TYPE ACCOUNT #-}

let VERSION = "RK-1.0.4"

let Scale8 = 100000000
let Scale6 = 1000000

let aggregatorAddress = getString("setup_aggregator").valueOrElse("").addressFromString().valueOrElse(Address(base58'3PGFHzVGT4NTigwCKP1NcwoXkodVZwvBuuU'))
let maxSwapAmount = getInteger("setup_maxSwapAmount").valueOrElse(10000000)
let maxLPCap = getInteger("setup_maxLPCap").valueOrElse(20000 * Scale6)

func getAssetString(assetId: ByteVector|Unit) = {
  match assetId {
    case b:ByteVector => b.toBase58String()
    case _ => "WAVES"
  }
}

func getAssetBytes(assetIdStr: String) = {
  if (assetIdStr == "WAVES") then {unit} else {assetIdStr.fromBase58String()}
}

func getBalance(assetIdStr: String) = {
  if (assetIdStr == "WAVES") then {wavesBalance(this).available} else {assetBalance(this, assetIdStr.fromBase58String())}
}


func getTargetReturn(assetFrom: String, assetsRatio: Int) = {
  let ratios = getStringValue("setup_targets_"+assetFrom).split(";") # "80000000,103000000;50000000,105000000;30000000,110000000;10000000,120000000;0,200000000"
  func f(accum: Int, next: String) = {
    let li = next.split(",")
    if (assetsRatio < li[0].parseIntValue()) then {li[1].parseIntValue()} else {accum}
  }

  FOLD<10>(ratios, 100000000, f)
}

func getLPQuantity() = {
  assetInfo(getStringValue("setup_lpId").fromBase58String()).value().quantity
}

func getLPContractPrice() = {
  let assets = getStringValue("setup_assets").split(",")
  let treasury = getBalance(assets[0].value()) + getBalance(assets[1].value())
  let quant = getLPQuantity()
  if (quant == 0) then Scale6 else fraction(treasury, Scale6, quant)
}


@Callable(i)
func init() = {
  if (i.caller != this) then {throw("available for self-invoke only")}
  else {
    let lp = Issue("Rome Keeper", "Rome Keeper - derivative to sustain ROME stablecoin peg. https://rome.puzzleswap.org.", 0, 6, true)
    let lpId = lp.calculateAssetId()

    [
      StringEntry("setup_lpId", lpId.toBase58String()),
      StringEntry("setup_assets", "9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi,AP4Cb5xLYGH6ZigHreCZHoXpQTWDkPsG2BHqfDUx6taJ"),
      StringEntry("setup_targets_9wc3LXNA4TEBsXyKtoLE9mrbDD7WMHXvXrCjZvabLAsi", "80000000,103000000;50000000,105000000;30000000,110000000;10000000,120000000;0,200000000"),
      StringEntry("setup_targets_AP4Cb5xLYGH6ZigHreCZHoXpQTWDkPsG2BHqfDUx6taJ", "80000000,100000000;50000000,100000000;30000000,101000000;10000000,110000000;0,150000000")
    ]
  }
}


@Callable(i)
func doSwap(asset0Str: String, asset1Str: String, amount: Int, route: String) = {
  let asset0Bal = getBalance(asset0Str)
  let asset1Bal = getBalance(asset1Str)
  let currentRatio = fraction(asset0Bal, Scale8, asset1Bal+asset0Bal)
  let targetReturn = getTargetReturn(asset0Str, currentRatio)

  let asset0 = getAssetBytes(asset0Str)
  let asset1 = getAssetBytes(asset1Str)

  strict asset1BalBefore = getBalance(asset1Str)
  strict swapTx = invoke(aggregatorAddress, "swap", [route, amount], [AttachedPayment(asset0, amount)])
  strict asset1BalChange = getBalance(asset1Str) - asset1BalBefore

  if (maxSwapAmount < amount) then {throw("amount to swap exceeds a limit")}
  else if (fraction(asset1BalChange, Scale8, amount) < targetReturn) then { throw("swap premium is not enough to perform arbitrage") }
  else {

    []

  }
}


@Callable(i)
func mintLP() = {
  let assetId = i.payments[0].assetId
  let amount = i.payments[0].amount
  let quantity = getLPQuantity()
  let toMint = fraction(amount, Scale6, getLPContractPrice())

  if (getStringValue("setup_assets").indexOf(assetId.getAssetString()) == unit) then {throw("wrong asset attached")}
  else if ((quantity + toMint) > maxLPCap) then {throw("LP cap reached")}
  else {
    
    let lpId = getStringValue("setup_lpId").fromBase58String()
    let reissue = Reissue(lpId, toMint, true)

    [
      reissue,
      ScriptTransfer(i.caller, toMint, lpId)
    ]

  }
}


@Callable(i)
func redeemLP() = {
  [
  ]
}


@Callable(i)
func updateString(key: String, val: String) = {
  if (this != i.caller) then {throw("admin only")}
  else {
    [
      StringEntry(key, val)
    ]
  }
}


@Callable(i)
func updateInt(key: String, val: Int) = {
  if (this != i.caller) then {throw("admin only")}
  else {
    [
      IntegerEntry(key, val)
    ]
  }
}

@Callable(i)
func getRKPrice(debug: Boolean) = {
  let res = getLPContractPrice()
  if (debug) then { throw(res.toString()) } else { ([], res)}
}

@Callable(i)
func getTargets(debug: Boolean) = {
  let assets = getStringValue("setup_assets").split(",")
  let asset0Bal = getBalance(assets[0])
  let asset1Bal = getBalance(assets[1])

  let currentRatio = fraction(asset0Bal, Scale8, asset1Bal+asset0Bal)
  let targetReturn = getTargetReturn(assets[0], currentRatio)

  let currentRatioRev = fraction(asset1Bal, Scale8, asset1Bal+asset0Bal)
  let targetReturnRev = getTargetReturn(assets[1], currentRatio)

  if (debug) then { throw(targetReturn.toString() + "," + targetReturnRev.toString()) } else { ([], (targetReturn, targetReturnRev))}
}