@agoric/inter-protocol 0.16.2-other-dev-8f8782b.0 → 0.16.2-other-dev-fbe72e7.0.fbe72e7

package/src/vaultFactory/prioritizedVaults.d.ts

@@ -0,0 +1,280 @@
+export function currentDebtToCollateral(vault: Vault): Ratio;
+export function makePrioritizedVaults(store: MapStore<string, Vault>): {
+    addVault: (vaultId: VaultId, vault: Vault) => string;
+    entries: (keyPatt?: Pattern, valuePatt?: Pattern) => Iterable<[string, import("@endo/exo").Guarded<{
+        getVaultSeat(): globalThis.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<globalThis.Invitation<string, undefined>>;
+                CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+                TransferVault(): Promise<globalThis.Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<globalThis.Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<Invitation<VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>]>;
+    getCount: (keyPatt?: Pattern, valuePatt?: Pattern) => number;
+    hasVaultByAttributes: (oldDebt: NormalizedDebt, oldCollateral: Amount<"nat">, vaultId: string) => boolean;
+    highestRatio: () => Ratio | undefined;
+    removeVault: (key: string) => Vault;
+    removeVaultByAttributes: (oldDebt: NormalizedDebt, oldCollateral: Amount<"nat">, vaultId: string) => import("@endo/exo").Guarded<{
+        getVaultSeat(): globalThis.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<globalThis.Invitation<string, undefined>>;
+                CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+                TransferVault(): Promise<globalThis.Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<globalThis.Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<Invitation<VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>;
+    removeVaultsBelow: ({ margin, quote, interest }: {
+        margin: any;
+        quote: any;
+        interest: any;
+    }) => MapStore<string, import("@endo/exo").Guarded<{
+        getVaultSeat(): globalThis.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<globalThis.Invitation<string, undefined>>;
+                CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+                TransferVault(): Promise<globalThis.Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<globalThis.Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<Invitation<VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>>;
+    countVaultsBelow: (crKey: any) => number;
+} & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+    addVault: (vaultId: VaultId, vault: Vault) => string;
+    entries: (keyPatt?: Pattern, valuePatt?: Pattern) => Iterable<[string, import("@endo/exo").Guarded<{
+        getVaultSeat(): globalThis.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<globalThis.Invitation<string, undefined>>;
+                CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+                TransferVault(): Promise<globalThis.Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<globalThis.Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<Invitation<VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>]>;
+    getCount: (keyPatt?: Pattern, valuePatt?: Pattern) => number;
+    hasVaultByAttributes: (oldDebt: NormalizedDebt, oldCollateral: Amount<"nat">, vaultId: string) => boolean;
+    highestRatio: () => Ratio | undefined;
+    removeVault: (key: string) => Vault;
+    removeVaultByAttributes: (oldDebt: NormalizedDebt, oldCollateral: Amount<"nat">, vaultId: string) => import("@endo/exo").Guarded<{
+        getVaultSeat(): globalThis.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<globalThis.Invitation<string, undefined>>;
+                CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+                TransferVault(): Promise<globalThis.Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<globalThis.Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<Invitation<VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>;
+    removeVaultsBelow: ({ margin, quote, interest }: {
+        margin: any;
+        quote: any;
+        interest: any;
+    }) => MapStore<string, import("@endo/exo").Guarded<{
+        getVaultSeat(): globalThis.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<globalThis.Invitation<string, undefined>>;
+                CloseVault(): Promise<globalThis.Invitation<string, undefined>>;
+                TransferVault(): Promise<globalThis.Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<globalThis.Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<globalThis.Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<Invitation<VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>>;
+    countVaultsBelow: (crKey: any) => number;
+}>;
+import type { Vault } from './vault.js';
+import type { MapStore } from '@agoric/store';
+import type { NormalizedDebt } from './storeUtils.js';
+//# sourceMappingURL=prioritizedVaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prioritizedVaults.d.ts","sourceRoot":"","sources":["prioritizedVaults.js"],"names":[],"mappings":"AA0CO,+CAHI,KAAK,GACH,KAAK,CAMf;AASI,6CAHI,SAAS,MAAM,EAAE,KAAK,CAAC;wBAsDrB,OAAO,SACP,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA9BL,cAAc,iBACd,MAAM,CAAC,KAAK,CAAC,WACb,MAAM;wBAlBJ,KAAK,GAAG,SAAS;uBA0BnB,MAAM,KACJ,KAAK;uCAQP,cAAc,iBACd,MAAM,CAAC,KAAK,CAAC,WACb,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAQN,OAAO,SACP,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA9BL,cAAc,iBACd,MAAM,CAAC,KAAK,CAAC,WACb,MAAM;wBAlBJ,KAAK,GAAG,SAAS;uBA0BnB,MAAM,KACJ,KAAK;uCAQP,cAAc,iBACd,MAAM,CAAC,KAAK,CAAC,WACb,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDlB;2BAxIuB,YAAY;8BADT,eAAe;oCAET,iBAAiB"}

package/src/vaultFactory/prioritizedVaults.js

@@ -13,8 +13,11 @@ import {
   normalizedCollRatio,
 } from './storeUtils.js';
 
-/** @typedef {import('./vault').Vault} Vault */
-/** @typedef {import('./storeUtils.js').NormalizedDebt} NormalizedDebt */
+/**
+ * @import {MapStore} from '@agoric/store';
+ * @import {Vault} from './vault.js';
+ * @import {NormalizedDebt} from './storeUtils.js';
+ */
 
 const trace = makeTracer('PVaults', true);
 
@@ -47,8 +50,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,sIATJ;IAAoC,QAAQ,EAApC,mBAAmB;IACG,SAAS,EAA/B,MAAM,CAAC,KAAK,CAAC;IACS,eAAe,EAArC,MAAM,CAAC,KAAK,CAAC;IACY,kBAAkB,EAA3C,gBAAgB;IACQ,cAAc,EAAtC,aAAa,EAAE;IAED,WAAW,EAAzB,KAAK;CACb,GAAU,gBAAgB,CA8N5B;;;;;;+BA1QY;IACR,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAClC,oBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACpC,oBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACpC,cAAc,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9B,eAAe,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC5B,gBAAgB,EAAE,CAAC,MAAM,EAAE,mBAAmB,CAAC,EAAE,CAAC;IAClD,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B;4BAOS;IACR,UAAU,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IAC3B,WAAW,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: Passable) => string;
+/**
+ * @param {string} encoded
+ * @returns {PureData}
+ */
+export const decodeData: (encoded: string, skip?: number) => 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,iDAA+C;AAO/C;;;GAGG;AACH,sEAA+C;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,2CALI,UAAU,sBACV,KAAK,UACL,KAAK,GACH,MAAM,CAiBlB;AAcM,8CANI,UAAU,sBACV,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,137 @@
+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<VaultManager>;
+type VaultFactoryCreatorFacet = {
+    addVaultType: AddVaultType;
+    getRewardAllocation: () => import("@agoric/zoe").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) => import("@agoric/zoe").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,KACrB,OAAO,CAAC,YAAY,CAAC;;kBAKpB,YAAY;yBACZ,MAAM,OAAO,aAAa,EAAE,UAAU;+BACtC,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;;;;;uBAEX,MAAM,YAAY;;;;;wBAElB,MAAM,YAAY;;eAIlB,MAAM;;;;;oBAIN,YAAY;;;;qBACZ,YAAY;;;oBAKZ,MAAM,oBAAoB;kBAC1B,CACT,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,KACR,OAAO,aAAa,EAAE,QAAQ;oBACxB,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,CAAC;;;6BAKrC,MAAM,OAAO,CACtB,UAAU,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAA;KAAE,CAAC,CAC9D;;;0BAKU,SAAS;;;;cACT,QAAQ;;;;aACR,QAAQ;;8BAKX,UAAU,eACV,SAAS,KACP,UAAU;;;;;;eAKT,SAAS;;;;;;;8BAET,SAAS;;6BAMT;IAAE,GAAG,EAAE,gBAAgB,GAAG;QAAE,eAAe,EAAE,KAAK,CAAA;KAAE,CAAA;CAAE;uCApIhC,YAAY;2BACxB,YAAY;8BACT,eAAe;kCACX,mBAAmB;uCACd,mBAAmB;qDACL,4BAA4B;6CACpC,4BAA4B;2CAC9B,0BAA0B;+BACtC,cAAc;kCACX,cAAc"}