@agoric/inter-protocol 0.16.2-upgrade-14-dev-0169c7e.0 → 0.16.2-upgrade-16-dev-8879538.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"prioritizedVaults.d.ts","sourceRoot":"","sources":["prioritizedVaults.js"],"names":[],"mappings":"AAuCO;;uBAgHiigB,OAAO,eAA0B,WAAW;;;;;;;;;YA3DllgB;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAJH;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;KA3DQ,KAAK,CAMf;AASI;;;;;;;;;;;YAwCL;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAJH;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;wBAOQ,OAAO;;2BAgDohgB,OAAO,eAA0B,WAAW;;;;;;;;;gBA3DllgB;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;mEArBQ,MAAM,CAAC,KAAK,CAAC,WACb,MAAM;wBAlBJ,KAAK,GAAG,SAAS;uBA0BnB,MAAM;;;;;;;;;;;gBAQjB;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;sEAFQ,MAAM,CAAC,KAAK,CAAC,WACb,MAAM;;;;;;;;;;;gBAHjB;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAOQ,OAAO;;;;;;;;;;;gBAXlB;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;mEArBQ,MAAM,CAAC,KAAK,CAAC,WACb,MAAM;wBAlBJ,KAAK,GAAG,SAAS;uBA0BnB,MAAM;;;;;;;;;;;gBAQjB;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;sEAFQ,MAAM,CAAC,KAAK,CAAC,WACb,MAAM;;;;;;;;;;;gBAHjB;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAJH;;;;mBAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDJ;oCAtIiC,iBAAiB"}

package/src/vaultFactory/prioritizedVaults.js

@@ -13,8 +13,8 @@ import {
   normalizedCollRatio,
 } from './storeUtils.js';
 
-/** @typedef {import('./vault').Vault} Vault */
-/** @typedef {import('./storeUtils.js').NormalizedDebt} NormalizedDebt */
+/** @import {Vault} from './vault.js' */
+/** @import {NormalizedDebt} from './storeUtils.js' */
 
 const trace = makeTracer('PVaults', true);
 
@@ -47,8 +47,8 @@ export const currentDebtToCollateral = vault =>
  * Vaults, ordered by their debt ratio so that all the vaults below a threshold
  * can be quickly found and liquidated.
  *
