@agoric/inter-protocol 0.13.3 → 0.13.4-dev-800c2bb.0

package/src/vaultFactory/vault.js

@@ -1,31 +1,23 @@
-// @ts-check
-import '@agoric/zoe/exported.js';
-
-import {
-  assertProposalShape,
-  makeRatioFromAmounts,
-  ceilMultiplyBy,
-  floorMultiplyBy,
-} from '@agoric/zoe/src/contractSupport/index.js';
-import { AmountMath } from '@agoric/ertp';
-import {
-  defineDurableKindMulti,
-  makeKindHandle,
-  pickFacet,
-} from '@agoric/vat-data';
-import { makeTracer } from '../makeTracer.js';
-import { calculateCurrentDebt, reverseInterest } from '../interest-math.js';
-import { makeVaultKit } from './vaultKit.js';
+import { AmountMath, AmountShape } from '@agoric/ertp';
+import { makeTracer, StorageNodeShape } from '@agoric/internal';
+import { M, prepareExoClassKit } from '@agoric/vat-data';
+import { atomicTransfer } from '@agoric/zoe/src/contractSupport/index.js';
+import { SeatShape } from '@agoric/zoe/src/typeGuards.js';
 import {
   addSubtract,
-  assertOnlyKeys,
-  makeEphemeraProvider,
-  stageDelta,
+  allEmpty,
+  makeNatAmountShape,
 } from '../contractSupport.js';
+import { calculateCurrentDebt, reverseInterest } from '../interest-math.js';
+import { UnguardedHelperI } from '../typeGuards.js';
+import { prepareVaultKit } from './vaultKit.js';
+
+import '@agoric/zoe/exported.js';
+import { calculateDebtCosts } from './math.js';
 
-const { details: X, quote: q } = assert;
+const { quote: q, Fail } = assert;
 
-const trace = makeTracer('IV', false);
+const trace = makeTracer('Vault', true);
 
 /** @typedef {import('./storeUtils.js').NormalizedDebt} NormalizedDebt */
 
