@agoric/inter-protocol 0.18.0-u23.0 → 0.18.0-u23.1

package/src/vaultFactory/params.d.ts

@@ -0,0 +1,170 @@
+/**
+ * @import {ERemote, Remote} from '@agoric/internal';
+ * @import {EMarshaller} from '@agoric/internal/src/marshal/wrap-marshaller.js';
+ * @import {MapStore} from '@agoric/store';
+ * @import {PriceAuthority} from '@agoric/zoe/tools/types.js';
+ * @import {ParamTypesMapFromRecord} from '@agoric/governance/src/contractGovernance/typedParamManager.js';
+ * @import {StoredPublisherKit} from '@agoric/notifier';
+ * @import {TimerService} from '@agoric/time';
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {Amount, Brand, Ratio} from '@agoric/ertp';
+ * @import {AssetReservePublicFacet} from '../reserve/assetReserve.js';
+ * @import {InterestTiming, VaultManagerParamValues} from './types.js';
+ * @import {GovernanceSubscriptionState} from '@agoric/governance/src/types.js';
+ * @import {StorageNode} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {ERef} from '@agoric/vow';
+ */
+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: 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<TimerService>;
+    reservePublicFacet: AssetReservePublicFacet;
+    interestTiming: InterestTiming;
+    shortfallInvitationAmount: Amount<"set">;
+    referencedUi?: string;
+}): {
+    priceAuthority: ERef<PriceAuthority>;
+    reservePublicFacet: import("@agoric/governance").GovernedPublicFacet<import("@endo/exo").Guarded<{
+        makeAddCollateralInvitation(): Promise<import("@agoric/zoe").Invitation<string, never>>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../reserve/assetReserveKit.js").MetricsNotification>;
+        };
+    }>>;
+    timerService: ERef<TimerService>;
+    governedParams: {
+        Electorate: {
+            type: "invitation";
+            value: import("@agoric/ertp").SetAmount<import("@endo/patterns").Key>;
+        };
+        MinInitialDebt: {
+            type: "amount";
+            value: import("@agoric/ertp").NatAmount;
+        };
+        ShortfallInvitation: {
+            type: "invitation";
+            value: import("@agoric/ertp").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: Baggage, marshaller: ERemote<EMarshaller>, managerParamOverrides: Record<string, VaultManagerParamOverrides>): {
+    /**
+     * @param {Brand} brand
+     * @param {Remote<StorageNode>} storageNode
+     * @param {VaultManagerParamValues} initialParamValues
+     */
+    addParamManager(brand: Brand, storageNode: Remote<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 = ParamTypesMapFromRecord<ReturnType<typeof makeVaultDirectorParams>>;
+export type VaultParamManager = ReturnType<typeof makeVaultParamManager>;
+export type VaultManagerParamOverrides = VaultManagerParamValues & {
+    brand: Brand;
+};
+import type { GovernanceSubscriptionState } from '@agoric/governance/src/types.js';
+import type { StoredPublisherKit } from '@agoric/notifier';
+import type { VaultManagerParamValues } from './types.js';
+import type { Amount } from '@agoric/ertp';
+import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
+import type { ERef } from '@agoric/vow';
+import type { TimerService } from '@agoric/time';
+import type { AssetReservePublicFacet } from '../reserve/assetReserve.js';
+import type { InterestTiming } from './types.js';
+import type { Baggage } from '@agoric/vat-data';
+import type { EMarshaller } from '@agoric/internal/src/marshal/wrap-marshaller.js';
+import type { ERemote } from '@agoric/internal';
+import type { Brand } from '@agoric/ertp';
+import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
+import type { Remote } from '@agoric/internal';
+/**
+ * @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").SetAmount<import("@endo/patterns").Key>;
+    };
+    MinInitialDebt: {
+        type: "amount";
+        value: import("@agoric/ertp").NatAmount;
+    };
+    ShortfallInvitation: {
+        type: "invitation";
+        value: import("@agoric/ertp").SetAmount<import("@endo/patterns").Key>;
+    };
+    ReferencedUI: {
+        type: "string";
+        value: string;
+    };
+    ChargingPeriod: {
+        type: "nat";
+        value: bigint;
+    };
+    RecordingPeriod: {
+        type: "nat";
+        value: bigint;
+    };
+};
+import type { ParamTypesMapFromRecord } from '@agoric/governance/src/contractGovernance/typedParamManager.js';
+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":"AAeA;;;;;;;;;;;;;;;GAeG;AAEH,kCAAmC,gBAAgB,CAAC;AACpD,mCAAoC,iBAAiB,CAAC;AAEtD,6BAA8B,WAAW,CAAC;AAC1C,qCAAsC,mBAAmB,CAAC;AAC1D,sCAAuC,oBAAoB,CAAC;AAC5D,sCAAuC,oBAAoB,CAAC;AAC5D,gCAAiC,cAAc,CAAC;AAChD,2BAA4B,SAAS,CAAC;AACtC,mCAAoC,gBAAgB,CAAC;AACrD,uCAAwC,qBAAqB,CAAC;AAC9D,gCAAiC,cAAc,CAAC;;;;;;;AAoEzC,oDAHI,mBAAmB,2BAA2B,CAAC,oGAC/C,uBAAuB;;;;;;;GAoB9B;AACJ,4EAA4E;AAE5E,iEAYE;AAeK,8MAZI;IACN,0BAA0B,EAAE,OAAO,KAAK,CAAC,CAAC;IAC1C,cAAc,EAAE,OAAO,KAAK,CAAC,CAAC;IAC9B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,cAAc,EAAE,KAAK,cAAc,CAAC,CAAC;IACrC,KAAK,EAAE,KAAK,YAAY,CAAC,CAAC;IAC1B,kBAAkB,EAAE,uBAAuB,CAAC;IAC5C,cAAc,EAAE,cAAc,CAAC;IAC/B,yBAAyB,EAAE,OAAO,KAAK,CAAC,CAAC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BH;AAeM,mDAJI,OAAO,cACP,QAAQ,WAAW,CAAC,yBACpB,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC;IAwDjD;;;;OAIG;2BAHQ,KAAK,eACL,OAAO,WAAW,CAAC,sBACnB,uBAAuB;;;;;;;;IAOlC,2BAA2B;eAAf,KAAK;;;;;;;;EAKpB;kCA3KY,wBACR,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAC3C;gCAgCU,UAAU,CAAC,OAAO,qBAAqB,CAAC;yCAwDxC,uBAAuB,GAAG;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE;iDA/JV,iCAAiC;wCAN1C,kBAAkB;6CAKG,YAAY;4BAF/B,cAAc;oCALpB,4BAA4B;0BAUtC,aAAa;kCAPL,cAAc;6CAGH,4BAA4B;oCACZ,YAAY;6BAH5C,kBAAkB;iCANd,iDAAiD;6BAD7C,kBAAkB;2BAQb,cAAc;iCAIvB,0CAA0C;4BAZtC,kBAAkB;AAuCpD;;;;;;GAMG;AACH,qEANW,OAAO,KAAK,CAAC,kBACb,OAAO,KAAK,CAAC,6BACb,OAAO,KAAK,CAAC,gBACb,MAAM,kBACN,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;EAgCxB;6CAxEyC,gEAAgE"}

package/src/vaultFactory/prioritizedVaults.d.ts

@@ -0,0 +1,283 @@
+export function currentDebtToCollateral(vault: Vault): Ratio;
+export function makePrioritizedVaults(store: MapStore<string, Vault>): {
+    addVault: (vaultId: VaultId, vault: Vault) => string;
+    entries: (keyPatt?: import("@endo/patterns").Pattern, valuePatt?: import("@endo/patterns").Pattern) => Iterable<[string, import("@endo/exo").Guarded<{
+        getVaultSeat(): import("@agoric/zoe").ZCFSeat;
+        initVaultKit(seat: import("@agoric/zoe").ZCFSeat, storageNode: import("@agoric/internal").Remote<import("@agoric/internal/src/lib-chainStorage.js").StorageNode>): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                AdjustBalances(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                CloseVault(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                TransferVault(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation<import("./vaultKit.js").VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): NormalizedDebt;
+    }>]>;
+    getCount: (keyPatt?: import("@endo/patterns").Pattern, valuePatt?: import("@endo/patterns").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(): import("@agoric/zoe").ZCFSeat;
+        initVaultKit(seat: import("@agoric/zoe").ZCFSeat, storageNode: import("@agoric/internal").Remote<import("@agoric/internal/src/lib-chainStorage.js").StorageNode>): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                AdjustBalances(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                CloseVault(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                TransferVault(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation<import("./vaultKit.js").VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): NormalizedDebt;
+    }>;
+    removeVaultsBelow: ({ margin, quote, interest }: {
+        margin: any;
+        quote: any;
+        interest: any;
+    }) => MapStore<string, import("@endo/exo").Guarded<{
+        getVaultSeat(): import("@agoric/zoe").ZCFSeat;
+        initVaultKit(seat: import("@agoric/zoe").ZCFSeat, storageNode: import("@agoric/internal").Remote<import("@agoric/internal/src/lib-chainStorage.js").StorageNode>): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                AdjustBalances(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                CloseVault(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                TransferVault(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation<import("./vaultKit.js").VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): NormalizedDebt;
+    }>>;
+    countVaultsBelow: (crKey: any) => number;
+} & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+    addVault: (vaultId: VaultId, vault: Vault) => string;
+    entries: (keyPatt?: import("@endo/patterns").Pattern, valuePatt?: import("@endo/patterns").Pattern) => Iterable<[string, import("@endo/exo").Guarded<{
+        getVaultSeat(): import("@agoric/zoe").ZCFSeat;
+        initVaultKit(seat: import("@agoric/zoe").ZCFSeat, storageNode: import("@agoric/internal").Remote<import("@agoric/internal/src/lib-chainStorage.js").StorageNode>): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                AdjustBalances(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                CloseVault(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                TransferVault(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation<import("./vaultKit.js").VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): NormalizedDebt;
+    }>]>;
+    getCount: (keyPatt?: import("@endo/patterns").Pattern, valuePatt?: import("@endo/patterns").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(): import("@agoric/zoe").ZCFSeat;
+        initVaultKit(seat: import("@agoric/zoe").ZCFSeat, storageNode: import("@agoric/internal").Remote<import("@agoric/internal/src/lib-chainStorage.js").StorageNode>): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                AdjustBalances(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                CloseVault(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                TransferVault(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation<import("./vaultKit.js").VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): NormalizedDebt;
+    }>;
+    removeVaultsBelow: ({ margin, quote, interest }: {
+        margin: any;
+        quote: any;
+        interest: any;
+    }) => MapStore<string, import("@endo/exo").Guarded<{
+        getVaultSeat(): import("@agoric/zoe").ZCFSeat;
+        initVaultKit(seat: import("@agoric/zoe").ZCFSeat, storageNode: import("@agoric/internal").Remote<import("@agoric/internal/src/lib-chainStorage.js").StorageNode>): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                AdjustBalances(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                CloseVault(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                TransferVault(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+            }>;
+            vault: import("@endo/exo").Guarded<{
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: import("@agoric/notifier").Subscriber<import("./vault.js").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+                makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation</*elided*/ any>>;
+                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                getNormalizedDebt(): NormalizedDebt;
+            }>;
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeCloseInvitation(): Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        makeTransferInvitation(): Promise<import("@agoric/zoe").Invitation<import("./vaultKit.js").VaultKit>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): NormalizedDebt;
+    }>>;
+    countVaultsBelow: (crKey: any) => number;
+}>;
+import type { Vault } from './vault.js';
+import type { Ratio } from '@agoric/ertp';
+import type { MapStore } from '@agoric/store';
+import type { VaultId } from './types.js';
+import type { NormalizedDebt } from './storeUtils.js';
+import type { Amount } from '@agoric/ertp';
+//# 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":"AA2CO,+CAHI,KAAK,GACH,KAAK,CAMf;AASI,6CAHI,SAAS,MAAM,EAAE,KAAK,CAAC;wBAsDrB,OAAO,SACP,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA9BL,cAAc,iBACd,OAAO,KAAK,CAAC,WACb,MAAM;wBAlBJ,KAAK,GAAG,SAAS;uBA0BnB,MAAM,KACJ,KAAK;uCAQP,cAAc,iBACd,OAAO,KAAK,CAAC,WACb,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAQN,OAAO,SACP,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCA9BL,cAAc,iBACd,OAAO,KAAK,CAAC,WACb,MAAM;wBAlBJ,KAAK,GAAG,SAAS;uBA0BnB,MAAM,KACJ,KAAK;uCAQP,cAAc,iBACd,OAAO,KAAK,CAAC,WACb,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDlB;2BA3IuB,YAAY;2BAEZ,cAAc;8BAHX,eAAe;6BAIhB,YAAY;oCAFL,iBAAiB;4BAGzB,cAAc"}

