At vaults liquidation, how could the flow 2a result in transfers of mintedRemaining to the vaults?

[Jorge-Lopes]

Question:

Accordingly to the description of flow 2a, the remaining debt is recorded in the reserve as a shortfall and vaults receive nothing back. However, there is a condition where, if mintedRemaining is not empty, the remaining IST not burned will be sent back to the vaults.
So, in what scenario would this condition be true and the plan.transfersToVault list has an entry describing a transfer of IST to vault that has no collateral?

Note: I couldn't find any test covering this scenario, if it exists I would appreciate it if you could point me to it.

Context

Liquidation.md

Flow 2: Auction does not raise enough to cover IST debt
This flow further bifurcates based on whether the auction has sold all its collateral asset and still has not covered the debt or has collateral remaining (which simply did not receive bidders)

Flow 2a: all collateral sold and debt is not covered

1. IST raised by the auction is burned to reduce debt in 1:1 ratio.

• Definitionally, this should result in zero IST remaining and some debt remaining

1. Remaining debt is recorded in the reserve as a shortfall::sequence ends; no penalty is taken and vaults receive nothing back::

---

When the calculateDistributionPlan is executed, an accounting variable is initiated with the returned object from liquidationResults. The liquidationResults will receive as arguments the totalDebt and the mintedProceeds (IST raised in the auction).

If minted is greater than or equal to debt, then the overage is the difference between minted and debt; otherwise, it is an empty amount. If minted is less than debt, then the shortfall is the difference between debt and minted; otherwise, it is an empty amount.

liquidationResults()

/**
* @param {Amount<'nat'>} debt
* @param {Amount<'nat'>} minted
* @returns {{ overage: Amount<'nat'>; shortfall: Amount<'nat'> }}
*/
export const liquidationResults = (debt, minted) => {
 if (AmountMath.isEmpty(minted)) {
   return { overage: minted, shortfall: debt };
 }

 const [overage, shortfall] = AmountMath.isGTE(debt, minted)
   ? [AmountMath.makeEmptyFromAmount(debt), AmountMath.subtract(debt, minted)]
   : [AmountMath.subtract(minted, debt), AmountMath.makeEmptyFromAmount(debt)];

 return { overage, shortfall };
};
harden(liquidationResults);

In Flow 2a we assume that minted is less than debt, which means that accounting object should have an empty amount as overage and some IST amount as shortfall.
The other assumption of Flow 2a is that all collateral as sold, which means that collateralProceeds will be empty.
Based on these 2 assumptions, in this scenario, the runFlow2a function will be executed.

calculateDistributionPlan

try {
    if (AmountMath.isEmpty(accounting.shortfall)) {
      // Flow #1: no shortfall
      runFlow1();
    } else if (AmountMath.isEmpty(collateralProceeds)) {
      // Flow 2a: all collateral was sold but debt was not covered
      runFlow2a();
    } else {
      // Flow #2b: There's unsold collateral; some vaults may be reinstated.
      runFlow2b();
    }
  } catch (err) {
    console.error('🚨 Failure running distribution flow:', err);
    // continue to return `plan` in the state that was reached
  }

As mentioned before, we know that minted is lower than debt, so when the debtToBurn is calculated in the runFlow2a, it should be equal to mintedProceeds.
And by consequence, the mintedRemaining should be empty as well

runFlow2a

const penaltyInMinted = ceilMultiplyBy(totalDebt, penaltyRate);
const recoveredDebt = AmountMath.min(
  AmountMath.add(totalDebt, penaltyInMinted),
  mintedProceeds,
);

plan.debtToBurn = recoveredDebt;

const distributable = subtractToEmpty(mintedProceeds, recoveredDebt);
let mintedRemaining = distributable;

So, assuming that mintedRemaining will be empty, the following condition will not pass and there will be no transfer of mintedRemaining to the initial vaults being pushed into transfersToVault.

if (!AmountMath.isEmpty(mintedRemaining)) {
  const mintedToReturn = AmountMath.min(mintedRemaining, vaultShare);
  mintedRemaining = AmountMath.subtract(mintedRemaining, mintedToReturn);
  plan.transfersToVault.push([vaultIndex, { Minted: mintedToReturn }]);
}

[anilhelvaci]

cc @Chris-Hibbert

[Chris-Hibbert]

I believe your analysis is correct. I think the extraneous check is there because it helped with a bug which has since been fixed. I looked for a short while, but didn't identify the particular bug. It doesn't seem worth tracking down further.

If you'll be making changes to that file anyway, feel free to drop that clause.

[Jorge-Lopes]

Sure, we will update the runFlow2a function accordingly.
Thank you very much for the clarification.