feat(liquidation): push penalties to reserve

Author: turadg

packages/run-protocol/src/vaultFactory/liquidateIncrementally.js

@@ -80,9 +80,26 @@ const start = async zcf => {
   const asFloat = (numerator, denominator) =>
     Number(numerator) / Number(denominator);
 
-  // TODO(5467)) distribute penalties to the reserve
-  assert(reservePublicFacet, 'Missing reservePublicFacet');
+  // #region penalty distribution
   const { zcfSeat: penaltyPoolSeat } = zcf.makeEmptySeatKit();
+  const drainPenaltyPool = async () => {
+    const addCollateral = await E(
+      reservePublicFacet,
+    ).makeAddCollateralInvitation();
+    const proposal = harden({
+      give: { Collateral: penaltyPoolSeat.getCurrentAllocation().Out },
+    });
+    const { deposited, userSeatPromise } = await offerTo(
+      zcf,
+      addCollateral,
+      harden({ Out: 'Collateral' }),
+      proposal,
+      penaltyPoolSeat,
+    );
+    const [deposits] = await Promise.all([deposited, userSeatPromise]);
+    trace('drainPenaltyPool deposited', deposits.Out);
+  };
+  // #endregion
 
   /**
    * Compute the tranche size whose sale on the AMM would have
@@ -312,6 +329,10 @@ const start = async zcf => {
 
     debtorSeat.exit();
     trace('exit seat');
+    // trigger but don't await so it doesn't make liquidation itself fail
+    drainPenaltyPool().catch(e =>
+      console.error('🚨 error draining penalty pool', e),
+    );
   };
 
   /**

packages/run-protocol/test/bundleTool.js

@@ -174,6 +174,11 @@ export const makeBundleCache = (wr, cwd, readPowers, opts) => {
   };
 
   const loaded = new Map();
+  /**
+   * @param {string} rootPath
+   * @param {string} targetName
+   * @param {(message: *) => void} [log]
+   */
   const load = async (rootPath, targetName, log = console.debug) => {
     const found = loaded.get(targetName);
     // console.log('load', { targetName, found: !!found, rootPath });

packages/run-protocol/test/vaultFactory/test-liquidator.js

@@ -34,7 +34,13 @@ import {
 } from '../supports.js';
 import { unsafeMakeBundleCache } from '../bundleTool.js';
 
-/** @type {import('ava').TestInterface<any>} */
+/** @typedef {Record<string, any> & {
+ *   aethKit: IssuerKit,
+ *   reserveCreatorFacet: AssetReserveCreatorFacet,
+ *   runKit: IssuerKit,
+ * }} Context */
+/** @type {import('ava').TestInterface<Context>} */
+// @ts-expect-error cast
 const test = unknownTest;
 
 // #region Support
@@ -45,6 +51,7 @@ const contractRoots = {
   liquidate: './src/vaultFactory/liquidateIncrementally.js',
   VaultFactory: './src/vaultFactory/vaultFactory.js',
   amm: './src/vpool-xyk-amm/multipoolMarketMaker.js',
+  reserve: './src/reserve/assetReserve.js',
 };
 
 /** @typedef {import('../../src/vaultFactory/vaultFactory').VaultFactoryContract} VFC */
@@ -285,6 +292,7 @@ const setupServices = async (
   iProduce.reserve.resolve(t.context.installation.reserve);
   // produce the reserve instance in the space
   await setupReserve(space);
+  t.context.reserveCreatorFacet = space.consume.reserveCreatorFacet;
   iProduce.VaultFactory.resolve(t.context.installation.VaultFactory);
   iProduce.liquidate.resolve(t.context.installation.liquidate);
   await startVaultFactory(space, { loanParams: loanTiming }, minInitialDebt);
@@ -818,3 +826,30 @@ test('amm stopAfter - want too much', async t => {
     Out: expectedRUN,
   });
 });
+
+test('penalties to reserve', async t => {
+  const {
+    aethKit: { brand: aethBrand },
+    runKit: { brand: runBrand },
+  } = t.context;
+
+  const d = await makeDriver(
+    t,
+    AmountMath.make(runBrand, 1000n),
+    AmountMath.make(aethBrand, 900n),
+  );
+  // Create a loan for 270 RUN with 400 aeth collateral
+  const collateralAmount = AmountMath.make(aethBrand, 400n);
+  const loanAmount = AmountMath.make(runBrand, 270n);
+  await d.makeVaultDriver(collateralAmount, loanAmount);
+
+  // liquidate
+  d.setPrice(AmountMath.make(runBrand, 636n));
+  await waitForPromisesToSettle();
+
+  const { reserveCreatorFacet } = t.context;
+  const reserveAllocations = await E(reserveCreatorFacet).getAllocations();
+  t.deepEqual(reserveAllocations, {
+    RUN: { brand: runBrand, value: 29n },
+  });
+});