@agoric/inter-protocol 0.16.1 → 0.16.2-calypso-dev-84eb287.0

package/src/vaultFactory/liquidation.js

@@ -13,16 +13,18 @@ import { makeCancelTokenMaker } from '../auction/util.js';
 
 const trace = makeTracer('LIQ');
 
-/** @typedef {import('@agoric/time/src/types').TimerService} TimerService */
-/** @typedef {import('@agoric/time/src/types').TimerWaker} TimerWaker */
-/** @typedef {import('@agoric/time/src/types').CancelToken} CancelToken */
-/** @typedef {import('@agoric/time/src/types').RelativeTimeRecord} RelativeTimeRecord */
+/** @import {TimerService} from '@agoric/time' */
+/** @import {TimerWaker} from '@agoric/time' */
+/** @import {CancelToken} from '@agoric/time' */
+/** @import {RelativeTimeRecord} from '@agoric/time' */
+/** @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js'; */
 
 const makeCancelToken = makeCancelTokenMaker('liq');
 
 /**
  * This will normally be set. If the schedule goes sideways, we'll unschedule
- * all events and unset it. When auction params are changed, we'll restart the schedule
+ * all events and unset it. When auction params are changed, we'll restart the
+ * schedule
  *
  * @type {object | undefined}
  */
@@ -47,15 +49,16 @@ const cancelWakeups = timer => {
 };
 
 /**
- * Schedule wakeups for the *next* auction round.
+ * Schedule wakeups for the _next_ auction round.
  *
- * In practice, there are these cases to handle (with N as "live" and N+1 is "next"):
+ * In practice, there are these cases to handle (with N as "live" and N+1 is
+ * "next"):
  *
- * | when (now within the range)      | what                                    |
- * | -------------------------------- | --------------------------------------- |
- * | [start N, nominalStart N+1]      | good: schedule normally the three wakers|
- * | (nominalStart N+1, endTime N+1]  | recover: skip round N+1 and schedule N+2|
- * | (endTime N+1, ∞)                 | give up: wait for repair by governance  |
+ * | when (now within the range)     | what                                     |
+ * | ------------------------------- | ---------------------------------------- |
+ * | [start N, nominalStart N+1]     | good: schedule normally the three wakers |
+ * | (nominalStart N+1, endTime N+1] | recover: skip round N+1 and schedule N+2 |
+ * | (endTime N+1, ∞)                | give up: wait for repair by governance   |
  *
  * @param {object} opts
  * @param {ERef<TimerService>} opts.timer
@@ -63,7 +66,7 @@ const cancelWakeups = timer => {
  * @param {TimerWaker} opts.liquidationWaker
  * @param {TimerWaker} opts.reschedulerWaker
  * @param {import('../auction/scheduler.js').Schedule} opts.nextAuctionSchedule
- * @param {import('@agoric/time/src/types').TimestampRecord} opts.now
+ * @param {import('@agoric/time').TimestampRecord} opts.now
  * @param {ParamStateRecord} opts.params
  * @returns {void}
  */
