fix: return funds from liquidation via a seat payout (#3656)

* fix: return funds from liquidation via a seat payout

Reduce overuse of vaultSeat for transferring RUN

* refactor: add liquidating state; disallow adjustments in liquidating

Author: Chris-Hibbert

packages/treasury/src/liquidation.js

@@ -20,10 +20,11 @@ export async function liquidate(
   strategy,
   collateralBrand,
 ) {
+  vaultKit.liquidating();
   const runDebt = vaultKit.vault.getDebtAmount();
-  const { runBrand } = runDebt.brand;
+  const { brand: runBrand } = runDebt;
+  const { vaultSeat, liquidationZcfSeat: liquidationSeat } = vaultKit;
 
-  const vaultSeat = vaultKit.vaultSeat;
   const collateralToSell = vaultSeat.getAmountAllocated(
     'Collateral',
     collateralBrand,
@@ -34,14 +35,15 @@ export async function liquidate(
     strategy.keywordMapping(),
     strategy.makeProposal(collateralToSell, runDebt),
     vaultSeat,
+    liquidationSeat,
   );
   trace(` offeredTo`, runDebt);
 
   // await deposited, but we don't need the value.
   await Promise.all([deposited, E(liqSeat).getOfferResult()]);
 
   // Now we need to know how much was sold so we can pay off the debt
-  const runProceedsAmount = vaultSeat.getAmountAllocated('RUN', runBrand);
+  const runProceedsAmount = liquidationSeat.getAmountAllocated('RUN', runBrand);
 
   trace('RUN PROCEEDS', runProceedsAmount);
 
@@ -50,11 +52,13 @@ export async function liquidate(
 
   const isUnderwater = !AmountMath.isGTE(runProceedsAmount, runDebt);
   const runToBurn = isUnderwater ? runProceedsAmount : runDebt;
-  burnLosses({ RUN: runToBurn }, vaultSeat);
+  burnLosses({ RUN: runToBurn }, liquidationSeat);
   vaultKit.liquidated(AmountMath.subtract(runDebt, runToBurn));
 
   // any remaining RUN plus anything else leftover from the sale are refunded
   vaultSeat.exit();
+  liquidationSeat.exit();
+  vaultKit.liquidationPromiseKit.resolve('Liquidated');
 }
 
 // The default strategy converts of all the collateral to RUN using autoswap,

packages/treasury/src/types.js

@@ -91,12 +91,13 @@
  * @property {() => Promise<Invitation>} makeCloseInvitation
  * @property {() => Amount} getCollateralAmount
  * @property {() => Amount} getDebtAmount
+ * @property {() => ERef<UserSeat>} getLiquidationSeat
+ * @property {() => Promise<string>} getLiquidationPromise
  */
 
 /**
  * @typedef {Object} LoanKit
  * @property {Vault} vault
- * @property {Promise<PaymentPKeywordRecord>} liquidationPayout
  * @property {Notifier<UIState>} uiNotifier
  */
 
@@ -105,6 +106,9 @@
  * @property {Vault} vault
  * @property {(ZCFSeat) => Promise<OpenLoanKit>} openLoan
  * @property {(Timestamp) => Amount} accrueInterestAndAddToPool
+ * @property {ZCFSeat} vaultSeat
+ * @property {PromiseRecord<string>} liquidationPromiseKit
+ * @property {ZCFSeat} liquidationZcfSeat
  */
 
 /**

packages/treasury/src/vault.js

@@ -15,12 +15,25 @@ import { makeNotifierKit } from '@agoric/notifier';
 import { makeRatio } from '@agoric/zoe/src/contractSupport/ratio.js';
 import { AmountMath } from '@agoric/ertp';
 import { Far } from '@agoric/marshal';
-import { makeTracer } from './makeTracer.js';
+import { makePromiseKit } from '@agoric/promise-kit';
 import { makeInterestCalculator } from './interest.js';
 
 // a Vault is an individual loan, using some collateralType as the
 // collateral, and lending RUN to the borrower
 
+/**
+ * Constants for vault state.
+ *
+ * @typedef {'active' | 'liquidating' | 'closed'} VAULT_STATE
+ *
+ * @type {{ ACTIVE: 'active', LIQUIDATING: 'liquidating', CLOSED: 'closed' }}
+ */
+export const VaultState = {
+  ACTIVE: 'active',
+  LIQUIDATING: 'liquidating',
+  CLOSED: 'closed',
+};
+
 /** @type {MakeVaultKit} */
 export function makeVaultKit(
   zcf,
@@ -31,13 +44,18 @@ export function makeVaultKit(
   loanParams,
   startTimeStamp,
 ) {
-  const trace = makeTracer('VV');
   const { updater: uiUpdater, notifier } = makeNotifierKit();
+  const {
+    zcfSeat: liquidationZcfSeat,
+    userSeat: liquidationSeat,
+  } = zcf.makeEmptySeatKit(undefined);
+  const liquidationPromiseKit = makePromiseKit();
 
-  let active = true; // liquidation halts all user actions
+  /** @type {VAULT_STATE} */
+  let vaultState = VaultState.ACTIVE;
 
   function assertVaultIsOpen() {
-    assert(active, 'vault must still be active');
+    assert(vaultState === VaultState.ACTIVE, 'vault must still be active');
   }
 
   const collateralBrand = manager.getCollateralBrand();
@@ -49,9 +67,7 @@ export function makeVaultKit(
   // (because the StableCoinMachine vat died), they'll get all their
   // collateral back. If that happens, the issuer for the RUN will be dead,
   // so their loan will be worthless.
-  const { zcfSeat: vaultSeat, userSeat } = zcf.makeEmptySeatKit();
-
-  trace('vaultSeat proposal', vaultSeat.getProposal());
+  const { zcfSeat: vaultSeat } = zcf.makeEmptySeatKit();
 
   const { brand: runBrand } = runMint.getIssuerRecord();
   let runDebt = AmountMath.makeEmpty(runBrand);
@@ -130,19 +146,31 @@ export function makeVaultKit(
       locked: getCollateralAmount(),
       debt: runDebt,
       collateralizationRatio,
-      liquidated: !active,
+      liquidated: vaultState === VaultState.CLOSED,
+      vaultState,
     });
 
-    if (active) {
-      uiUpdater.updateState(uiState);
-    } else {
-      uiUpdater.finish(uiState);
+    switch (vaultState) {
+      case VaultState.ACTIVE:
+      case VaultState.LIQUIDATING:
+        uiUpdater.updateState(uiState);
+        break;
+      case VaultState.CLOSED:
+        uiUpdater.finish(uiState);
+        break;
+      default:
+        throw Error(`unreachable vaultState: ${vaultState}`);
     }
   }
 
   function liquidated(newDebt) {
     runDebt = newDebt;
-    active = false;
+    vaultState = VaultState.CLOSED;
+    updateUiState();
+  }
+
+  function liquidating() {
+    vaultState = VaultState.LIQUIDATING;
     updateUiState();
   }
 
@@ -167,20 +195,24 @@ export function makeVaultKit(
     assert(AmountMath.isGTE(runReturned, runDebt));
 
     // Return any overpayment
-    vaultSeat.incrementBy(seat.decrementBy({ RUN: runDebt }));
+
+    const { zcfSeat: burnSeat } = zcf.makeEmptySeatKit();
+    burnSeat.incrementBy(seat.decrementBy({ RUN: runDebt }));
     seat.incrementBy(
       vaultSeat.decrementBy({ Collateral: getCollateralAllocated(vaultSeat) }),
     );
-    zcf.reallocate(seat, vaultSeat);
-
+    zcf.reallocate(seat, vaultSeat, burnSeat);
+    runMint.burnLosses({ RUN: runDebt }, burnSeat);
     seat.exit();
-    active = false;
+    burnSeat.exit();
+    vaultState = VaultState.CLOSED;
     updateUiState();
 
-    runMint.burnLosses({ RUN: runDebt }, vaultSeat);
     runDebt = AmountMath.makeEmpty(runBrand);
     assertVaultHoldsNoRun();
     vaultSeat.exit();
+    liquidationZcfSeat.exit();
+    liquidationPromiseKit.resolve('Closed');
 
     return 'your loan is closed, thank you for your business';
   }
@@ -397,8 +429,6 @@ export function makeVaultKit(
       want: { RUN: wantedRun },
     } = seat.getProposal();
 
-    const collateralPayoutP = E(userSeat).getPayouts();
-
     // todo trigger process() check right away, in case the price dropped while we ran
 
     const fee = multiplyBy(wantedRun, manager.getLoanFee());
@@ -419,7 +449,7 @@ export function makeVaultKit(
 
     updateUiState();
 
-    return { notifier, collateralPayoutP };
+    return { notifier };
   }
 
   function accrueInterestAndAddToPool(currentTime) {
@@ -453,13 +483,18 @@ export function makeVaultKit(
     // for status/debugging
     getCollateralAmount,
     getDebtAmount,
+    getLiquidationSeat: () => liquidationSeat,
+    getLiquidationPromise: () => liquidationPromiseKit.promise,
   });
 
   return harden({
     vault,
     openLoan,
     accrueInterestAndAddToPool,
     vaultSeat,
+    liquidating,
     liquidated,
+    liquidationPromiseKit,
+    liquidationZcfSeat,
   });
 }

packages/treasury/src/vaultManager.js

@@ -224,21 +224,18 @@ export function makeVaultManager(
     );
 
     const { vault, openLoan } = vaultKit;
-    const { notifier, collateralPayoutP } = await openLoan(seat);
+    const { notifier } = await openLoan(seat);
     sortedVaultKits.addVaultKit(vaultKit, notifier);
 
     seat.exit();
 
-    // TODO: nicer to return single objects, find a better way to give them
-    // the payout object
     return harden({
       uiNotifier: notifier,
       invitationMakers: Far('invitation makers', {
         AdjustBalances: vault.makeAdjustBalancesInvitation,
         CloseVault: vault.makeCloseInvitation,
       }),
       vault,
-      liquidationPayout: collateralPayoutP,
     });
   }
 

packages/treasury/test/swingsetTests/vat-alice.js

@@ -26,7 +26,7 @@ const build = async (log, zoe, brands, payments, timer) => {
       }),
     );
 
-    const { vault, _liquidationPayout } = await E(loanSeat).getOfferResult();
+    const { vault } = await E(loanSeat).getOfferResult();
     log(`Alice owes ${q(await E(vault).getDebtAmount())} after borrowing`);
     await E(timer).tick();
     log(`Alice owes ${q(await E(vault).getDebtAmount())} after interest`);