@@ -70,7 +62,7 @@ export const Phase = /** @type {const} */ ({
  */
 const validTransitions = {
   [Phase.ACTIVE]: [Phase.LIQUIDATING, Phase.CLOSED],
-  [Phase.LIQUIDATING]: [Phase.LIQUIDATED],
+  [Phase.LIQUIDATING]: [Phase.LIQUIDATED, Phase.ACTIVE],
   [Phase.LIQUIDATED]: [Phase.CLOSED],
   [Phase.CLOSED]: [],
 };
@@ -88,11 +80,12 @@ const validTransitions = {
 /**
  * @typedef {object} VaultManager
  * @property {() => Subscriber<import('./vaultManager').AssetState>} getAssetSubscriber
- * @property {(collateralAmount: Amount) => ERef<Amount<'nat'>>} maxDebtFor
+ * @property {(collateralAmount: Amount) => Amount<'nat'>} maxDebtFor
  * @property {() => Brand} getCollateralBrand
+ * @property {(base: string) => string} scopeDescription
  * @property {() => Brand<'nat'>} getDebtBrand
- * @property {MintAndReallocate} mintAndReallocate
- * @property {(amount: Amount, seat: ZCFSeat) => void} burnAndRecord
+ * @property {MintAndTransfer} mintAndTransfer
+ * @property {(amount: Amount, seat: ZCFSeat) => void} burn
  * @property {() => Ratio} getCompoundedInterest
  * @property {(oldDebt: import('./storeUtils.js').NormalizedDebt, oldCollateral: Amount<'nat'>, vaultId: VaultId, vaultPhase: VaultPhase, vault: Vault) => void} handleBalanceChange
  * @property {() => import('./vaultManager.js').GovernedParamGetters} getGovernedParams
@@ -102,6 +95,7 @@ const validTransitions = {
  * @typedef {Readonly<{
  * idInManager: VaultId,
  * manager: VaultManager,
+ * storageNode: StorageNode,
  * vaultSeat: ZCFSeat,
  * }>} ImmutableState
  */
@@ -113,696 +107,765 @@ const validTransitions = {
  *   interestSnapshot: Ratio,
  *   phase: VaultPhase,
  *   debtSnapshot: Amount<'nat'>,
+ *   outerUpdater: import('@agoric/zoe/src/contractSupport/recorder.js').Recorder<VaultNotification> | null,
  * }} MutableState
  */
 
-/**
- * @typedef {Readonly<{
- *   state: ImmutableState & MutableState,
- *   facets: {
- *     self: import('@agoric/vat-data/src/types').KindFacet<typeof selfBehavior>,
- *     helper: import('@agoric/vat-data/src/types').KindFacet<typeof helperBehavior>,
- *   },
- * }>} MethodContext
- */
+export const VaultI = M.interface('Vault', {
+  getCollateralAmount: M.call().returns(AmountShape),
+  getCurrentDebt: M.call().returns(AmountShape),
+  getNormalizedDebt: M.call().returns(AmountShape),
+  getVaultSeat: M.call().returns(SeatShape),
+  initVaultKit: M.call(SeatShape, StorageNodeShape).returns(M.promise()),
+  liquidated: M.call().returns(undefined),
+  liquidating: M.call().returns(undefined),
+  makeAdjustBalancesInvitation: M.call().returns(M.promise()),
+  makeCloseInvitation: M.call().returns(M.promise()),
+  makeTransferInvitation: M.call().returns(M.promise()),
+  abortLiquidation: M.call().returns(M.string()),
+});
 
-/**
- * Ephemera are the elements of state that cannot (or need not) be durable.
- * When there's a single instance it can be held in a closure, but there are
- * many vault manaager objects. So we hold their ephemera keyed by the durable
- * vault manager object reference.
- *
- * @type {(key: VaultId) => {
- * storageNode: ERef<StorageNode>,
- * marshaller: ERef<Marshaller>,
- * outerUpdater: Publisher<VaultNotification> | null,
- * zcf: ZCF,
- * }} */
-// @ts-expect-error not yet defined
-const provideEphemera = makeEphemeraProvider(() => ({}));
+const VaultStateShape = harden({
+  idInManager: M.any(),
+  manager: M.any(),
+  outerUpdater: M.any(),
+  phase: M.any(),
+  storageNode: M.any(),
+  vaultSeat: M.any(),
+  interestSnapshot: M.any(),
+  debtSnapshot: M.any(),
+});
 
 /**
+ * @param {import('@agoric/ertp').Baggage} baggage
+ * @param {import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit} makeRecorderKit
  * @param {ZCF} zcf
- * @param {VaultManager} manager
- * @param {VaultId} idInManager
- * @param {ERef<StorageNode>} storageNode
- * @param {ERef<Marshaller>} marshaller
  */
-const initState = (zcf, manager, idInManager, storageNode, marshaller) => {
-  const ephemera = provideEphemera(idInManager);
-  ephemera.storageNode = storageNode;
-  ephemera.marshaller = marshaller;
-  ephemera.zcf = zcf;
-
-  /**
-   * @type {ImmutableState & MutableState}
-   */
-  return harden({
-    idInManager,
-    manager,
-    outerUpdater: null,
-    phase: Phase.ACTIVE,
-
-    // vaultSeat will hold the collateral until the loan is retired. The
-    // payout from it will be handed to the user: if the vault dies early
-    // (because the vaultFactory vat died), they'll get all their
-    // collateral back. If that happens, the issuer for the Minted will be dead,
-    // so their loan will be worthless.
-    vaultSeat: zcf.makeEmptySeatKit().zcfSeat,
-
-    // Two values from the same moment
-    interestSnapshot: manager.getCompoundedInterest(),
-    debtSnapshot: AmountMath.makeEmpty(manager.getDebtBrand()),
-  });
-};
-
-/**
- * Check whether we can proceed with an `adjustBalances`.
- *
- * @param {Amount} newCollateralPre
- * @param {Amount} maxDebtPre
- * @param {Amount} newCollateral
- * @param {Amount} newDebt
- * @returns {boolean}
- */
-const checkRestart = (newCollateralPre, maxDebtPre, newCollateral, newDebt) => {
-  if (AmountMath.isGTE(newCollateralPre, newCollateral)) {
-    // The collateral did not go up. If the collateral decreased, we pro-rate maxDebt.
-    // We can pro-rate maxDebt because the quote is either linear (price is
-    // unchanging) or super-linear (also called "convex"). Super-linear is from
-    // AMMs: selling less collateral would mean an even smaller price impact, so
-    // this is a conservative choice.
-    const debtPerCollateral = makeRatioFromAmounts(
-      maxDebtPre,
-      newCollateralPre,
-    );
-    // `floorMultiply` because the debt ceiling should be tight
-    const maxDebtAfter = floorMultiplyBy(newCollateral, debtPerCollateral);
-    assert(
-      AmountMath.isGTE(maxDebtAfter, newDebt),
-      X`The requested debt ${q(
-        newDebt,
-      )} is more than the collateralization ratio allows: ${q(maxDebtAfter)}`,
-    );
-    // The `collateralAfter` can still cover the `newDebt`, so don't restart.
-    return false;
-  }
-  // The collateral went up. Restart if the debt *also* went up because
-  // the price quote might not apply at the higher numbers.
-  return !AmountMath.isGTE(maxDebtPre, newDebt);
-};
-
-const helperBehavior = {
-  // #region Computed constants
-  collateralBrand: ({ state }) => state.manager.getCollateralBrand(),
-  debtBrand: ({ state }) => state.manager.getDebtBrand(),
-
-  emptyCollateral: ({ facets }) =>
-    AmountMath.makeEmpty(facets.helper.collateralBrand()),
-  emptyDebt: ({ facets }) => AmountMath.makeEmpty(facets.helper.debtBrand()),
-  // #endregion
-
-  // #region Phase logic
-  /**
-   * @param {MethodContext} context
-   * @param {VaultPhase} newPhase
-   */
-  assignPhase: ({ state }, newPhase) => {
-    const { phase } = state;
-    const validNewPhases = validTransitions[phase];
-    validNewPhases.includes(newPhase) ||
-      assert.fail(
-        X`Vault cannot transition from ${q(phase)} to ${q(newPhase)}`,
-      );
-    state.phase = newPhase;
-  },
-
-  assertActive: ({ state }) => {
-    const { phase } = state;
-    assert(phase === Phase.ACTIVE);
-  },
-
-  assertCloseable: ({ state }) => {
-    const { phase } = state;
-    phase === Phase.ACTIVE ||
-      phase === Phase.LIQUIDATED ||
-      assert.fail(
-        X`to be closed a vault must be active or liquidated, not ${phase}`,
-      );
-  },
-  // #endregion
-
-  /**
-   * Called whenever the debt is paid or created through a transaction,
-   * but not for interest accrual.
-   *
-   * @param {MethodContext} context
-   * @param {Amount} newDebt - principal and all accrued interest
-   */
-  updateDebtSnapshot: ({ state }, newDebt) => {
-    // update local state
-    state.debtSnapshot = newDebt;
-    state.interestSnapshot = state.manager.getCompoundedInterest();
-  },
-
-  /**
-   * Update the debt balance and propagate upwards to
-   * maintain aggregate debt and liquidation order.
-   *
-   * @param {MethodContext} context
-   * @param {NormalizedDebt} oldDebtNormalized - prior principal and all accrued interest, normalized to the launch of the vaultManager
-   * @param {Amount<'nat'>} oldCollateral - actual collateral
-   * @param {Amount<'nat'>} newDebtActual - actual principal and all accrued interest
-   */
-  updateDebtAccounting: (
-    { state, facets },
-    oldDebtNormalized,
-    oldCollateral,
-    newDebtActual,
-  ) => {
-    const { helper } = facets;
-    helper.updateDebtSnapshot(newDebtActual);
-    // notify manager so it can notify and clean up as appropriate
-    state.manager.handleBalanceChange(
-      oldDebtNormalized,
-      oldCollateral,
-      state.idInManager,
-      state.phase,
-      facets.self,
-    );
-  },
-
-  /**
-   *
-   * @param {MethodContext} context
-   * @param {ZCFSeat} seat
-   */
-  getCollateralAllocated: ({ facets }, seat) =>
-    seat.getAmountAllocated('Collateral', facets.helper.collateralBrand()),
-  getMintedAllocated: ({ facets }, seat) =>
-    seat.getAmountAllocated('Minted', facets.helper.debtBrand()),
-
-  assertVaultHoldsNoMinted: ({ state, facets }) => {
-    const { vaultSeat } = state;
-    AmountMath.isEmpty(facets.helper.getMintedAllocated(vaultSeat)) ||
-      assert.fail(X`Vault should be empty of Minted`);
-  },
-
-  /**
-   *
-   * @param {MethodContext} context
-   * @param {Amount<'nat'>} collateralAmount
-   * @param {Amount<'nat'>} proposedRunDebt
-   */
-  assertSufficientCollateral: async (
-    { state, facets },
-    collateralAmount,
-    proposedRunDebt,
-  ) => {
-    const maxRun = await state.manager.maxDebtFor(collateralAmount);
-    assert(
-      AmountMath.isGTE(maxRun, proposedRunDebt, facets.helper.debtBrand()),
-      X`Requested ${q(proposedRunDebt)} exceeds max ${q(maxRun)} for ${q(
-        collateralAmount,
-      )} collateral`,
-    );
-  },
-
-  /**
-   *
-   * @param {MethodContext} context
-   * @param {HolderPhase} newPhase
-   */
-  getStateSnapshot: ({ state, facets }, newPhase) => {
-    const { debtSnapshot: debt, interestSnapshot: interest } = state;
-    /** @type {VaultNotification} */
-    return harden({
-      debtSnapshot: { debt, interest },
-      locked: facets.self.getCollateralAmount(),
-      // newPhase param is so that makeTransferInvitation can finish without setting the vault's phase
-      // TODO refactor https://github.com/Agoric/agoric-sdk/issues/4415
-      vaultState: newPhase,
-    });
-  },
-
-  /**
-   * call this whenever anything changes!
-   *
-   * @param {MethodContext} context
-   */
-  updateUiState: ({ state, facets }) => {
-    const ephemera = provideEphemera(state.idInManager);
-    const { outerUpdater } = ephemera;
-    if (!outerUpdater) {
-      // It's not an error to change to liquidating during transfer
-      return;
-    }
-    const { phase } = state;
-    const uiState = facets.helper.getStateSnapshot(phase);
-    trace('updateUiState', state.idInManager, uiState);
-
-    switch (phase) {
-      case Phase.ACTIVE:
-      case Phase.LIQUIDATING:
-      case Phase.LIQUIDATED:
-        outerUpdater.publish(uiState);
-        break;
-      case Phase.CLOSED:
-        outerUpdater.finish(uiState);
-        ephemera.outerUpdater = null;
-        break;
-      default:
-        throw Error(`unreachable vault phase: ${phase}`);
-    }
-  },
-
-  /**
-   * @param {MethodContext} context
-   * @param {ZCFSeat} seat
-   */
-  closeHook: async ({ state, facets }, seat) => {
-    const { self, helper } = facets;
-    helper.assertCloseable();
-    const { phase, vaultSeat } = state;
-    const { zcf } = provideEphemera(state.idInManager);
-
-    // Held as keys for cleanup in the manager
-    const oldDebtNormalized = self.getNormalizedDebt();
-    const oldCollateral = self.getCollateralAmount();
-
-    if (phase === Phase.ACTIVE) {
-      assertProposalShape(seat, {
-        give: { Minted: null },
+export const prepareVault = (baggage, makeRecorderKit, zcf) => {
+  const makeVaultKit = prepareVaultKit(baggage, makeRecorderKit);
+
+  const maker = prepareExoClassKit(
+    baggage,
+    'Vault',
+    {
+      helper: UnguardedHelperI,
+      self: VaultI,
+    },
+    /**
+     * @param {VaultManager} manager
+     * @param {VaultId} idInManager
+     * @param {StorageNode} storageNode
+     * @returns {ImmutableState & MutableState}
+     */
+    (manager, idInManager, storageNode) => {
+      return harden({
+        idInManager,
+        manager,
+        outerUpdater: null,
+        phase: Phase.ACTIVE,
+
+        storageNode,
+
+        // vaultSeat will hold the collateral until the position is retired. The
+        // payout from it will be handed to the user: if the vault dies early
+        // (because the vaultFactory vat died), they'll get all their
+        // collateral back. If that happens, the issuer for the Minted will be dead,
+        // so their position will be worthless.
+        vaultSeat: zcf.makeEmptySeatKit().zcfSeat,
+
+        // Two values from the same moment
+        interestSnapshot: manager.getCompoundedInterest(),
+        debtSnapshot: AmountMath.makeEmpty(manager.getDebtBrand()),
       });
-
-      // you're paying off the debt, you get everything back.
-      const debt = self.getCurrentDebt();
-      const {
-        give: { Minted: given },
-      } = seat.getProposal();
-
-      // you must pay off the entire remainder but if you offer too much, we won't
-      // take more than you owe
-      AmountMath.isGTE(given, debt) ||
-        assert.fail(
-          X`Offer ${given} is not sufficient to pay off debt ${debt}`,
-        );
-
-      // Return any overpayment
-      seat.incrementBy(vaultSeat.decrementBy(vaultSeat.getCurrentAllocation()));
-      zcf.reallocate(seat, vaultSeat);
-      state.manager.burnAndRecord(debt, seat);
-    } else if (phase === Phase.LIQUIDATED) {
-      // Simply reallocate vault assets to the offer seat.
-      // Don't take anything from the offer, even if vault is underwater.
-      // TODO verify that returning Minted here doesn't mess up debt limits
-      seat.incrementBy(vaultSeat.decrementBy(vaultSeat.getCurrentAllocation()));
-      zcf.reallocate(seat, vaultSeat);
-    } else {
-      throw new Error('only active and liquidated vaults can be closed');
-    }
-
-    seat.exit();
-    helper.assignPhase(Phase.CLOSED);
-    helper.updateDebtSnapshot(helper.emptyDebt());
-    helper.updateUiState();
-
-    helper.assertVaultHoldsNoMinted();
-    vaultSeat.exit();
-
-    state.manager.handleBalanceChange(
-      oldDebtNormalized,
-      oldCollateral,
-      state.idInManager,
-      state.phase,
-      facets.self,
-    );
-
-    return 'your loan is closed, thank you for your business';
-  },
-
-  /**
-   * Calculate the fee, the amount to mint and the resulting debt.
-   * The give and the want together reflect a delta, where typically
-   * one is zero because they come from the gave/want of an offer
-   * proposal. If the `want` is zero, the `fee` will also be zero,
-   * so the simple math works.
-   *
-   * @param {MethodContext} context
-   * @param {Amount} currentDebt
-   * @param {Amount} giveAmount
-   * @param {Amount} wantAmount
-   */
-  loanFee: ({ state }, currentDebt, giveAmount, wantAmount) => {
-    const fee = ceilMultiplyBy(
-      wantAmount,
-      state.manager.getGovernedParams().getLoanFee(),
-    );
-    const toMint = AmountMath.add(wantAmount, fee);
-    const newDebt = addSubtract(currentDebt, toMint, giveAmount);
-    return { newDebt, toMint, fee };
-  },
-
-  /**
-   * Adjust principal and collateral (atomically for offer safety)
-   *
-   * @param {MethodContext} context
-   * @param {ZCFSeat} clientSeat
-   * @returns {Promise<string>} success message
-   */
-  adjustBalancesHook: async ({ state, facets }, clientSeat) => {
-    const { self, helper } = facets;
-    const ephemera = provideEphemera(state.idInManager);
-    const { outerUpdater: updaterPre } = ephemera;
-    const { vaultSeat } = state;
-    const proposal = clientSeat.getProposal();
-    assertOnlyKeys(proposal, ['Collateral', 'Minted']);
-
-    const allEmpty = amounts => {
-      return amounts.every(a => AmountMath.isEmpty(a));
-    };
-
-    const normalizedDebtPre = self.getNormalizedDebt();
-    const collateralPre = helper.getCollateralAllocated(vaultSeat);
-
-    const giveColl = proposal.give.Collateral || helper.emptyCollateral();
-    const wantColl = proposal.want.Collateral || helper.emptyCollateral();
-
-    const newCollateralPre = addSubtract(collateralPre, giveColl, wantColl);
-    // max debt supported by current Collateral as modified by proposal
-    const maxDebtPre = await state.manager.maxDebtFor(newCollateralPre);
-    updaterPre === ephemera.outerUpdater ||
-      assert.fail(X`Transfer during vault adjustment`);
-    helper.assertActive();
-
-    // After the `await`, we retrieve the vault's allocations again,
-    // so we can compare to the debt limit based on the new values.
-    const collateral = helper.getCollateralAllocated(vaultSeat);
-    const newCollateral = addSubtract(collateral, giveColl, wantColl);
-
-    const debt = self.getCurrentDebt();
-    const giveMinted = AmountMath.min(
-      proposal.give.Minted || helper.emptyDebt(),
-      debt,
-    );
-    const wantMinted = proposal.want.Minted || helper.emptyDebt();
-    if (allEmpty([giveColl, giveMinted, wantColl, wantMinted])) {
-      clientSeat.exit();
-      return 'no transaction, as requested';
-    }
-
-    // Calculate the fee, the amount to mint and the resulting debt. We'll
-    // verify that the target debt doesn't violate the collateralization ratio,
-    // then mint, reallocate, and burn.
-    const { newDebt, fee, toMint } = helper.loanFee(
-      debt,
-      giveMinted,
-      wantMinted,
-    );
-
-    trace('adjustBalancesHook', state.idInManager, {
-      newCollateralPre,
-      newCollateral,
-      fee,
-      toMint,
-      newDebt,
-    });
-
-    if (checkRestart(newCollateralPre, maxDebtPre, newCollateral, newDebt)) {
-      return helper.adjustBalancesHook(clientSeat);
-    }
-
-    stageDelta(clientSeat, vaultSeat, giveColl, wantColl, 'Collateral');
-    // `wantMinted` is allocated in the reallocate and mint operation, and so not here
-    stageDelta(clientSeat, vaultSeat, giveMinted, helper.emptyDebt(), 'Minted');
-
-    /** @type {Array<ZCFSeat>} */
-    const vaultSeatOpt = allEmpty([giveColl, giveMinted, wantColl])
-      ? []
-      : [vaultSeat];
-    state.manager.mintAndReallocate(toMint, fee, clientSeat, ...vaultSeatOpt);
-
-    // parent needs to know about the change in debt
-    helper.updateDebtAccounting(normalizedDebtPre, collateralPre, newDebt);
-    state.manager.burnAndRecord(giveMinted, vaultSeat);
-    helper.assertVaultHoldsNoMinted();
-
-    helper.updateUiState();
-    clientSeat.exit();
-    return 'We have adjusted your balances, thank you for your business';
-  },
-
-  /**
-   *
-   * @param {MethodContext} context
-   * @param {ZCFSeat} seat
-   * @returns {VaultKit}
-   */
-  makeTransferInvitationHook: ({ state, facets }, seat) => {
-    const { self, helper } = facets;
-    helper.assertCloseable();
-    seat.exit();
-
-    const ephemera = provideEphemera(state.idInManager);
-
-    // eslint-disable-next-line no-use-before-define
-    const vaultKit = makeVaultKit(
-      self,
-      ephemera.storageNode,
-      ephemera.marshaller,
-      state.manager.getAssetSubscriber(),
-    );
-    ephemera.outerUpdater = vaultKit.vaultUpdater;
-    helper.updateUiState();
-
-    return vaultKit;
-  },
+    },
+    {
+      helper: {
+        //#region Computed constants
+        collateralBrand() {
+          return this.state.manager.getCollateralBrand();
+        },
+        debtBrand() {
+          return this.state.manager.getDebtBrand();
+        },
+
+        emptyCollateral() {
+          return AmountMath.makeEmpty(this.facets.helper.collateralBrand());
+        },
+        emptyDebt() {
+          return AmountMath.makeEmpty(this.facets.helper.debtBrand());
+        },
+        /**
+         * @typedef {{ give: { Collateral: Amount<'nat'>, Minted: Amount<'nat'> }, want: { Collateral: Amount<'nat'>, Minted: Amount<'nat'> } }} FullProposal
+         */
+        /**
+         * @param {ProposalRecord} partial
+         * @returns {FullProposal}
+         */
+        fullProposal(partial) {
+          return {
+            give: {
+              Collateral:
+                partial.give?.Collateral ||
+                this.facets.helper.emptyCollateral(),
+              Minted: partial.give?.Minted || this.facets.helper.emptyDebt(),
+            },
+            want: {
+              Collateral:
+                partial.want?.Collateral ||
+                this.facets.helper.emptyCollateral(),
+              Minted: partial.want?.Minted || this.facets.helper.emptyDebt(),
+            },
+          };
+        },
+        //#endregion
+
+        //#region Phase logic
+        /**
+         * @param {VaultPhase} newPhase
+         */
+        assignPhase(newPhase) {
+          const { state } = this;
+
+          const { phase } = state;
+          const validNewPhases = validTransitions[phase];
+          validNewPhases.includes(newPhase) ||
+            Fail`Vault cannot transition from ${q(phase)} to ${q(newPhase)}`;
+          state.phase = newPhase;
+        },
+
+        assertActive() {
+          const { phase } = this.state;
+          phase === Phase.ACTIVE || Fail`vault not active`;
+        },
+
+        assertCloseable() {
+          const { phase } = this.state;
+          phase === Phase.ACTIVE ||
+            phase === Phase.LIQUIDATED ||
+            Fail`to be closed a vault must be active or liquidated, not ${phase}`;
+        },
+        //#endregion
+
+        /**
+         * Called whenever the debt is paid or created through a transaction,
+         * but not for interest accrual.
+         *
+         * @param {Amount<'nat'>} newDebt - principal and all accrued interest
+         */
+        updateDebtSnapshot(newDebt) {
+          const { state } = this;
+
+          // update local state
+          state.debtSnapshot = newDebt;
+          state.interestSnapshot = state.manager.getCompoundedInterest();
+        },
+
+        /**
+         * Update the debt balance and propagate upwards to
+         * maintain aggregate debt and liquidation order.
+         *
+         * @param {NormalizedDebt} oldDebtNormalized - prior principal and all accrued interest, normalized to the launch of the vaultManager
+         * @param {Amount<'nat'>} oldCollateral - actual collateral
+         * @param {Amount<'nat'>} newDebtActual - actual principal and all accrued interest
+         */
+        updateDebtAccounting(oldDebtNormalized, oldCollateral, newDebtActual) {
+          const { state, facets } = this;
+          const { helper } = facets;
+          helper.updateDebtSnapshot(newDebtActual);
+          // notify manager so it can notify and clean up as appropriate
+          state.manager.handleBalanceChange(
+            oldDebtNormalized,
+            oldCollateral,
+            state.idInManager,
+            state.phase,
+            facets.self,
+          );
+        },
+
+        /**
+         *
+         * @param {ZCFSeat} seat
+         */
+        getCollateralAllocated(seat) {
+          return seat.getAmountAllocated(
+            'Collateral',
+            this.facets.helper.collateralBrand(),
+          );
+        },
+        getMintedAllocated(seat) {
+          return seat.getAmountAllocated(
+            'Minted',
+            this.facets.helper.debtBrand(),
+          );
+        },
+
+        assertVaultHoldsNoMinted() {
+          const { state, facets } = this;
+          const { vaultSeat } = state;
+          AmountMath.isEmpty(facets.helper.getMintedAllocated(vaultSeat)) ||
+            Fail`Vault should be empty of Minted`;
+        },
+
+        /**
+         *
+         * @param {Amount<'nat'>} collateralAmount
+         * @param {Amount<'nat'>} proposedDebt
+         */
+        assertSufficientCollateral(collateralAmount, proposedDebt) {
+          const { state, facets } = this;
+          const maxDebt = state.manager.maxDebtFor(collateralAmount);
+          AmountMath.isGTE(maxDebt, proposedDebt, facets.helper.debtBrand()) ||
+            Fail`Proposed debt ${q(proposedDebt)} exceeds max ${q(
+              maxDebt,
+            )} for ${q(collateralAmount)} collateral`;
+        },
+
+        /**
+         *
+         * @param {HolderPhase} newPhase
+         */
+        getStateSnapshot(newPhase) {
+          const { state, facets } = this;
+
+          const { debtSnapshot: debt, interestSnapshot: interest } = state;
+          /** @type {VaultNotification} */
+          return harden({
+            debtSnapshot: { debt, interest },
+            locked: facets.self.getCollateralAmount(),
+            // newPhase param is so that makeTransferInvitation can finish without setting the vault's phase
+            // TODO refactor https://github.com/Agoric/agoric-sdk/issues/4415
+            vaultState: newPhase,
+          });
+        },
+
+        /**
+         * call this whenever anything changes!
+         */
+        updateUiState() {
+          const { state, facets } = this;
+          const { outerUpdater } = state;
+          if (!outerUpdater) {
+            // It's not an error to change to liquidating during transfer
+            return;
+          }
+          const { phase } = state;
+          const uiState = facets.helper.getStateSnapshot(phase);
+          const brand = facets.helper.collateralBrand();
+          trace(brand, 'updateUiState', state.idInManager, uiState);
+
+          switch (phase) {
+            case Phase.ACTIVE:
+            case Phase.LIQUIDATING:
+            case Phase.LIQUIDATED:
+              void outerUpdater.write(uiState);
+              break;
+            case Phase.CLOSED:
+              void outerUpdater.writeFinal(uiState);
+              state.outerUpdater = null;
+              break;
+            default:
+              throw Error(`unreachable vault phase: ${phase}`);
+          }
+        },
+
+        /**
+         * @param {ZCFSeat} seat
+         */
+        async closeHook(seat) {
+          const { state, facets } = this;
+
+          const { self, helper } = facets;
+          helper.assertCloseable();
+          const { phase, vaultSeat } = state;
+
+          // Held as keys for cleanup in the manager
+          const oldDebtNormalized = self.getNormalizedDebt();
+          const oldCollateral = self.getCollateralAmount();
+
+          if (phase === Phase.ACTIVE) {
+            // you're paying off the debt, you get everything back.
+            const debt = self.getCurrentDebt();
+            const {
+              give: { Minted: given },
+            } = seat.getProposal();
+            given || Fail`closing an active vault requires a give`;
+
+            // you must pay off the entire remainder but if you offer too much, we won't
+            // take more than you owe
+            AmountMath.isGTE(given, debt) ||
+              Fail`Offer ${q(given)} is not sufficient to pay off debt ${q(
+                debt,
+              )}`;
+
+            // Return any overpayment
+            atomicTransfer(
+              zcf,
+              vaultSeat,
+              seat,
+              vaultSeat.getCurrentAllocation(),
+            );
+
+            state.manager.burn(debt, seat);
+          } else if (phase === Phase.LIQUIDATED) {
+            // Simply reallocate vault assets to the offer seat.
+            // Don't take anything from the offer, even if vault is underwater.
+            // TODO verify that returning Minted here doesn't mess up debt limits
+
+            atomicTransfer(
+              zcf,
+              vaultSeat,
+              seat,
+              vaultSeat.getCurrentAllocation(),
+            );
+          } else {
+            throw Error('only active and liquidated vaults can be closed');
+          }
+
+          seat.exit();
+          helper.assignPhase(Phase.CLOSED);
+          helper.updateDebtSnapshot(helper.emptyDebt());
+          helper.updateUiState();
+          helper.assertVaultHoldsNoMinted();
+          vaultSeat.exit();
+
+          state.manager.handleBalanceChange(
+            oldDebtNormalized,
+            oldCollateral,
+            state.idInManager,
+            state.phase,
+            facets.self,
+          );
+
+          return 'your vault is closed, thank you for your business';
+        },
+
+        /**
+         * Calculate the fee, the amount to mint and the resulting debt.
+         * The give and the want together reflect a delta, where typically
+         * one is zero because they come from the gave/want of an offer
+         * proposal. If the `want` is zero, the `fee` will also be zero,
+         * so the simple math works.
+         *
+         * @param {Amount<'nat'>} currentDebt
+         * @param {Amount<'nat'>} giveAmount
+         * @param {Amount<'nat'>} wantAmount
+         */
+        debtFee(currentDebt, giveAmount, wantAmount) {
+          const { state } = this;
+
+          return calculateDebtCosts(
+            currentDebt,
+            giveAmount,
+            wantAmount,
+            state.manager.getGovernedParams().getMintFee(),
+          );
+        },
+
+        /**
+         * Adjust principal and collateral (atomically for offer safety)
+         *
+         * @param {ZCFSeat} clientSeat
+         * @returns {string} success message
+         */
+        adjustBalancesHook(clientSeat) {
+          const { state, facets } = this;
+
+          const { self, helper } = facets;
+          const { vaultSeat } = state;
+          const fp = helper.fullProposal(clientSeat.getProposal());
+
+          if (
+            allEmpty([
+              fp.give.Collateral,
+              fp.give.Minted,
+              fp.want.Collateral,
+              fp.want.Minted,
+            ])
+          ) {
+            clientSeat.exit();
+            return 'no transaction, as requested';
+          }
+
+          // Calculate the fee, the amount to mint and the resulting debt. We'll
+          // verify that the target debt doesn't violate the collateralization ratio,
+          // then mint, reallocate, and burn.
+          const { newDebt, fee, surplus, toMint } = helper.debtFee(
+            self.getCurrentDebt(),
+            fp.give.Minted,
+            fp.want.Minted,
+          );
+
+          const normalizedDebtPre = self.getNormalizedDebt();
+          const collateralPre = helper.getCollateralAllocated(vaultSeat);
+
+          const hasWants = !allEmpty([fp.want.Collateral, fp.want.Minted]);
+          if (hasWants) {
+            const newCollateral = addSubtract(
+              collateralPre,
+              fp.give.Collateral,
+              fp.want.Collateral,
+            );
+            helper.assertSufficientCollateral(newCollateral, newDebt);
+          }
+
+          return helper.commitBalanceAdjustment(
+            clientSeat,
+            fp,
+            {
+              newDebt,
+              fee,
+              surplus,
+              toMint,
+            },
+            { normalizedDebtPre, collateralPre },
+          );
+        },
+
+        /**
+         *
+         * @param {ZCFSeat} clientSeat
+         * @param {FullProposal} fp
+         * @param {ReturnType<typeof calculateDebtCosts>} costs
+         * @param {object} accounting
+         * @param {NormalizedDebt} accounting.normalizedDebtPre
+         * @param {Amount<'nat'>} accounting.collateralPre
+         * @returns {string} success message
+         */
+        commitBalanceAdjustment(
+          clientSeat,
+          fp,
+          { newDebt, fee, surplus, toMint },
+          { normalizedDebtPre, collateralPre },
+        ) {
+          const { state, facets } = this;
+          const { helper } = facets;
+          const { vaultSeat } = state;
+
+          const giveMintedTaken = AmountMath.subtract(fp.give.Minted, surplus);
+
+          /** @type {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart[]} */
+          const transfers = harden([
+            [clientSeat, vaultSeat, { Collateral: fp.give.Collateral }],
+            [vaultSeat, clientSeat, { Collateral: fp.want.Collateral }],
+            [clientSeat, vaultSeat, { Minted: giveMintedTaken }],
+            // Minted into vaultSeat requires minting and so is done by mintAndTransfer
+          ]);
+
+          state.manager.mintAndTransfer(clientSeat, toMint, fee, transfers);
+
+          // parent needs to know about the change in debt
+          helper.updateDebtAccounting(
+            normalizedDebtPre,
+            collateralPre,
+            newDebt,
+          );
+          state.manager.burn(giveMintedTaken, vaultSeat);
+          helper.assertVaultHoldsNoMinted();
+
+          helper.updateUiState();
+          clientSeat.exit();
+          return 'We have adjusted your balances, thank you for your business';
+        },
+
+        /**
+         *
+         * @param {ZCFSeat} seat
+         * @returns {VaultKit}
+         */
+        makeTransferInvitationHook(seat) {
+          const { state, facets } = this;
+
+          const { self, helper } = facets;
+          helper.assertCloseable();
+          seat.exit();
+
+          // eslint-disable-next-line no-use-before-define
+          const vaultKit = makeVaultKit(self, state.storageNode);
+          state.outerUpdater = vaultKit.vaultUpdater;
+          helper.updateUiState();
+
+          return vaultKit;
+        },
+      },
+      self: {
+        getVaultSeat() {
+          return this.state.vaultSeat;
+        },
+
+        /**
+         * @param {ZCFSeat} seat
+         * @param {StorageNode} storageNode
+         */
+        async initVaultKit(seat, storageNode) {
+          const { state, facets } = this;
+
+          const { self, helper } = facets;
+
+          const normalizedDebtPre = self.getNormalizedDebt();
+          const actualDebtPre = self.getCurrentDebt();
+          (AmountMath.isEmpty(normalizedDebtPre) &&
+            AmountMath.isEmpty(actualDebtPre)) ||
+            Fail`vault must be empty initially`;
+
+          const collateralPre = self.getCollateralAmount();
+          trace('initVaultKit start: collateral', state.idInManager, {
+            actualDebtPre,
+            collateralPre,
+          });
+
+          // get the payout to provide access to the collateral if the
+          // contract abandons
+          const {
+            give: { Collateral: giveCollateral },
+            want: { Minted: wantMinted },
+          } = seat.getProposal();
+
+          const minInitialDebt = state.manager
+            .getGovernedParams()
+            .getMinInitialDebt();
+          AmountMath.isGTE(wantMinted, minInitialDebt) ||
+            Fail`Vault creation requires a minInitialDebt of ${q(
+              minInitialDebt,
+            )}`;
+
+          const {
+            newDebt: newDebtPre,
+            fee,
+            toMint,
+          } = helper.debtFee(actualDebtPre, helper.emptyDebt(), wantMinted);
+          !AmountMath.isEmpty(fee) ||
+            Fail`debt requested (${wantMinted}) too small to accrue interest`;
+          AmountMath.isEqual(newDebtPre, toMint) ||
+            Fail`fee mismatch for vault`;
+          trace(
+            'initVault',
+            state.idInManager,
+            { wantedRun: wantMinted, fee },
+            self.getCollateralAmount(),
+          );
+
+          helper.assertSufficientCollateral(giveCollateral, newDebtPre);
+
+          const { vaultSeat } = state;
+          state.manager.mintAndTransfer(
+            seat,
+            toMint,
+            fee,
+            harden([[seat, vaultSeat, { Collateral: giveCollateral }]]),
+          );
+          seat.exit();
+
+          helper.updateDebtAccounting(
+            normalizedDebtPre,
+            collateralPre,
+            newDebtPre,
+          );
+          trace('initVault updateDebtAccounting fired');
+
+          // So that makeVaultKit can be synchronous
+          const vaultKit = makeVaultKit(self, storageNode);
+          state.outerUpdater = vaultKit.vaultUpdater;
+          helper.updateUiState();
+          return vaultKit;
+        },
+
+        /**
+         * Called by manager at start of liquidation.
+         */
+        liquidating() {
+          const { facets } = this;
+
+          const { helper } = facets;
+          helper.assignPhase(Phase.LIQUIDATING);
+          helper.updateUiState();
+        },
+
+        /**
+         * Called by manager at end of liquidation, at which point all debts have been
+         * covered.
+         */
+        liquidated() {
+          const { facets } = this;
+
+          const { helper } = facets;
+          helper.updateDebtSnapshot(
+            // liquidated vaults retain no debt
+            AmountMath.makeEmpty(helper.debtBrand()),
+          );
+
+          helper.assignPhase(Phase.LIQUIDATED);
+          helper.updateUiState();
+        },
+
+        /**
+         * Called by vaultManager when the auction wasn't able to sell the
+         * collateral. The liquidation fee was charged against the collateral,
+         * but the debt will be restored and the vault will be active again.
+         * Liquidation.md has details on the liquidation approach.
+         */
+        abortLiquidation() {
+          const { state, facets } = this;
+
+          const { helper } = facets;
+
+          helper.assignPhase(Phase.ACTIVE);
+          helper.updateUiState();
+          return state.idInManager;
+        },
+
+        makeAdjustBalancesInvitation() {
+          const { state, facets } = this;
+          const { helper } = facets;
+          helper.assertActive();
+
+          return zcf.makeInvitation(
+            seat => helper.adjustBalancesHook(seat),
+            state.manager.scopeDescription('AdjustBalances'),
+            undefined,
+            M.splitRecord({
+              give: M.splitRecord(
+                {},
+                {
+                  // It may seem odd to give both at once but there is use case:
+                  // To rescue a vault that's on the verge of being liquidated
+                  // when you have limited resources, you might add collateral
+                  // at the same time that you're repaying IST.
+                  Collateral: makeNatAmountShape(helper.collateralBrand()),
+                  Minted: makeNatAmountShape(helper.debtBrand()),
+                },
+                {},
+              ),
+              want: M.splitRecord(
+                {},
+                {
+                  Collateral: makeNatAmountShape(helper.collateralBrand()),
+                  Minted: makeNatAmountShape(helper.debtBrand()),
+                },
+                {},
+              ),
+            }),
+          );
+        },
+
+        makeCloseInvitation() {
+          const { state, facets } = this;
+          const { helper } = facets;
+          helper.assertCloseable();
+          return zcf.makeInvitation(
+            seat => helper.closeHook(seat),
+            state.manager.scopeDescription('CloseVault'),
+            undefined,
+            M.splitRecord({
+              give: M.splitRecord(
+                {},
+                {
+                  Minted: makeNatAmountShape(helper.debtBrand()),
+                },
+                {},
+              ),
+              want: M.splitRecord(
+                {},
+                {
+                  Collateral: makeNatAmountShape(helper.collateralBrand()),
+                },
+                {},
+              ),
+            }),
+          );
+        },
+
+        /**
+         * @returns {Promise<Invitation>}
+         */
+        makeTransferInvitation() {
+          const { state, facets } = this;
+          const { outerUpdater } = state;
+          const { self, helper } = facets;
+          // Bring the debt snapshot current for the final report before transfer
+          helper.updateDebtSnapshot(self.getCurrentDebt());
+          const {
+            debtSnapshot: debt,
+            interestSnapshot: interest,
+            phase,
+          } = state;
+          if (outerUpdater) {
+            void outerUpdater.writeFinal(
+              helper.getStateSnapshot(Phase.TRANSFER),
+            );
+            state.outerUpdater = null;
+          }
+          const transferState = {
+            debtSnapshot: { debt, interest },
+            locked: self.getCollateralAmount(),
+            vaultState: phase,
+          };
+          return zcf.makeInvitation(
+            seat => helper.makeTransferInvitationHook(seat),
+            state.manager.scopeDescription('TransferVault'),
+            transferState,
+          );
+        },
+
+        // for status/debugging
+
+        /**
+         *
+         * @returns {Amount<'nat'>}
+         */
+        getCollateralAmount() {
+          const { state, facets } = this;
+          const { vaultSeat } = state;
+          const { helper } = facets;
+          // getCollateralAllocated would return final allocations
+          return vaultSeat.hasExited()
+            ? helper.emptyCollateral()
+            : helper.getCollateralAllocated(vaultSeat);
+        },
+
+        /**
+         * The actual current debt, including accrued interest.
+         *
+         * This looks like a simple getter but it does a lot of the heavy lifting for
+         * interest accrual. Rather than updating all records when interest accrues,
+         * the vault manager updates just its rolling compounded interest. Here we
+         * calculate what the current debt is given what's recorded in this vault and
+         * what interest has compounded since this vault record was written.
+         *
+         * @see getNormalizedDebt
+         *
+         * @returns {Amount<'nat'>}
+         */
+        getCurrentDebt() {
+          const { state } = this;
+          return calculateCurrentDebt(
+            state.debtSnapshot,
+            state.interestSnapshot,
+            state.manager.getCompoundedInterest(),
+          );
+        },
+
+        /**
+         * The normalization puts all debts on a common time-independent scale since
+         * the launch of this vault manager. This allows the manager to order vaults
+         * by their debt-to-collateral ratios without having to mutate the debts as
+         * the interest accrues.
+         *
+         * @see getActualDebAmount
+         *
+         * @returns {import('./storeUtils.js').NormalizedDebt} as if the vault was open at the launch of this manager, before any interest accrued
+         */
+        getNormalizedDebt() {
+          const { state } = this;
+          // @ts-expect-error cast
+          return reverseInterest(state.debtSnapshot, state.interestSnapshot);
+        },
+      },
+    },
+    {
+      stateShape: VaultStateShape,
+    },
+  );
+  return maker;
 };
 
-const selfBehavior = {
-  /**
-   * @param {MethodContext} context
-   */
-  getVaultSeat: ({ state }) => state.vaultSeat,
-
-  /**
-   * @param {MethodContext} context
-   * @param {ZCFSeat} seat
-   * @param {ERef<StorageNode>} storageNode
-   * @param {ERef<Marshaller>} marshaller
-   */
-  initVaultKit: async ({ state, facets }, seat, storageNode, marshaller) => {
-    assert(seat && storageNode && marshaller, 'initVaultKit missing argument');
-    const ephemera = provideEphemera(state.idInManager);
-
-    const { self, helper } = facets;
-
-    const normalizedDebtPre = self.getNormalizedDebt();
-    const actualDebtPre = self.getCurrentDebt();
-    assert(
-      AmountMath.isEmpty(normalizedDebtPre) &&
-        AmountMath.isEmpty(actualDebtPre),
-      X`vault must be empty initially`,
-    );
-
-    const collateralPre = self.getCollateralAmount();
-    trace('initVaultKit start: collateral', state.idInManager, {
-      actualDebtPre,
-      collateralPre,
-    });
-
-    // get the payout to provide access to the collateral if the
-    // contract abandons
-    const {
-      give: { Collateral: giveCollateral },
-      want: { Minted: wantMinted },
-    } = seat.getProposal();
-
-    const {
-      newDebt: newDebtPre,
-      fee,
-      toMint,
-    } = helper.loanFee(actualDebtPre, helper.emptyDebt(), wantMinted);
-    !AmountMath.isEmpty(fee) ||
-      assert.fail(
-        X`loan requested (${wantMinted}) is too small; cannot accrue interest`,
-      );
-    assert(AmountMath.isEqual(newDebtPre, toMint), X`fee mismatch for vault`);
-    trace(
-      'initVault',
-      state.idInManager,
-      { wantedRun: wantMinted, fee },
-      self.getCollateralAmount(),
-    );
-
-    await helper.assertSufficientCollateral(giveCollateral, newDebtPre);
-
-    const { vaultSeat } = state;
-    vaultSeat.incrementBy(
-      seat.decrementBy(harden({ Collateral: giveCollateral })),
-    );
-    state.manager.mintAndReallocate(toMint, fee, seat, vaultSeat);
-    helper.updateDebtAccounting(normalizedDebtPre, collateralPre, newDebtPre);
-
-    const vaultKit = makeVaultKit(
-      self,
-      storageNode,
-      marshaller,
-      state.manager.getAssetSubscriber(),
-    );
-    ephemera.outerUpdater = vaultKit.vaultUpdater;
-    helper.updateUiState();
-    return vaultKit;
-  },
-
-  /**
-   * Called by manager at start of liquidation.
-   *
-   * @param {MethodContext} context
-   */
-  liquidating: ({ facets }) => {
-    const { helper } = facets;
-    helper.assignPhase(Phase.LIQUIDATING);
-    helper.updateUiState();
-  },
-
-  /**
-   * Called by manager at end of liquidation, at which point all debts have been
-   * covered.
-   *
-   * @param {MethodContext} context
-   */
-  liquidated: ({ facets }) => {
-    const { helper } = facets;
-    helper.updateDebtSnapshot(
-      // liquidated vaults retain no debt
-      AmountMath.makeEmpty(helper.debtBrand()),
-    );
-
-    helper.assignPhase(Phase.LIQUIDATED);
-    helper.updateUiState();
-  },
-
-  /**
-   * @param {MethodContext} context
-   */
-  makeAdjustBalancesInvitation: ({ state, facets }) => {
-    const { helper } = facets;
-    helper.assertActive();
-    const { zcf } = provideEphemera(state.idInManager);
-    return zcf.makeInvitation(
-      seat => helper.adjustBalancesHook(seat),
-      'AdjustBalances',
-    );
-  },
-
-  /**
-   * @param {MethodContext} context
-   */
-  makeCloseInvitation: ({ state, facets }) => {
-    const { helper } = facets;
-    helper.assertCloseable();
-    const { zcf } = provideEphemera(state.idInManager);
-    return zcf.makeInvitation(seat => helper.closeHook(seat), 'CloseVault');
-  },
-
-  /**
-   * @param {MethodContext} context
-   * @returns {Promise<Invitation>}
-   */
-  makeTransferInvitation: ({ state, facets }) => {
-    const ephemera = provideEphemera(state.idInManager);
-    const { outerUpdater } = ephemera;
-    const { self, helper } = facets;
-    // Bring the debt snapshot current for the final report before transfer
-    helper.updateDebtSnapshot(self.getCurrentDebt());
-    const { debtSnapshot: debt, interestSnapshot: interest, phase } = state;
-    if (outerUpdater) {
-      outerUpdater.finish(helper.getStateSnapshot(Phase.TRANSFER));
-      ephemera.outerUpdater = null;
-    }
-    const transferState = {
-      debtSnapshot: { debt, interest },
-      locked: self.getCollateralAmount(),
-      vaultState: phase,
-    };
-    const { zcf } = provideEphemera(state.idInManager);
-    return zcf.makeInvitation(
-      seat => helper.makeTransferInvitationHook(seat),
-      'TransferVault',
-      transferState,
-    );
-  },
-
-  // for status/debugging
-
-  /**
-   *
-   * @param {MethodContext} context
-   * @returns {Amount<'nat'>}
-   */
-  getCollateralAmount: ({ state, facets }) => {
-    const { vaultSeat } = state;
-    const { helper } = facets;
-    // getCollateralAllocated would return final allocations
-    return vaultSeat.hasExited()
-      ? helper.emptyCollateral()
-      : helper.getCollateralAllocated(vaultSeat);
-  },
-
-  /**
-   * The actual current debt, including accrued interest.
-   *
-   * This looks like a simple getter but it does a lot of the heavy lifting for
-   * interest accrual. Rather than updating all records when interest accrues,
-   * the vault manager updates just its rolling compounded interest. Here we
-   * calculate what the current debt is given what's recorded in this vault and
-   * what interest has compounded since this vault record was written.
-   *
-   * @see getNormalizedDebt
-   *
-   * @param {MethodContext} context
-   * @returns {Amount<'nat'>}
-   */
-  getCurrentDebt: ({ state }) => {
-    return calculateCurrentDebt(
-      state.debtSnapshot,
-      state.interestSnapshot,
-      state.manager.getCompoundedInterest(),
-    );
-  },
-
-  /**
-   * The normalization puts all debts on a common time-independent scale since
-   * the launch of this vault manager. This allows the manager to order vaults
-   * by their debt-to-collateral ratios without having to mutate the debts as
-   * the interest accrues.
-   *
-   * @see getActualDebAmount
-   *
-   * @param {MethodContext} context
-   * @returns {import('./storeUtils.js').NormalizedDebt} as if the vault was open at the launch of this manager, before any interest accrued
-   */
-  getNormalizedDebt: ({ state }) => {
-    // @ts-expect-error cast
-    return reverseInterest(state.debtSnapshot, state.interestSnapshot);
-  },
-};
-
-const makeVaultBase = defineDurableKindMulti(
-  makeKindHandle('Vault'),
-  initState,
-  {
-    self: selfBehavior,
-    helper: helperBehavior,
-  },
-);
-
-/**
- * @param {ZCF} zcf
- * @param {VaultManager} manager
- * @param {VaultId} idInManager
- */
-export const makeVault = pickFacet(makeVaultBase, 'self');
-
-/** @typedef {ReturnType<typeof makeVault>} Vault */
+/** @typedef {ReturnType<ReturnType<typeof prepareVault>>['self']} Vault */