- * @param {MapStore<string, Vault>} store
- * vault has a higher debt ratio than the previous highest
+ * @param {MapStore<string, Vault>} store vault has a higher debt ratio than the
+ *   previous highest
  */
 export const makePrioritizedVaults = store => {
   const vaults = makeOrderedVaultStore(store);

package/src/vaultFactory/proceeds.d.ts

@@ -0,0 +1,35 @@
+export function calculateDistributionPlan({ proceeds, totalDebt, totalCollateral, oraclePriceAtStart, vaultsBalances, penaltyRate, }: {
+    proceeds: AmountKeywordRecord;
+    totalDebt: Amount<"nat">;
+    totalCollateral: Amount<"nat">;
+    oraclePriceAtStart: PriceDescription;
+    vaultsBalances: VaultBalances[];
+    penaltyRate: Ratio;
+}): DistributionPlan;
+/**
+ * The plan to execute for distributing proceeds of a liquidation.
+ *
+ * Vaults are referenced by index in the list sent to the calculator.
+ */
+export type DistributionPlan = {
+    overage: Amount<"nat">;
+    shortfallToReserve: Amount<"nat">;
+    collateralForReserve: Amount<"nat">;
+    actualCollateralSold: Amount<"nat">;
+    collateralSold: Amount<"nat">;
+    collatRemaining: Amount<"nat">;
+    debtToBurn: Amount<"nat">;
+    mintedForReserve: Amount<"nat">;
+    mintedProceeds: Amount<"nat">;
+    phantomDebt: Amount<"nat">;
+    totalPenalty: Amount<"nat">;
+    transfersToVault: [number, AmountKeywordRecord][];
+    vaultsToReinstate: number[];
+};
+export type VaultBalances = {
+    collateral: Amount<"nat">;
+    presaleDebt: Amount<"nat">;
+    currentDebt: Amount<"nat">;
+};
+import type { PriceDescription } from '@agoric/zoe/tools/types.js';
+//# sourceMappingURL=proceeds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proceeds.d.ts","sourceRoot":"","sources":["proceeds.js"],"names":[],"mappings":"AA4DO;cATI,mBAAmB;eACnB,MAAM,CAAC,KAAK,CAAC;qBACb,MAAM,CAAC,KAAK,CAAC;;oBAEb,aAAa,EAAE;iBAEf,KAAK;IACH,gBAAgB,CA8N5B;;;;;;+BA1QY;IACZ,OAAW,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3B,kBAAsB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACtC,oBAAwB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACxC,oBAAwB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACxC,cAAkB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAClC,eAAmB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACnC,UAAc,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9B,gBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACpC,cAAkB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAClC,WAAe,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/B,YAAgB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAChC,gBAAoB,EAAE,CAAC,MAAM,EAAE,mBAAmB,CAAC,EAAE,CAAC;IACtD,iBAAqB,EAAE,MAAM,EAAE,CAAC;CAC7B;4BAOS;IACZ,UAAc,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9B,WAAe,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/B,WAAe,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;CAC5B;sCA5B0F,4BAA4B"}

package/src/vaultFactory/proceeds.js

@@ -9,29 +9,36 @@ import {
 import { quoteAsRatio, subtractToEmpty } from '../contractSupport.js';
 import { liquidationResults } from './liquidation.js';
 
+/** @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js'; */
+
 /**
  * @typedef {{
- *   overage: Amount<'nat'>,
- *   shortfallToReserve: Amount<'nat'>,
- *   collateralForReserve: Amount<'nat'>,
- *   actualCollateralSold: Amount<'nat'>,
- *   collateralSold: Amount<'nat'>,
- *   collatRemaining: Amount<'nat'>,
- *   debtToBurn: Amount<'nat'>,
- *   mintedForReserve: Amount<'nat'>,
- *   mintedProceeds: Amount<'nat'>,
- *   phantomDebt: Amount<'nat'>,
- *   totalPenalty: Amount<'nat'>,
- *   transfersToVault: Array<[number, AmountKeywordRecord]>,
- *   vaultsToReinstate: Array<number>
+ *   overage: Amount<'nat'>;
+ *   shortfallToReserve: Amount<'nat'>;
+ *   collateralForReserve: Amount<'nat'>;
+ *   actualCollateralSold: Amount<'nat'>;
+ *   collateralSold: Amount<'nat'>;
+ *   collatRemaining: Amount<'nat'>;
+ *   debtToBurn: Amount<'nat'>;
+ *   mintedForReserve: Amount<'nat'>;
+ *   mintedProceeds: Amount<'nat'>;
+ *   phantomDebt: Amount<'nat'>;
+ *   totalPenalty: Amount<'nat'>;
+ *   transfersToVault: [number, AmountKeywordRecord][];
+ *   vaultsToReinstate: number[];
  * }} DistributionPlan
+ *   The plan to execute for distributing proceeds of a liquidation.
  *
- * The plan to execute for distributing proceeds of a liquidation.
- *
- * Vaults are referenced by index in the list sent to the calculator.
+ *   Vaults are referenced by index in the list sent to the calculator.
  */
 
-/** @typedef {{ collateral: Amount<'nat'>, presaleDebt:  Amount<'nat'>, currentDebt: Amount<'nat'> }} VaultBalances */
+/**
+ * @typedef {{
+ *   collateral: Amount<'nat'>;
+ *   presaleDebt: Amount<'nat'>;
+ *   currentDebt: Amount<'nat'>;
+ * }} VaultBalances
+ */
 
 /**
  * Liquidation.md describes how to process liquidation proceeds.
@@ -46,7 +53,8 @@ import { liquidationResults } from './liquidation.js';
  * @param {Amount<'nat'>} inputs.totalDebt
  * @param {Amount<'nat'>} inputs.totalCollateral
  * @param {PriceDescription} inputs.oraclePriceAtStart
- * @param {Array<VaultBalances>} inputs.vaultsBalances ordered best to worst collateralized
+ * @param {VaultBalances[]} inputs.vaultsBalances ordered best to worst
+ *   collateralized
  * @param {Ratio} inputs.penaltyRate
  * @returns {DistributionPlan}
  */

package/src/vaultFactory/storeUtils.d.ts

@@ -0,0 +1,25 @@
+/** @import {PureData} from '@endo/marshal' */
+/** @typedef {[normalizedCollateralization: number, vaultId: VaultId]} CompositeKey */
+/**
+ * @param {PureData} key
+ * @returns {string}
+ */
+export const encodeData: (p: import("@endo/marshal").Passable) => string;
+/**
+ * @param {string} encoded
+ * @returns {PureData}
+ */
+export const decodeData: (encoded: string, skip?: number | undefined) => import("@endo/marshal").Passable;
+export function toVaultKey(normalizedDebt: NormalizedDebt, collateral: Amount<"nat">, vaultId: VaultId): string;
+export function fromVaultKey(key: string): [normalizedCollateralization: number, vaultId: VaultId];
+export function normalizedCollRatio(quote: PriceQuote, compoundedInterest: Ratio, margin: Ratio): number;
+export function normalizedCollRatioKey(quote: PriceQuote, compoundedInterest: Ratio, margin: Ratio): string;
+export type CompositeKey = [normalizedCollateralization: number, vaultId: VaultId];
+export type NormalizedDebt = Amount<"nat"> & {
+    normalized: true;
+};
+export type ActualDebt = Amount<"nat"> & {
+    normalized: false;
+};
+import type { PriceQuote } from '@agoric/zoe/tools/types.js';
+//# sourceMappingURL=storeUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storeUtils.d.ts","sourceRoot":"","sources":["storeUtils.js"],"names":[],"mappings":"AAuBA,8CAA8C;AAE9C,sFAAsF;AAOtF;;;GAGG;AACH,yEAA+C;AAO/C;;;GAGG;AACH,kDAkDmD,kBAClD,sCAnD8C;AAkDxC,2CANI,cAAc,cACd,MAAM,CAAC,KAAK,CAAC,WACb,OAAO,GACL,MAAM,CAelB;AAOM,kCAHI,MAAM,GACJ,CAAC,2BAA2B,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAKnE;AAgBM,2EAJI,KAAK,UACL,KAAK,GACH,MAAM,CAiBlB;AAcM,8EALI,KAAK,UACL,KAAK,GACH,MAAM,CAMlB;2BA9Ia,CAAC,2BAA2B,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;6BA4CvD,MAAM,CAAC,KAAK,CAAC,GAAG;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE;yBACpC,MAAM,CAAC,KAAK,CAAC,GAAG;IAAE,UAAU,EAAE,KAAK,CAAA;CAAE;gCA/D2C,4BAA4B"}

package/src/vaultFactory/storeUtils.js

@@ -5,6 +5,8 @@
  * API supports them.
  */
 
+/** @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js'; */
+
 // XXX importing these that are declared to be used only for testing
 // until @agoric/store supports composite keys
 import { makeDecodePassable, makeEncodePassable } from '@endo/marshal';
@@ -19,13 +21,9 @@ const { multiply } = natSafeMath;
 
 const trace = makeTracer('Store', true);
 
-/**
- * @typedef {import('@endo/marshal').PureData} PureData
- */
+/** @import {PureData} from '@endo/marshal' */
 
-/**
- * @typedef {[normalizedCollateralization: number, vaultId: VaultId]} CompositeKey
- */
+/** @typedef {[normalizedCollateralization: number, vaultId: VaultId]} CompositeKey */
 
 // `makeEncodePassable` has three named options:
 // `encodeRemotable`, `encodeError`, and `encodePromise`.
@@ -69,12 +67,12 @@ const decodeNumber = encoded => {
 };
 
 // Type annotations to support static testing of amount values
-/** @typedef {Amount<'nat'> & {normalized: true}} NormalizedDebt */
-/** @typedef {Amount<'nat'> & {normalized: false}} ActualDebt */
+/** @typedef {Amount<'nat'> & { normalized: true }} NormalizedDebt */
+/** @typedef {Amount<'nat'> & { normalized: false }} ActualDebt */
 
 /**
- * Overcollateralized are greater than one.
- * The more undercollaterized the smaller in [0-1].
+ * Overcollateralized are greater than one. The more undercollaterized the
+ * smaller in [0-1].
  *
  * @param {NormalizedDebt} normalizedDebt normalized (not actual) total debt
  * @param {Amount<'nat'>} collateral
@@ -95,7 +93,7 @@ const collateralizationRatio = (normalizedDebt, collateral) => {
  * @param {Amount<'nat'>} collateral
  * @param {VaultId} vaultId
  * @returns {string} lexically sortable string in which highest
- * debt-to-collateral is earliest
+ *   debt-to-collateral is earliest
  */
 export const toVaultKey = (normalizedDebt, collateral, vaultId) => {
   assert(normalizedDebt);
@@ -162,7 +160,7 @@ harden(normalizedCollRatio);
  * @param {Ratio} compoundedInterest
  * @param {Ratio} margin
  * @returns {string} lexically sortable string in which highest
- * debt-to-collateral is earliest
+ *   debt-to-collateral is earliest
  */
 export const normalizedCollRatioKey = (quote, compoundedInterest, margin) => {
   const collRatio = normalizedCollRatio(quote, compoundedInterest, margin);

package/src/vaultFactory/types-ambient.d.ts

@@ -0,0 +1,234 @@
+type VaultFactoryPublicFacet = import("./vaultFactory.js").VaultFactoryContract["publicFacet"];
+type AutoswapLocal = {
+    getInputPrice: (amount: Amount, brand: Brand) => Amount;
+    makeSwapInvitation: () => Invitation;
+};
+type VaultManagerParamValues = {
+    /**
+     * - margin below which collateral will be
+     * liquidated to satisfy the debt.
+     */
+    liquidationMargin: Ratio;
+    /**
+     * - penalty charged upon liquidation as
+     * proportion of debt
+     */
+    liquidationPenalty: Ratio;
+    /**
+     * - annual interest rate charged on debt
+     * positions
+     */
+    interestRate: Ratio;
+    /**
+     * - The fee (in BasisPoints) charged when creating or
+     * increasing a debt position.
+     */
+    mintFee: Ratio;
+    debtLimit: Amount<"nat">;
+    /**
+     * - vault must maintain this in order to
+     * remove collateral or add debt
+     */
+    liquidationPadding?: Ratio | undefined;
+};
+type AddVaultType = (collateralIssuer: Issuer, collateralKeyword: Keyword, params: VaultManagerParamValues) => Promise<import("@endo/exo").Guarded<{
+    getGovernedParams(): import("./vaultManager.js").GovernedParamGetters;
+    makeVaultKit(seat: ZCFSeat): 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>;
+    }>;
+    getCollateralQuote(): import("@agoric/zoe/tools/types.js").PriceQuote;
+    getPublicFacet(): import("@endo/exo").Guarded<{
+        makeVaultInvitation(): Promise<Invitation<{
+            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>;
+        }, undefined>>;
+        getQuotes(): import("@agoric/notifier").StoredNotifier<import("@agoric/zoe/tools/types.js").PriceQuote>;
+        getCompoundedInterest(): Ratio;
+        getPublicTopics(): {
+            asset: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").AssetState>;
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").MetricsNotification>;
+        };
+    }>;
+    lockOraclePrices(): import("@agoric/zoe/tools/types.js").PriceQuote;
+    liquidateVaults(auctionPF: globalThis.ERef<globalThis.GovernedPublicFacet<{
+        getElectorate: () => import("@agoric/ertp/src/types.js").SetAmount<import("@endo/patterns").Key>;
+        getStartFrequency: () => RelativeTime;
+        getClockStep: () => RelativeTime;
+        getStartingRate: () => bigint;
+        getLowestRate: () => bigint;
+        getDiscountStep: () => bigint;
+        getAuctionStartDelay: () => RelativeTime;
+        getPriceLockPeriod: () => RelativeTime;
+        makeBidInvitation(collateralBrand: Brand<"nat">): Promise<Invitation<string, import("../auction/auctionBook.js").OfferSpec>>;
+        getSchedules(): {
+            liveAuctionSchedule: import("../auction/scheduler.js").Schedule | null;
+            nextAuctionSchedule: import("../auction/scheduler.js").Schedule | null;
+        };
+        getScheduleUpdates(): globalThis.Subscriber<import("../auction/scheduler.js").ScheduleNotification>;
+        getBookDataUpdates(brand: any): globalThis.Subscriber<import("../auction/auctionBook.js").BookDataNotification>;
+        getPublicTopics(brand: any): {
+            bookData: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../auction/auctionBook.js").BookDataNotification>;
+        } | {
+            schedule: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../auction/scheduler.js").ScheduleNotification>;
+        };
+        makeDepositInvitation: () => Promise<Invitation<string, {
+            goal: import("@agoric/ertp/src/types.js").NatAmount;
+        }>>;
+    }>>): Promise<void>;
+}>>;
+type VaultFactoryCreatorFacet = {
+    addVaultType: AddVaultType;
+    getRewardAllocation: () => Allocation;
+    makeCollectFeesInvitation: () => Promise<Invitation<string, never>>;
+    makeLiquidationWaker: () => import("@agoric/time").TimerWaker;
+    makePriceLockWaker: () => import("@agoric/time").TimerWaker;
+};
+/**
+ * Mint new debt `toMint` and transfer the `fee`
+ *   portion to the vaultFactory's reward pool. Then reallocate over all the
+ *   seat arguments and the rewardPoolSeat. Update the `totalDebt` if the
+ *   reallocate succeeds.
+ */
+type MintAndTransfer = (mintReceiver: ZCFSeat, toMint: Amount<"nat">, fee: Amount<"nat">, transfers: TransferPart[]) => void;
+/**
+ * Burn debt tokens off a seat and update the `totalDebt` if
+ *   the reallocate succeeds.
+ */
+type BurnDebt = (toBurn: Amount, fromSeat: ZCFSeat) => void;
+type GetVaultParams = {
+    getLiquidationMargin: () => Ratio;
+    getMintFee: () => Ratio;
+    getCollateralQuote: () => Promise<import("@agoric/zoe/tools/types.js").PriceQuote>;
+    /**
+     * - The annual interest rate on a debt
+     * position
+     */
+    getInterestRate: () => Ratio;
+    /**
+     * - The period (in seconds) at
+     * which interest is charged to the debt position.
+     */
+    getChargingPeriod: () => RelativeTime;
+    /**
+     * - The period (in seconds)
+     * at which interest is recorded to the debt position.
+     */
+    getRecordingPeriod: () => RelativeTime;
+};
+type VaultId = string;
+type InterestTiming = {
+    /**
+     * in seconds
+     */
+    chargingPeriod: RelativeTime;
+    /**
+     * in seconds
+     */
+    recordingPeriod: RelativeTime;
+};
+type LiquidationStrategy = {
+    keywordMapping: () => KeywordKeywordRecord;
+    makeProposal: (collateral: Amount, run: Amount) => Proposal;
+    makeInvitation: (debt: Amount) => Promise<Invitation>;
+};
+type Liquidator = {
+    makeLiquidateInvitation: () => Promise<Invitation<void, {
+        debt: Amount<"nat">;
+        penaltyRate: Ratio;
+    }>>;
+};
+type DebtStatus = {
+    latestInterestUpdate: Timestamp;
+    /**
+     * interest accrued since latestInterestUpdate
+     */
+    interest: NatValue;
+    /**
+     * total including principal and interest
+     */
+    newDebt: NatValue;
+};
+type Calculate = (debtStatus: DebtStatus, currentTime: Timestamp) => DebtStatus;
+type CalculatorKit = {
+    /**
+     * calculate new debt for charging periods up to
+     * the present.
+     */
+    calculate: Calculate;
+    /**
+     * calculate new debt for
+     * reporting periods up to the present. If some charging periods have elapsed
+     * that don't constitute whole reporting periods, the time is not updated past
+     * them and interest is not accumulated for them.
+     */
+    calculateReportingPeriod: Calculate;
+};
+type VaultFactoryParamPath = {
+    key: "governedParams" | {
+        collateralBrand: Brand;
+    };
+};
+import type { VaultNotification } from './vault.js';
+import type { Vault } from './vault.js';
+import type { VaultKit } from './vaultKit.js';
+import type { VaultManager } from './vaultManager.js';
+import type { CollateralManager } from './vaultManager.js';
+import type { AssetReserveLimitedCreatorFacet } from '../reserve/assetReserve.js';
+import type { AssetReservePublicFacet } from '../reserve/assetReserve.js';
+import type { AuctioneerPublicFacet } from '../auction/auctioneer.js';
+import type { Timestamp } from '@agoric/time';
+import type { RelativeTime } from '@agoric/time';
+//# sourceMappingURL=types-ambient.d.ts.map

package/src/vaultFactory/types-ambient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-ambient.d.ts","sourceRoot":"","sources":["types-ambient.js"],"names":[],"mappings":"+BAGa,OAAO,mBAAmB,EAAE,oBAAoB,CAAC,aAAa,CAAC;;mBAe9D,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,MAAM;wBACxC,MAAM,UAAU;;;;;;;uBAKhB,KAAK;;;;;wBAEL,KAAK;;;;;kBAEL,KAAK;;;;;aAEL,KAAK;eAEL,MAAM,CAAC,KAAK,CAAC;;;;;;;uCAOhB,MAAM,qBACN,OAAO,UACP,uBAAuB;;uBA6Fg38B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAApqa,MAAM,KAAK,CAAC;;;;;;;;;;;;;;;;;;kBAvFnviB,YAAY;yBACZ,MAAM,UAAU;+BAChB,MAAM,OAAO,CAAC,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;0BACxC,MAAM,OAAO,cAAc,EAAE,UAAU;wBACvC,MAAM,OAAO,cAAc,EAAE,UAAU;;;;;;;;sCAQ1C,OAAO,UACP,MAAM,CAAC,KAAK,CAAC,OACb,MAAM,CAAC,KAAK,CAAC,aACb,YAAY,EAAE,KACZ,IAAI;;;;;yBAMN,MAAM,YACN,OAAO,KACL,IAAI;;0BAKH,MAAM,KAAK;gBACX,MAAM,KAAK;wBACX,MAAM,OAAO,CAAC,OAAO,4BAA4B,EAAE,UAAU,CAAC;;;;;qBAC9D,MAAM,KAAK;;;;;;;;;;;;eAQX,MAAM;;;;;;;;;;;;oBAUN,MAAM,oBAAoB;kBAC1B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,QAAQ;oBAC7C,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC;;;6BAKrC,MAAM,OAAO,CAC1B,UAAc,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAA;KAAE,CAAC,CAC9D;;;;;;;cAMU,QAAQ;;;;aACR,QAAQ;;8BAKX,UAAU,6BAER,UAAU;;;;;;eAKT,SAAS;;;;;;;8BAET,SAAS;;6BAMT;IAAE,GAAG,EAAE,gBAAgB,GAAG;QAAE,eAAe,EAAE,KAAK,CAAA;KAAE,CAAA;CAAE;uCAjIhC,YAAY;2BACxB,YAAY;8BACT,eAAe;kCACX,mBAAmB;uCACd,mBAAmB;qDACL,4BAA4B;6CACpC,4BAA4B;2CAC9B,0BAA0B;+BACtC,cAAc;kCACX,cAAc"}

package/src/vaultFactory/{types.js → types-ambient.js}

@@ -1,22 +1,21 @@
 // @jessie-check
 
 /**
- * @typedef {import('./vault').VaultNotification} VaultNotification
- * @typedef {import('./vault').Vault} Vault
- * @typedef {import('./vaultKit').VaultKit} VaultKit
- * @typedef {import('./vaultManager').VaultManager} VaultManager
- * @typedef {import('./vaultManager').CollateralManager} CollateralManager
- * @typedef {import('../reserve/assetReserve.js').AssetReserveLimitedCreatorFacet} AssetReserveCreatorFacet
- * @typedef {import('../reserve/assetReserve.js').AssetReservePublicFacet} AssetReservePublicFacet
- * @typedef {import('../auction/auctioneer.js').AuctioneerPublicFacet} AuctioneerPublicFacet
  * @typedef {import('./vaultFactory.js').VaultFactoryContract['publicFacet']} VaultFactoryPublicFacet
- *
- * @typedef {import('@agoric/time/src/types').Timestamp} Timestamp
- * @typedef {import('@agoric/time/src/types').RelativeTime} RelativeTime
+ * @import {VaultNotification} from './vault.js'
+ * @import {Vault} from './vault.js'
+ * @import {VaultKit} from './vaultKit.js'
+ * @import {VaultManager} from './vaultManager.js'
+ * @import {CollateralManager} from './vaultManager.js'
+ * @import {AssetReserveLimitedCreatorFacet} from '../reserve/assetReserve.js'
+ * @import {AssetReservePublicFacet} from '../reserve/assetReserve.js'
+ * @import {AuctioneerPublicFacet} from '../auction/auctioneer.js'
+ * @import {Timestamp} from '@agoric/time'
+ * @import {RelativeTime} from '@agoric/time'
  */
 
 /**
- * @typedef  {object} AutoswapLocal
+ * @typedef {object} AutoswapLocal
  * @property {(amount: Amount, brand: Brand) => Amount} getInputPrice
  * @property {() => Invitation} makeSwapInvitation
  */
@@ -24,13 +23,16 @@
 /**
  * @typedef {object} VaultManagerParamValues
  * @property {Ratio} liquidationMargin - margin below which collateral will be
- * liquidated to satisfy the debt.
- * @property {Ratio} liquidationPenalty - penalty charged upon liquidation as proportion of debt
- * @property {Ratio} interestRate - annual interest rate charged on debt positions
- * @property {Ratio} mintFee - The fee (in BasisPoints) charged when creating
- * or increasing a debt position.
+ *   liquidated to satisfy the debt.
+ * @property {Ratio} liquidationPenalty - penalty charged upon liquidation as
+ *   proportion of debt
+ * @property {Ratio} interestRate - annual interest rate charged on debt
+ *   positions
+ * @property {Ratio} mintFee - The fee (in BasisPoints) charged when creating or
+ *   increasing a debt position.
  * @property {Amount<'nat'>} debtLimit
- * @property {Ratio} [liquidationPadding] - vault must maintain this in order to remove collateral or add debt
+ * @property {Ratio} [liquidationPadding] - vault must maintain this in order to
+ *   remove collateral or add debt
  */
 
 /**
@@ -42,32 +44,29 @@
  */
 
 /**
- * @typedef  {object} VaultFactoryCreatorFacet
+ * @typedef {object} VaultFactoryCreatorFacet
  * @property {AddVaultType} addVaultType
  * @property {() => Allocation} getRewardAllocation
  * @property {() => Promise<Invitation<string, never>>} makeCollectFeesInvitation
- * @property {() => import('@agoric/time/src/types').TimerWaker} makeLiquidationWaker
- * @property {() => import('@agoric/time/src/types').TimerWaker} makePriceLockWaker
+ * @property {() => import('@agoric/time').TimerWaker} makeLiquidationWaker
+ * @property {() => import('@agoric/time').TimerWaker} makePriceLockWaker
  */
 
 /**
- * @callback MintAndTransfer
- * Mint new debt `toMint` and transfer the `fee` portion to the vaultFactory's reward
- * pool. Then reallocate over all the seat arguments and the rewardPoolSeat. Update
- * the `totalDebt` if the reallocate succeeds.
+ * @callback MintAndTransfer Mint new debt `toMint` and transfer the `fee`
+ *   portion to the vaultFactory's reward pool. Then reallocate over all the
+ *   seat arguments and the rewardPoolSeat. Update the `totalDebt` if the
+ *   reallocate succeeds.
  * @param {ZCFSeat} mintReceiver
  * @param {Amount<'nat'>} toMint
  * @param {Amount<'nat'>} fee
- * @param {import('@agoric/zoe/src/contractSupport/atomicTransfer.js').TransferPart[]} transfers
+ * @param {TransferPart[]} transfers
  * @returns {void}
  */
 
 /**
- * @callback BurnDebt
- *
- * Burn debt tokens off a seat and update
- * the `totalDebt` if the reallocate succeeds.
- *
+ * @callback BurnDebt Burn debt tokens off a seat and update the `totalDebt` if
+ *   the reallocate succeeds.
  * @param {Amount} toBurn
  * @param {ZCFSeat} fromSeat
  * @returns {void}
@@ -77,17 +76,16 @@
  * @typedef {object} GetVaultParams
  * @property {() => Ratio} getLiquidationMargin
  * @property {() => Ratio} getMintFee
- * @property {() => Promise<PriceQuote>} getCollateralQuote
- * @property {() => Ratio} getInterestRate - The annual interest rate on a debt position
+ * @property {() => Promise<import('@agoric/zoe/tools/types.js').PriceQuote>} getCollateralQuote
+ * @property {() => Ratio} getInterestRate - The annual interest rate on a debt
+ *   position
  * @property {() => RelativeTime} getChargingPeriod - The period (in seconds) at
  *   which interest is charged to the debt position.
  * @property {() => RelativeTime} getRecordingPeriod - The period (in seconds)
  *   at which interest is recorded to the debt position.
  */
 
-/**
- * @typedef {string} VaultId
- */
+/** @typedef {string} VaultId */
 
 /**
  * @typedef {object} InterestTiming
@@ -104,7 +102,9 @@
 
 /**
  * @typedef {object} Liquidator
- * @property {() => Promise<Invitation<void, { debt: Amount<'nat'>; penaltyRate: Ratio; }>>} makeLiquidateInvitation
+ * @property {() => Promise<
+ *   Invitation<void, { debt: Amount<'nat'>; penaltyRate: Ratio }>
+ * >} makeLiquidateInvitation
  */
 
 /**
@@ -124,11 +124,11 @@
 /**
  * @typedef {object} CalculatorKit
  * @property {Calculate} calculate calculate new debt for charging periods up to
- * the present.
+ *   the present.
  * @property {Calculate} calculateReportingPeriod calculate new debt for
- * reporting periods up to the present. If some charging periods have elapsed
- * that don't constitute whole reporting periods, the time is not updated past
- * them and interest is not accumulated for them.
+ *   reporting periods up to the present. If some charging periods have elapsed
+ *   that don't constitute whole reporting periods, the time is not updated past
+ *   them and interest is not accumulated for them.
  */
 
-/** @typedef {{key: 'governedParams' | {collateralBrand: Brand}}} VaultFactoryParamPath */
+/** @typedef {{ key: 'governedParams' | { collateralBrand: Brand } }} VaultFactoryParamPath */