@@ -132,7 +135,7 @@ const setWakeups = ({
 };
 
 /**
- * Schedule wakeups for the *next* auction round.
+ * Schedule wakeups for the _next_ auction round.
  *
  * Called by vaultDirector's resetWakeupsForNextAuction at start() and every
  * time there's a "reschedule" wakeup.
@@ -185,7 +188,7 @@ harden(setWakeupsForNextAuction);
 /**
  * @param {Amount<'nat'>} debt
  * @param {Amount<'nat'>} minted
- * @returns {{ overage: Amount<'nat'>, shortfall: Amount<'nat'>}}
+ * @returns {{ overage: Amount<'nat'>; shortfall: Amount<'nat'> }}
  */
 export const liquidationResults = (debt, minted) => {
   if (AmountMath.isEmpty(minted)) {
@@ -240,15 +243,21 @@ export const watchForGovernanceChange = (
  * @param {PriceQuote} collateralizationDetails.quote
  * @param {Ratio} collateralizationDetails.interest
  * @param {Ratio} collateralizationDetails.margin
- * @param {ReturnType<typeof import('./prioritizedVaults.js').makePrioritizedVaults>} prioritizedVaults
+ * @param {ReturnType<
+ *   typeof import('./prioritizedVaults.js').makePrioritizedVaults
+ * >} prioritizedVaults
  * @param {SetStore<Vault>} liquidatingVaults
  * @param {Brand<'nat'>} debtBrand
  * @param {Brand<'nat'>} collateralBrand
  * @returns {{
- *    vaultData: MapStore<Vault, { collateralAmount: Amount<'nat'>, debtAmount:  Amount<'nat'>}>,
- *    totalDebt: Amount<'nat'>,
- *    totalCollateral: Amount<'nat'>,
- *    liqSeat: ZCFSeat}}
+ *   vaultData: MapStore<
+ *     Vault,
+ *     { collateralAmount: Amount<'nat'>; debtAmount: Amount<'nat'> }
+ *   >;
+ *   totalDebt: Amount<'nat'>;
+ *   totalCollateral: Amount<'nat'>;
+ *   liqSeat: ZCFSeat;
+ * }}
  */
 export const getLiquidatableVaults = (
   zcf,
@@ -261,13 +270,18 @@ export const getLiquidatableVaults = (
   const vaultsToLiquidate = prioritizedVaults.removeVaultsBelow(
     collateralizationDetails,
   );
-  /** @type {MapStore<Vault, { collateralAmount: Amount<'nat'>, debtAmount:  Amount<'nat'>}>} */
+  /**
+   * @type {MapStore<
+   *   Vault,
+   *   { collateralAmount: Amount<'nat'>; debtAmount: Amount<'nat'> }
+   * >}
+   */
   const vaultData = makeScalarMapStore();
 
   const { zcfSeat: liqSeat } = zcf.makeEmptySeatKit();
   let totalDebt = AmountMath.makeEmpty(debtBrand);
   let totalCollateral = AmountMath.makeEmpty(collateralBrand);
-  /** @type {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart[]} */
+  /** @type {TransferPart[]} */
   const transfers = [];
 
   for (const vault of vaultsToLiquidate.values()) {

package/src/vaultFactory/math.d.ts

@@ -0,0 +1,11 @@
+export function calculateMinimumCollateralization(liquidationMargin: Ratio, liquidationPadding: Ratio): Ratio;
+export function minimumPrice(quoteA: PriceQuote, quoteB?: PriceQuote | undefined): Ratio;
+export function maxDebtForVault(quoteAmount: PriceQuote, liquidationMargin: Ratio, liquidationPadding: Ratio): Amount<"nat">;
+export function calculateDebtCosts(currentDebt: Amount<"nat">, give: Amount<"nat">, want: Amount<"nat">, debtFee: Ratio): {
+    newDebt: import("@agoric/ertp/src/types.js").NatAmount;
+    toMint: import("@agoric/ertp/src/types.js").NatAmount;
+    fee: import("@agoric/ertp/src/types.js").NatAmount;
+    surplus: import("@agoric/ertp/src/types.js").NatAmount;
+};
+import type { PriceQuote } from '@agoric/zoe/tools/types.js';
+//# sourceMappingURL=math.d.ts.map

package/src/vaultFactory/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["math.js"],"names":[],"mappings":"AA4BO,qEAJI,KAAK,sBACL,KAAK,GACH,KAAK,CAKmC;AAS9C,qCAJI,UAAU,oCAER,KAAK,CAajB;AAYM,6CALI,UAAU,qBACV,KAAK,sBACL,KAAK,GACH,MAAM,CAAC,KAAK,CAAC,CAczB;AAaM,gDALI,MAAM,CAAC,KAAK,CAAC,QACb,MAAM,CAAC,KAAK,CAAC,QACb,MAAM,CAAC,KAAK,CAAC,WACb,KAAK;;;;;EASf;gCA7E6F,4BAA4B"}

package/src/vaultFactory/math.js

@@ -1,8 +1,8 @@
 // @jessie-check
 
 /**
- * @file calculations specific to the Vault Factory contract
- * See also ../interest-math.js
+ * @file calculations specific to the Vault Factory contract See also
+ *   ../interest-math.js
  */
 
 import { AmountMath } from '@agoric/ertp';
@@ -16,9 +16,11 @@ import {
 import { priceFrom } from '../auction/util.js';
 import { addSubtract } from '../contractSupport.js';
 
+/** @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js'; */
+
 /**
- * Calculate the minimum collateralization given the liquidation margin and the "padding"
- * from that liquidation threshold.
+ * Calculate the minimum collateralization given the liquidation margin and the
+ * "padding" from that liquidation threshold.
  *
  * @param {Ratio} liquidationMargin
  * @param {Ratio} liquidationPadding
@@ -74,11 +76,10 @@ export const maxDebtForVault = (
 };
 
 /**
- * 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.
+ * 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'>} give excess of currentDebt is returned in 'surplus'

package/src/vaultFactory/orderedVaultStore.d.ts

@@ -0,0 +1,93 @@
+export function makeOrderedVaultStore(store: MapStore<string, Vault>): {
+    addVault: (vaultId: string, vault: Vault) => string;
+    removeByKey: (key: string) => Vault;
+    has: (key: string) => boolean;
+    keys: (keyPatt?: globalThis.Pattern, valuePatt?: globalThis.Pattern) => Iterable<string>;
+    entries: (keyPatt?: globalThis.Pattern, valuePatt?: globalThis.Pattern) => Iterable<[string, import("@endo/exo").Guarded<{
+        getVaultSeat(): ZCFSeat;
+        initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                AdjustBalances(): Promise<Invitation<string, undefined>>;
+                CloseVault(): Promise<Invitation<string, undefined>>;
+                TransferVault(): Promise<Invitation<any, undefined>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                getCollateralAmount(): import("@agoric/ertp/src/types.js").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp/src/types.js").NatAmount;
+                getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<Invitation<VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>]>;
+    getSize: (keyPatt?: globalThis.Pattern, valuePatt?: globalThis.Pattern) => number;
+    values: (keyPatt?: globalThis.Pattern, valuePatt?: globalThis.Pattern) => Iterable<import("@endo/exo").Guarded<{
+        getVaultSeat(): ZCFSeat;
+        initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                AdjustBalances(): Promise<Invitation<string, undefined>>;
+                CloseVault(): Promise<Invitation<string, undefined>>;
+                TransferVault(): Promise<Invitation<any, undefined>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                getCollateralAmount(): import("@agoric/ertp/src/types.js").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp/src/types.js").NatAmount;
+                getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<Invitation<VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>>;
+};
+import type { Vault } from './vault.js';
+//# sourceMappingURL=orderedVaultStore.d.ts.map

package/src/vaultFactory/orderedVaultStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orderedVaultStore.d.ts","sourceRoot":"","sources":["orderedVaultStore.js"],"names":[],"mappings":"AAiBO,6CADK,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;wBAGtB,MAAM,SACN,KAAK;uBAWL,MAAM,KACJ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAkCgu1B,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EADpw1B;2BApDwB,YAAY"}

package/src/vaultFactory/orderedVaultStore.js

@@ -3,22 +3,20 @@ import { fromVaultKey, toVaultKey } from './storeUtils.js';
 /**
  * Used by prioritizedVaults to wrap the Collections API for this use case.
  *
- * Designed to be replaceable by naked Collections API when composite keys are available.
+ * Designed to be replaceable by naked Collections API when composite keys are
+ * available.
  *
- * In this module debts are encoded as the inverse quotient (collateral over debt) so that
- * greater collateralization sorts after lower. (Higher debt-to-collateral come
- * first.)
+ * In this module debts are encoded as the inverse quotient (collateral over
+ * debt) so that greater collateralization sorts after lower. (Higher
+ * debt-to-collateral come first.)
  */
 
-/** @typedef {import('./vault').Vault} Vault */
-/** @typedef {import('./storeUtils').CompositeKey} CompositeKey */
+/** @import {Vault} from './vault.js' */
+/** @import {CompositeKey} from './storeUtils.js' */
 
-/**
- * @param {MapStore<string, Vault>} store
- */
+/** @param {MapStore<string, Vault>} store */
 export const makeOrderedVaultStore = store => {
   /**
-   *
    * @param {string} vaultId
    * @param {Vault} vault
    */
@@ -31,7 +29,6 @@ export const makeOrderedVaultStore = store => {
   };
 
   /**
-   *
    * @param {string} key
    * @returns {Vault}
    */

package/src/vaultFactory/params.d.ts

@@ -0,0 +1,140 @@
+/** @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js'; */
+export const CHARGING_PERIOD_KEY: "ChargingPeriod";
+export const RECORDING_PERIOD_KEY: "RecordingPeriod";
+export const DEBT_LIMIT_KEY: "DebtLimit";
+export const LIQUIDATION_MARGIN_KEY: "LiquidationMargin";
+export const LIQUIDATION_PADDING_KEY: "LiquidationPadding";
+export const LIQUIDATION_PENALTY_KEY: "LiquidationPenalty";
+export const INTEREST_RATE_KEY: "InterestRate";
+export const MINT_FEE_KEY: "MintFee";
+export const MIN_INITIAL_DEBT_KEY: "MinInitialDebt";
+export const SHORTFALL_INVITATION_KEY: "ShortfallInvitation";
+export const REFERENCED_UI_KEY: "ReferencedUI";
+export namespace vaultDirectorParamTypes {
+    let MinInitialDebt: "amount";
+    let ChargingPeriod: "nat";
+    let RecordingPeriod: "nat";
+    let ReferencedUI: "string";
+}
+export function makeVaultParamManager(publisherKit: import("@agoric/notifier").StoredPublisherKit<GovernanceSubscriptionState>, { debtLimit, interestRate, liquidationMargin, liquidationPadding, liquidationPenalty, mintFee, }: VaultManagerParamValues): import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+    DebtLimit: "amount";
+    InterestRate: "ratio";
+    LiquidationPadding: "ratio";
+    LiquidationMargin: "ratio";
+    LiquidationPenalty: "ratio";
+    MintFee: "ratio";
+}>;
+/** @typedef {ReturnType<typeof makeVaultParamManager>} VaultParamManager */
+export const vaultParamPattern: import("@endo/patterns").Matcher;
+export function makeGovernedTerms({ bootstrapPaymentValue, electorateInvitationAmount, interestTiming, minInitialDebt, priceAuthority, reservePublicFacet, timer, shortfallInvitationAmount, referencedUi, }: {
+    electorateInvitationAmount: Amount<"set">;
+    minInitialDebt: Amount<"nat">;
+    bootstrapPaymentValue: bigint;
+    priceAuthority: ERef<PriceAuthority>;
+    timer: ERef<import("@agoric/time").TimerService>;
+    reservePublicFacet: AssetReservePublicFacet;
+    interestTiming: InterestTiming;
+    shortfallInvitationAmount: Amount<"set">;
+    referencedUi?: string;
+}): {
+    priceAuthority: globalThis.ERef<PriceAuthority>;
+    reservePublicFacet: globalThis.GovernedPublicFacet<import("@endo/exo").Guarded<{
+        makeAddCollateralInvitation(): Promise<Invitation<string, never>>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../reserve/assetReserveKit.js").MetricsNotification>;
+        };
+    }>>;
+    timerService: globalThis.ERef<import("@agoric/time").TimerService>;
+    governedParams: {
+        Electorate: {
+            type: "invitation";
+            value: import("@agoric/ertp/src/types.js").SetAmount<import("@endo/patterns").Key>;
+        };
+        MinInitialDebt: {
+            type: "amount";
+            value: import("@agoric/ertp/src/types.js").NatAmount;
+        };
+        ShortfallInvitation: {
+            type: "invitation";
+            value: import("@agoric/ertp/src/types.js").SetAmount<import("@endo/patterns").Key>;
+        };
+        ReferencedUI: {
+            type: "string";
+            value: string;
+        };
+        ChargingPeriod: {
+            type: "nat";
+            value: bigint;
+        };
+        RecordingPeriod: {
+            type: "nat";
+            value: bigint;
+        };
+    };
+    bootstrapPaymentValue: bigint;
+};
+export function provideVaultParamManagers(baggage: import("@agoric/vat-data").Baggage, marshaller: ERef<Marshaller>, managerParamOverrides: Record<string, VaultManagerParamOverrides>): {
+    /**
+     * @param {Brand} brand
+     * @param {StorageNode} storageNode
+     * @param {VaultManagerParamValues} initialParamValues
+     */
+    addParamManager(brand: Brand, storageNode: StorageNode, initialParamValues: VaultManagerParamValues): import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+        DebtLimit: "amount";
+        InterestRate: "ratio";
+        LiquidationPadding: "ratio";
+        LiquidationMargin: "ratio";
+        LiquidationPenalty: "ratio";
+        MintFee: "ratio";
+    }>;
+    /** @param {Brand} brand */
+    get(brand: Brand): import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+        DebtLimit: "amount";
+        InterestRate: "ratio";
+        LiquidationPadding: "ratio";
+        LiquidationMargin: "ratio";
+        LiquidationPenalty: "ratio";
+        MintFee: "ratio";
+    }>;
+};
+export type VaultDirectorParams = import("@agoric/governance/src/contractGovernance/typedParamManager.js").ParamTypesMapFromRecord<ReturnType<typeof makeVaultDirectorParams>>;
+export type VaultParamManager = ReturnType<typeof makeVaultParamManager>;
+export type VaultManagerParamOverrides = VaultManagerParamValues & {
+    brand: Brand;
+};
+import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
+/**
+ * @param {Amount<'set'>} electorateInvitationAmount
+ * @param {Amount<'nat'>} minInitialDebt
+ * @param {Amount<'set'>} shortfallInvitationAmount
+ * @param {string} referencedUi
+ * @param {InterestTiming} interestTiming
+ */
+declare function makeVaultDirectorParams(electorateInvitationAmount: Amount<"set">, minInitialDebt: Amount<"nat">, shortfallInvitationAmount: Amount<"set">, referencedUi: string, interestTiming: InterestTiming): {
+    Electorate: {
+        type: "invitation";
+        value: import("@agoric/ertp/src/types.js").SetAmount<import("@endo/patterns").Key>;
+    };
+    MinInitialDebt: {
+        type: "amount";
+        value: import("@agoric/ertp/src/types.js").NatAmount;
+    };
+    ShortfallInvitation: {
+        type: "invitation";
+        value: import("@agoric/ertp/src/types.js").SetAmount<import("@endo/patterns").Key>;
+    };
+    ReferencedUI: {
+        type: "string";
+        value: string;
+    };
+    ChargingPeriod: {
+        type: "nat";
+        value: bigint;
+    };
+    RecordingPeriod: {
+        type: "nat";
+        value: bigint;
+    };
+};
+export {};
+//# sourceMappingURL=params.d.ts.map

package/src/vaultFactory/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["params.js"],"names":[],"mappings":"AAiBA,8HAA8H;AAE9H,mDAAoD;AACpD,qDAAsD;AAEtD,yCAA0C;AAC1C,yDAA0D;AAC1D,2DAA4D;AAC5D,2DAA4D;AAC5D,+CAAgD;AAChD,qCAAsC;AACtC,oDAAqD;AACrD,6DAA8D;AAC9D,+CAAgD;;;;;;;AAkEzC,oDAHI,OAAO,kBAAkB,EAAE,kBAAkB,CAAC,2BAA2B,CAAC,oGAC1E,uBAAuB;;;;;;;GAoB9B;AACJ,4EAA4E;AAE5E,iEAYE;AAeK,8MAZI;IACV,0BAA8B,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9C,cAAkB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAClC,qBAAyB,EAAE,MAAM,CAAC;IAClC,cAAkB,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IACzC,KAAS,EAAE,IAAI,CAAC,OAAO,cAAc,EAAE,YAAY,CAAC,CAAC;IACrD,kBAAsB,EAAE,uBAAuB,CAAC;IAChD,cAAkB,EAAE,cAAc,CAAC;IACnC,yBAA6B,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7C,YAAgB,CAAC,EAAE,MAAM,CAAC;CACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BH;AAeM,mDAJI,OAAO,kBAAkB,EAAE,OAAO,cAClC,IAAI,CAAC,UAAU,CAAC,yBAChB,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC;IA+CjD;;;;OAIG;2BAHQ,KAAK,eACL,WAAW,sBACX,uBAAuB;;;;;;;;IAOlC,2BAA2B;eAAf,KAAK;;;;;;;;EAKpB;kCAhKY,OAAO,gEAAgE,EAAE,uBAAuB,CAC5G,UAAgB,CAAC,OAAO,uBAAuB,CAAC,CAC3C;gCA8BQ,UAAU,CAAC,OAAO,qBAAqB,CAAC;yCAwDxC,uBAAuB,GAAG;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE;oCA1JsC,4BAA4B;AAyB1H;;;;;;GAMG;AACH,qEANW,MAAM,CAAC,KAAK,CAAC,kBACb,MAAM,CAAC,KAAK,CAAC,6BACb,MAAM,CAAC,KAAK,CAAC,gBACb,MAAM,kBACN,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;EAgCxB"}

package/src/vaultFactory/params.js

@@ -1,6 +1,6 @@
 // @jessie-check
 
-import './types.js';
+/// <reference path="./types-ambient.js" />
 
 import {
   CONTRACT_ELECTORATE,
@@ -12,8 +12,11 @@ import { M, makeScalarMapStore } from '@agoric/store';
 import { TimeMath } from '@agoric/time';
 import { provideDurableMapStore } from '@agoric/vat-data';
 import { subtractRatios } from '@agoric/zoe/src/contractSupport/ratio.js';
+import { makeTracer } from '@agoric/internal/src/index.js';
 import { amountPattern, ratioPattern } from '../contractSupport.js';
 
+/** @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js'; */
+
 export const CHARGING_PERIOD_KEY = 'ChargingPeriod';
 export const RECORDING_PERIOD_KEY = 'RecordingPeriod';
 
@@ -35,6 +38,8 @@ export const vaultDirectorParamTypes = {
 };
 harden(vaultDirectorParamTypes);
 
+const trace = makeTracer('Vault Params');
+
 /**
  * @param {Amount<'set'>} electorateInvitationAmount
  * @param {Amount<'nat'>} minInitialDebt
@@ -75,7 +80,11 @@ const makeVaultDirectorParams = (
 };
 harden(makeVaultDirectorParams);
 
-/** @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager').ParamTypesMapFromRecord<ReturnType<typeof makeVaultDirectorParams>>} VaultDirectorParams */
+/**
+ * @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager.js').ParamTypesMapFromRecord<
+ *     ReturnType<typeof makeVaultDirectorParams>
+ *   >} VaultDirectorParams
+ */
 
 /** @type {(liquidationMargin: Ratio) => Ratio} */
 const zeroRatio = liquidationMargin =>
@@ -122,20 +131,18 @@ export const vaultParamPattern = M.splitRecord(
 
 /**
  * @param {{
- *   auctioneerPublicFacet: ERef<AuctioneerPublicFacet>,
- *   electorateInvitationAmount: Amount<'set'>,
- *   minInitialDebt: Amount<'nat'>,
- *   bootstrapPaymentValue: bigint,
- *   priceAuthority: ERef<PriceAuthority>,
- *   timer: ERef<import('@agoric/time/src/types').TimerService>,
- *   reservePublicFacet: AssetReservePublicFacet,
- *   interestTiming: InterestTiming,
- *   shortfallInvitationAmount: Amount<'set'>,
- *   referencedUi?: string,
+ *   electorateInvitationAmount: Amount<'set'>;
+ *   minInitialDebt: Amount<'nat'>;
+ *   bootstrapPaymentValue: bigint;
+ *   priceAuthority: ERef<PriceAuthority>;
+ *   timer: ERef<import('@agoric/time').TimerService>;
+ *   reservePublicFacet: AssetReservePublicFacet;
+ *   interestTiming: InterestTiming;
+ *   shortfallInvitationAmount: Amount<'set'>;
+ *   referencedUi?: string;
  * }} opts
  */
 export const makeGovernedTerms = ({
-  auctioneerPublicFacet,
   bootstrapPaymentValue,
   electorateInvitationAmount,
   interestTiming,
@@ -147,7 +154,6 @@ export const makeGovernedTerms = ({
   referencedUi = 'NO REFERENCE',
 }) => {
   return harden({
-    auctioneerPublicFacet,
     priceAuthority,
     reservePublicFacet,
     timerService: timer,
@@ -162,21 +168,34 @@ export const makeGovernedTerms = ({
   });
 };
 harden(makeGovernedTerms);
+
+/** @typedef {VaultManagerParamValues & { brand: Brand }} VaultManagerParamOverrides */
+
 /**
- * Stop-gap which restores initial param values
- * UNTIL https://github.com/Agoric/agoric-sdk/issues/5200
+ * Stop-gap which restores initial param values UNTIL
+ * https://github.com/Agoric/agoric-sdk/issues/5200
  *
  * NB: changes from initial values will be lost upon restart
  *
  * @param {import('@agoric/vat-data').Baggage} baggage
  * @param {ERef<Marshaller>} marshaller
+ * @param {Record<string, VaultManagerParamOverrides>} managerParamOverrides
  */
-export const provideVaultParamManagers = (baggage, marshaller) => {
+export const provideVaultParamManagers = (
+  baggage,
+  marshaller,
+  managerParamOverrides,
+) => {
   /** @type {MapStore<Brand, VaultParamManager>} */
   const managers = makeScalarMapStore();
 
   // the managers aren't durable but their arguments are
-  /** @type {MapStore<Brand, {storageNode: StorageNode, initialParamValues: VaultManagerParamValues}>} */
+  /**
+   * @type {MapStore<
+   *   Brand,
+   *   { storageNode: StorageNode; initialParamValues: VaultManagerParamValues }
+   * >}
+   */
   const managerArgs = provideDurableMapStore(
     baggage,
     'vault param manager parts',
@@ -191,12 +210,23 @@ export const provideVaultParamManagers = (baggage, marshaller) => {
     return manager;
   };
 
-  // restore from baggage
-  [...managerArgs.entries()].map(([brand, args]) => makeManager(brand, args));
+  // restore from baggage, unless `managerParamOverrides` overrides.
+  for (const [brand, args] of managerArgs.entries()) {
+    const newInitial = managerParamOverrides
+      ? Object.values(managerParamOverrides).find(e => e.brand === brand)
+      : undefined;
+
+    if (newInitial) {
+      trace(`reviving params, override`, brand, newInitial);
+      makeManager(brand, { ...args, initialParamValues: newInitial });
+    } else {
+      trace(`reviving params, keeping`, brand, args.initialParamValues);
+      makeManager(brand, args);
+    }
+  }
 
   return {
     /**
-     *
      * @param {Brand} brand
      * @param {StorageNode} storageNode
      * @param {VaultManagerParamValues} initialParamValues
@@ -206,9 +236,7 @@ export const provideVaultParamManagers = (baggage, marshaller) => {
       managerArgs.init(brand, args);
       return makeManager(brand, args);
     },
-    /**
-     * @param {Brand} brand
-     */
+    /** @param {Brand} brand */
     get(brand) {
       return managers.get(brand);
     },