package/src/vaultFactory/storeUtils.d.ts

@@ -0,0 +1,30 @@
+/** @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) => 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 { Amount } from '@agoric/ertp';
+import type { VaultId } from './types.js';
+import type { PriceQuote } from '@agoric/zoe/tools/types.js';
+import type { Ratio } from '@agoric/ertp';
+//# 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":"AAyBA,8CAA8C;AAE9C;;GAEG;AAOH;;;GAGG;AACH,yEAA+C;AAO/C;;;GAGG;AACH,8FAA+C;AAkDxC,2CANI,cAAc,cACd,OAAO,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;2BA/IY,CAAC,2BAA2B,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC;6BA6CtD,OAAO,KAAK,CAAC,GAAG;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE;yBACpC,OAAO,KAAK,CAAC,GAAG;IAAE,UAAU,EAAE,KAAK,CAAA;CAAE;4BAnEnB,cAAc;6BACpB,YAAY;gCAFuD,4BAA4B;2BACzF,cAAc"}

package/src/vaultFactory/types.d.ts

@@ -0,0 +1,137 @@
+export type VaultFactoryPublicFacet = import("./vaultFactory.js").VaultFactoryContract["publicFacet"];
+export type AutoswapLocal = {
+    getInputPrice: (amount: Amount, brand: Brand) => Amount;
+    makeSwapInvitation: () => Invitation;
+};
+export 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;
+};
+export type AddVaultType = (collateralIssuer: Issuer, collateralKeyword: Keyword, params: VaultManagerParamValues) => Promise<VaultManager>;
+export type VaultFactoryCreatorFacet = {
+    addVaultType: AddVaultType;
+    getRewardAllocation: () => import("@agoric/zoe").Allocation;
+    makeCollectFeesInvitation: () => Promise<Invitation<string, never>>;
+};
+/**
+ * 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.
+ */
+export 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.
+ */
+export type BurnDebt = (toBurn: Amount, fromSeat: ZCFSeat) => void;
+export 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;
+};
+export type VaultId = string;
+export type InterestTiming = {
+    /**
+     * in seconds
+     */
+    chargingPeriod: RelativeTime;
+    /**
+     * in seconds
+     */
+    recordingPeriod: RelativeTime;
+};
+export type LiquidationStrategy = {
+    keywordMapping: () => import("@agoric/zoe/src/contractSupport/types.js").KeywordKeywordRecord;
+    makeProposal: (collateral: Amount, run: Amount) => import("@agoric/zoe").Proposal;
+    makeInvitation: (debt: Amount) => Promise<Invitation>;
+};
+export type Liquidator = {
+    makeLiquidateInvitation: () => Promise<Invitation<void, {
+        debt: Amount<"nat">;
+        penaltyRate: Ratio;
+    }>>;
+};
+export type DebtStatus = {
+    latestInterestUpdate: Timestamp;
+    /**
+     * interest accrued since latestInterestUpdate
+     */
+    interest: NatValue;
+    /**
+     * total including principal and interest
+     */
+    newDebt: NatValue;
+};
+export type Calculate = (debtStatus: DebtStatus, currentTime: Timestamp) => DebtStatus;
+export 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;
+};
+export type VaultFactoryParamPath = {
+    key: "governedParams" | {
+        collateralBrand: Brand;
+    };
+};
+import type { Amount } from '@agoric/ertp';
+import type { Brand } from '@agoric/ertp';
+import type { Invitation } from '@agoric/zoe';
+import type { Ratio } from '@agoric/ertp';
+import type { Issuer } from '@agoric/ertp';
+import type { Keyword } from '@agoric/zoe';
+import type { VaultManager } from './vaultManager.js';
+import type { ZCFSeat } from '@agoric/zoe';
+import type { TransferPart } from '@agoric/zoe';
+import type { RelativeTime } from '@agoric/time';
+import type { Timestamp } from '@agoric/time';
+import type { NatValue } from '@agoric/ertp';
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"sCAMa,OAAO,mBAAmB,EAAE,oBAAoB,CAAC,aAAa,CAAC;;mBAY9D,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,MAAM;wBACxC,MAAM,UAAU;;;;;;;uBAKhB,KAAK;;;;;wBAEL,KAAK;;;;;kBAEL,KAAK;;;;;aAEL,KAAK;eAEL,OAAO,KAAK,CAAC;;;;;;;8CAOhB,MAAM,qBACN,OAAO,UACP,uBAAuB,KACrB,OAAO,CAAC,YAAY,CAAC;;kBAKpB,YAAY;yBACZ,MAAM,OAAO,aAAa,EAAE,UAAU;+BACtC,MAAM,OAAO,CAAC,WAAW,MAAM,EAAE,KAAK,CAAC,CAAC;;;;;;;;6CAQ3C,OAAO,UACP,OAAO,KAAK,CAAC,OACb,OAAO,KAAK,CAAC,aACb,YAAY,EAAE,KACZ,IAAI;;;;;gCAMN,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;;sBAIlB,MAAM;;;;;oBAIN,YAAY;;;;qBACZ,YAAY;;;oBAKZ,MAAM,OAAO,0CAA0C,EAAE,oBAAoB;kBAC7E,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,CAC1B,WACA,IAAU,EACV;QAAQ,IAAI,EAAE,OAAO,KAAK,CAAC,CAAC;QAAC,WAAW,EAAE,KAAK,CAAA;KAAE,CAC5C,CACF;;;0BAKU,SAAS;;;;cACT,QAAQ;;;;aACR,QAAQ;;qCAKX,UAAU,eACV,SAAS,KACP,UAAU;;;;;;eAKT,SAAS;;;;;;;8BAET,SAAS;;oCAMT;IAAE,GAAG,EAAE,gBAAgB,GAAG;QAAE,eAAe,EAAE,KAAK,CAAA;KAAE,CAAA;CAAE;4BA7HX,cAAc;2BAAd,cAAc;gCACV,aAAa;2BADjB,cAAc;4BAAd,cAAc;6BACV,aAAa;kCAJ3C,mBAAmB;6BAIW,aAAa;kCAAb,aAAa;kCAF3C,cAAc;+BADjB,cAAc;8BAEe,cAAc"}