@agoric/inter-protocol 0.16.2-dev-6e5b422.0 → 0.16.2-dev-bd1190d.0

package/src/tokens.d.ts

@@ -0,0 +1,36 @@
+export namespace Stable {
+    export let symbol: "IST";
+    export let denom: "uist";
+    export let proposedName: "Agoric stable token";
+    export { NAT as assetKind };
+    export namespace displayInfo {
+        export let decimalPlaces: 6;
+        export { NAT as assetKind };
+    }
+}
+export namespace Stake {
+    let symbol_1: "BLD";
+    export { symbol_1 as symbol };
+    let denom_1: "ubld";
+    export { denom_1 as denom };
+    let proposedName_1: "Agoric staking token";
+    export { proposedName_1 as proposedName };
+    export { NAT as assetKind };
+    export namespace displayInfo_1 {
+        let decimalPlaces_1: 6;
+        export { decimalPlaces_1 as decimalPlaces };
+        export { NAT as assetKind };
+    }
+    export { displayInfo_1 as displayInfo };
+}
+export type TokenKeyword = 'IST' | 'BLD';
+/** @typedef { 'IST' | 'BLD' } TokenKeyword */
+/**
+ * Use static type check and unit tests rather than runtime import
+ * to avoid bundling all of ERTP just to get Stable.symbol.
+ *
+ * @type {typeof import('@agoric/ertp').AssetKind.NAT}
+ */
+declare const NAT: typeof import('@agoric/ertp').AssetKind.NAT;
+export {};
+//# sourceMappingURL=tokens.d.ts.map

package/src/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["tokens.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;2BAEe,KAAK,GAAG,KAAK;AAA5B,8CAA8C;AAE9C;;;;;GAKG;AACH,mBAFU,cAAc,cAAc,EAAE,SAAS,CAAC,GAAG,CAEnC"}

package/src/typeGuards.d.ts

@@ -0,0 +1,5 @@
+/**
+ * To be used only for 'helper' facets where the calls are from trusted code.
+ */
+export const UnguardedHelperI: import("@endo/patterns").InterfaceGuard;
+//# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA;;GAEG;AACH,uEAKE"}

package/src/vaultFactory/burn.d.ts

@@ -0,0 +1,2 @@
+export function paymentFromZCFMint(zcf: ZCF, zcfMint: ZCFMint, amount: Amount): Promise<Payment<any>>;
+//# sourceMappingURL=burn.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"burn.d.ts","sourceRoot":"","sources":["burn.js"],"names":[],"mappings":"AAWO,wCAJI,GAAG,WACH,OAAO,UACP,MAAM,yBAOhB"}

package/src/vaultFactory/liquidation.d.ts

@@ -0,0 +1,24 @@
+export function setWakeupsForNextAuction(auctioneerPublicFacet: ERef<import('../auction/auctioneer.js').AuctioneerPublicFacet>, timer: ERef<TimerService>, priceLockWaker: TimerWaker, liquidationWaker: TimerWaker, reschedulerWaker: TimerWaker): Promise<void>;
+export function liquidationResults(debt: Amount<'nat'>, minted: Amount<'nat'>): {
+    overage: Amount<'nat'>;
+    shortfall: Amount<'nat'>;
+};
+export function watchForGovernanceChange(auctioneerPublicFacet: ERef<import('../auction/auctioneer.js').AuctioneerPublicFacet>, timer: ERef<TimerService>, reschedulerWaker: TimerWaker): void;
+export function getLiquidatableVaults(zcf: ZCF, collateralizationDetails: {
+    quote: PriceQuote;
+    interest: Ratio;
+    margin: Ratio;
+}, prioritizedVaults: ReturnType<typeof import('./prioritizedVaults.js').makePrioritizedVaults>, liquidatingVaults: SetStore<Vault>, debtBrand: Brand<'nat'>, collateralBrand: Brand<'nat'>): {
+    vaultData: MapStore<Vault, {
+        collateralAmount: Amount<'nat'>;
+        debtAmount: Amount<'nat'>;
+    }>;
+    totalDebt: Amount<'nat'>;
+    totalCollateral: Amount<'nat'>;
+    liqSeat: ZCFSeat;
+};
+export type TimerService = import('@agoric/time/src/types').TimerService;
+export type TimerWaker = import('@agoric/time/src/types').TimerWaker;
+export type CancelToken = import('@agoric/time/src/types').CancelToken;
+export type RelativeTimeRecord = import('@agoric/time/src/types').RelativeTimeRecord;
+//# sourceMappingURL=liquidation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"liquidation.d.ts","sourceRoot":"","sources":["liquidation.js"],"names":[],"mappings":"AAkJO,gEAPI,KAAK,OAAO,0BAA0B,EAAE,qBAAqB,CAAC,SAC9D,KAAK,YAAY,CAAC,kBAClB,UAAU,oBACV,UAAU,oBACV,UAAU,GACR,QAAQ,IAAI,CAAC,CAqCzB;AAQM,yCAJI,OAAO,KAAK,CAAC,UACb,OAAO,KAAK,CAAC;aACA,OAAO,KAAK,CAAC;eAAa,OAAO,KAAK,CAAC;EAY9D;AAWM,gEALI,KAAK,OAAO,0BAA0B,EAAE,qBAAqB,CAAC,SAC9D,KAAK,YAAY,CAAC,oBAClB,UAAU,GACR,IAAI,CA0BhB;AAkBM,2CAfI,GAAG;IAEkC,KAAK,EAA1C,UAAU;IACsB,QAAQ,EAAxC,KAAK;IAC2B,MAAM,EAAtC,KAAK;sBACL,WAAW,cAAc,wBAAwB,EAAE,qBAAqB,CAAC,qBACzE,SAAS,KAAK,CAAC,aACf,MAAM,KAAK,CAAC,mBACZ,MAAM,KAAK,CAAC;eAEN,SAAS,KAAK,EAAE;QAAE,gBAAgB,EAAE,OAAO,KAAK,CAAC,CAAC;QAAC,UAAU,EAAG,OAAO,KAAK,CAAC,CAAA;KAAC,CAAC;eAC/E,OAAO,KAAK,CAAC;qBACP,OAAO,KAAK,CAAC;aACrB,OAAO;EA4CrB;2BAvRa,OAAO,wBAAwB,EAAE,YAAY;yBAC7C,OAAO,wBAAwB,EAAE,UAAU;0BAC3C,OAAO,wBAAwB,EAAE,WAAW;iCAC5C,OAAO,wBAAwB,EAAE,kBAAkB"}

package/src/vaultFactory/math.d.ts

@@ -0,0 +1,10 @@
+export function calculateMinimumCollateralization(liquidationMargin: Ratio, liquidationPadding: Ratio): Ratio;
+export function minimumPrice(quoteA: PriceQuote, quoteB?: PriceQuote | undefined): Ratio;
+export function maxDebtForVault(quoteAmount: PriceQuote, liquidationMargin: Ratio, liquidationPadding: Ratio): Amount<'nat'>;
+export function calculateDebtCosts(currentDebt: Amount<'nat'>, give: Amount<'nat'>, want: Amount<'nat'>, debtFee: Ratio): {
+    newDebt: Amount<"nat">;
+    toMint: Amount<"nat">;
+    fee: Amount<"nat">;
+    surplus: Amount<"nat">;
+};
+//# sourceMappingURL=math.d.ts.map

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

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

package/src/vaultFactory/orderedVaultStore.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"orderedVaultStore.d.ts","sourceRoot":"","sources":["orderedVaultStore.js"],"names":[],"mappings":"AAkBO,6CAFI,SAAS,MAAM,EAAE,KAAK,CAAC;wBAKrB,MAAM,SACN,KAAK;uBAYL,MAAM,KACJ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCnB;oBAxDa,OAAO,SAAS,EAAE,KAAK;2BACvB,OAAO,cAAc,EAAE,YAAY"}

package/src/vaultFactory/params.d.ts

@@ -0,0 +1,162 @@
+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 STABILITY_FEE_KEY: "StabilityFee";
+export const MINT_FEE_KEY: "MintFee";
+export const MIN_INITIAL_DEBT_KEY: "MinInitialDebt";
+export const SHORTFALL_INVITATION_KEY: "ShortfallInvitation";
+export const REFERENCED_UI_KEY: "ReferencedUI";
+export namespace vaultDirectorParamTypes {
+    let MinInitialDebt: "amount";
+    let ChargingPeriod: "nat";
+    let RecordingPeriod: "nat";
+    let ReferencedUI: "string";
+}
+export function makeVaultParamManager(publisherKit: import('@agoric/notifier').StoredPublisherKit<GovernanceSubscriptionState>, { debtLimit, stabilityFee, liquidationMargin, liquidationPadding, liquidationPenalty, mintFee, }: VaultManagerParamValues): import("@agoric/governance/src/contractGovernance/typedParamManager").TypedParamManager<{
+    DebtLimit: "amount";
+    StabilityFee: "ratio";
+    LiquidationPadding: "ratio";
+    LiquidationMargin: "ratio";
+    LiquidationPenalty: "ratio";
+    MintFee: "ratio";
+}>;
+/** @typedef {ReturnType<typeof makeVaultParamManager>} VaultParamManager */
+export const vaultParamPattern: import("@endo/patterns").Matcher;
+export function makeGovernedTerms({ auctioneerPublicFacet, bootstrapPaymentValue, electorateInvitationAmount, interestTiming, minInitialDebt, priceAuthority, reservePublicFacet, timer, shortfallInvitationAmount, referencedUi, }: {
+    auctioneerPublicFacet: ERef<AuctioneerPublicFacet>;
+    electorateInvitationAmount: Amount<'set'>;
+    minInitialDebt: Amount<'nat'>;
+    bootstrapPaymentValue: bigint;
+    priceAuthority: ERef<PriceAuthority>;
+    timer: ERef<import('@agoric/time/src/types').TimerService>;
+    reservePublicFacet: AssetReservePublicFacet;
+    interestTiming: InterestTiming;
+    shortfallInvitationAmount: Amount<'set'>;
+    referencedUi?: string;
+}): {
+    auctioneerPublicFacet: ERef<GovernedPublicFacet<{
+        getElectorate: () => Amount<"set">;
+        getStartFrequency: () => import("@agoric/time/src/types").RelativeTime;
+        getClockStep: () => import("@agoric/time/src/types").RelativeTime;
+        getStartingRate: () => bigint;
+        getLowestRate: () => bigint;
+        getDiscountStep: () => bigint;
+        getAuctionStartDelay: () => import("@agoric/time/src/types").RelativeTime;
+        getPriceLockPeriod: () => import("@agoric/time/src/types").RelativeTime;
+        makeBidInvitation(collateralBrand: Brand<"nat">): Promise<Invitation<R, A>>;
+        getSchedules(): {
+            liveAuctionSchedule: import("../auction/scheduler.js").Schedule | null;
+            nextAuctionSchedule: import("../auction/scheduler.js").Schedule | null;
+        };
+        getScheduleUpdates(): Subscriber<import("../auction/scheduler.js").ScheduleNotification>;
+        getBookDataUpdates(brand: any): 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<R, A>>;
+    }>>;
+    priceAuthority: ERef<PriceAuthority>;
+    reservePublicFacet: GovernedPublicFacet<{
+        makeAddCollateralInvitation(): Promise<Invitation<R, A>>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../reserve/assetReserveKit.js").MetricsNotification>;
+        };
+    }>;
+    timerService: ERef<import("@agoric/time/src/types").TimerService>;
+    governedParams: {
+        Electorate: {
+            type: "invitation";
+            value: Amount<"set">;
+        };
+        MinInitialDebt: {
+            type: "amount";
+            value: Amount<"nat">;
+        };
+        ShortfallInvitation: {
+            type: "invitation";
+            value: Amount<"set">;
+        };
+        ReferencedUI: {
+            type: "string";
+            value: string;
+        };
+        ChargingPeriod: {
+            type: "nat";
+            value: bigint;
+        };
+        RecordingPeriod: {
+            type: "nat";
+            value: bigint;
+        };
+    };
+    bootstrapPaymentValue: bigint;
+};
+export function provideVaultParamManagers(baggage: MapStore<string, unknown>, marshaller: ERef<Marshaller>): {
+    /**
+     *
+     * @param {Brand} brand
+     * @param {StorageNode} storageNode
+     * @param {VaultManagerParamValues} initialParamValues
+     */
+    addParamManager(brand: Brand, storageNode: StorageNode, initialParamValues: VaultManagerParamValues): import("@agoric/governance/src/contractGovernance/typedParamManager").TypedParamManager<{
+        DebtLimit: "amount";
+        StabilityFee: "ratio";
+        LiquidationPadding: "ratio";
+        LiquidationMargin: "ratio";
+        LiquidationPenalty: "ratio";
+        MintFee: "ratio";
+    }>;
+    /**
+     * @param {Brand} brand
+     */
+    get(brand: Brand): import("@agoric/governance/src/contractGovernance/typedParamManager").TypedParamManager<{
+        DebtLimit: "amount";
+        StabilityFee: "ratio";
+        LiquidationPadding: "ratio";
+        LiquidationMargin: "ratio";
+        LiquidationPenalty: "ratio";
+        MintFee: "ratio";
+    }>;
+};
+export type VaultDirectorParams = import('@agoric/governance/src/contractGovernance/typedParamManager').ParamTypesMapFromRecord<ReturnType<typeof makeVaultDirectorParams>>;
+export type VaultParamManager = ReturnType<typeof makeVaultParamManager>;
+/**
+ * @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: Amount<"set">;
+    };
+    MinInitialDebt: {
+        type: "amount";
+        value: Amount<"nat">;
+    };
+    ShortfallInvitation: {
+        type: "invitation";
+        value: Amount<"set">;
+    };
+    ReferencedUI: {
+        type: "string";
+        value: string;
+    };
+    ChargingPeriod: {
+        type: "nat";
+        value: bigint;
+    };
+    RecordingPeriod: {
+        type: "nat";
+        value: bigint;
+    };
+};
+export {};
+//# sourceMappingURL=params.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["params.js"],"names":[],"mappings":"AAgBA,mDAAoD;AACpD,qDAAsD;AAEtD,yCAA0C;AAC1C,yDAA0D;AAC1D,2DAA4D;AAC5D,2DAA4D;AAC5D,+CAAgD;AAChD,qCAAsC;AACtC,oDAAqD;AACrD,6DAA8D;AAC9D,+CAAgD;;;;;;;AA4DzC,oDAHI,OAAO,kBAAkB,EAAE,kBAAkB,CAAC,2BAA2B,CAAC,oGAC1E,uBAAuB;;;;;;;GAoB9B;AACJ,4EAA4E;AAE5E,iEAYE;AAgBK,qOAbI;IACV,qBAAyB,EAAE,KAAK,qBAAqB,CAAC,CAAC;IACvD,0BAA8B,EAAE,OAAO,KAAK,CAAC,CAAC;IAC9C,cAAkB,EAAE,OAAO,KAAK,CAAC,CAAC;IAClC,qBAAyB,EAAE,MAAM,CAAC;IAClC,cAAkB,EAAE,KAAK,cAAc,CAAC,CAAC;IACzC,KAAS,EAAE,KAAK,OAAO,wBAAwB,EAAE,YAAY,CAAC,CAAC;IAC/D,kBAAsB,EAAE,uBAAuB,CAAC;IAChD,cAAkB,EAAE,cAAc,CAAC;IACnC,yBAA6B,EAAE,OAAO,KAAK,CAAC,CAAC;IAC7C,YAAgB,CAAC,EAAE,MAAM,CAAC;CACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BH;AAWM,0FAFI,KAAK,UAAU,CAAC;IA0BvB;;;;;OAKG;2BAHQ,KAAK,eACL,WAAW,sBACX,uBAAuB;;;;;;;;IAOlC;;OAEG;eADQ,KAAK;;;;;;;;EAMnB;kCA1Ia,OAAO,6DAA6D,EAAE,uBAAuB,CAAC,WAAW,8BAA8B,CAAC,CAAC;gCA6BzI,WAAW,4BAA4B,CAAC;AArEtD;;;;;;GAMG;AACH,qEANW,OAAO,KAAK,CAAC,kBACb,OAAO,KAAK,CAAC,6BACb,OAAO,KAAK,CAAC,gBACb,MAAM,kBACN,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;EAgCxB"}

package/src/vaultFactory/prioritizedVaults.d.ts

@@ -0,0 +1,279 @@
+export function currentDebtToCollateral(vault: Vault): Ratio;
+export function makePrioritizedVaults(store: MapStore<string, Vault>): {
+    addVault: (vaultId: VaultId, vault: Vault) => string;
+    entries: (keyPatt?: any, valuePatt?: any) => Iterable<[string, {
+        getVaultSeat(): ZCFSeat;
+        initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: Subscriber<import("./vault").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: {
+                AdjustBalances(): Promise<Invitation<R, A>>;
+                CloseVault(): Promise<Invitation<R, A>>;
+                TransferVault(): Promise<Invitation<R, A>>;
+            };
+            vault: {
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: Subscriber<import("./vault").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+                makeCloseInvitation(): Promise<Invitation<R, A>>;
+                makeTransferInvitation(): Promise<Invitation<R, A>>;
+                getCollateralAmount(): Amount<"nat">;
+                getCurrentDebt(): Amount<"nat">;
+                getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+            };
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+        makeCloseInvitation(): Promise<Invitation<R, A>>;
+        makeTransferInvitation(): Promise<Invitation<R, A>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }]>;
+    getCount: (keyPatt?: any, valuePatt?: any) => 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) => {
+        getVaultSeat(): ZCFSeat;
+        initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: Subscriber<import("./vault").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: {
+                AdjustBalances(): Promise<Invitation<R, A>>;
+                CloseVault(): Promise<Invitation<R, A>>;
+                TransferVault(): Promise<Invitation<R, A>>;
+            };
+            vault: {
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: Subscriber<import("./vault").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+                makeCloseInvitation(): Promise<Invitation<R, A>>;
+                makeTransferInvitation(): Promise<Invitation<R, A>>;
+                getCollateralAmount(): Amount<"nat">;
+                getCurrentDebt(): Amount<"nat">;
+                getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+            };
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+        makeCloseInvitation(): Promise<Invitation<R, A>>;
+        makeTransferInvitation(): Promise<Invitation<R, A>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    };
+    removeVaultsBelow: ({ margin, quote, interest }: {
+        margin: any;
+        quote: any;
+        interest: any;
+    }) => MapStore<string, {
+        getVaultSeat(): ZCFSeat;
+        initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: Subscriber<import("./vault").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: {
+                AdjustBalances(): Promise<Invitation<R, A>>;
+                CloseVault(): Promise<Invitation<R, A>>;
+                TransferVault(): Promise<Invitation<R, A>>;
+            };
+            vault: {
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: Subscriber<import("./vault").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+                makeCloseInvitation(): Promise<Invitation<R, A>>;
+                makeTransferInvitation(): Promise<Invitation<R, A>>;
+                getCollateralAmount(): Amount<"nat">;
+                getCurrentDebt(): Amount<"nat">;
+                getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+            };
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+        makeCloseInvitation(): Promise<Invitation<R, A>>;
+        makeTransferInvitation(): Promise<Invitation<R, A>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>;
+    countVaultsBelow: (crKey: any) => number;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    addVault: (vaultId: VaultId, vault: Vault) => string;
+    entries: (keyPatt?: any, valuePatt?: any) => Iterable<[string, {
+        getVaultSeat(): ZCFSeat;
+        initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: Subscriber<import("./vault").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: {
+                AdjustBalances(): Promise<Invitation<R, A>>;
+                CloseVault(): Promise<Invitation<R, A>>;
+                TransferVault(): Promise<Invitation<R, A>>;
+            };
+            vault: {
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: Subscriber<import("./vault").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+                makeCloseInvitation(): Promise<Invitation<R, A>>;
+                makeTransferInvitation(): Promise<Invitation<R, A>>;
+                getCollateralAmount(): Amount<"nat">;
+                getCurrentDebt(): Amount<"nat">;
+                getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+            };
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+        makeCloseInvitation(): Promise<Invitation<R, A>>;
+        makeTransferInvitation(): Promise<Invitation<R, A>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }]>;
+    getCount: (keyPatt?: any, valuePatt?: any) => 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) => {
+        getVaultSeat(): ZCFSeat;
+        initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: Subscriber<import("./vault").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: {
+                AdjustBalances(): Promise<Invitation<R, A>>;
+                CloseVault(): Promise<Invitation<R, A>>;
+                TransferVault(): Promise<Invitation<R, A>>;
+            };
+            vault: {
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: Subscriber<import("./vault").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+                makeCloseInvitation(): Promise<Invitation<R, A>>;
+                makeTransferInvitation(): Promise<Invitation<R, A>>;
+                getCollateralAmount(): Amount<"nat">;
+                getCurrentDebt(): Amount<"nat">;
+                getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+            };
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+        makeCloseInvitation(): Promise<Invitation<R, A>>;
+        makeTransferInvitation(): Promise<Invitation<R, A>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    };
+    removeVaultsBelow: ({ margin, quote, interest }: {
+        margin: any;
+        quote: any;
+        interest: any;
+    }) => MapStore<string, {
+        getVaultSeat(): ZCFSeat;
+        initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+            publicSubscribers: {
+                vault: {
+                    description: string;
+                    subscriber: Subscriber<import("./vault").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: {
+                AdjustBalances(): Promise<Invitation<R, A>>;
+                CloseVault(): Promise<Invitation<R, A>>;
+                TransferVault(): Promise<Invitation<R, A>>;
+            };
+            vault: {
+                getPublicTopics(): {
+                    vault: {
+                        description: string;
+                        subscriber: Subscriber<import("./vault").VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+                makeCloseInvitation(): Promise<Invitation<R, A>>;
+                makeTransferInvitation(): Promise<Invitation<R, A>>;
+                getCollateralAmount(): Amount<"nat">;
+                getCurrentDebt(): Amount<"nat">;
+                getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+            };
+            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault").VaultNotification>;
+        }>;
+        liquidating(): void;
+        liquidated(): void;
+        abortLiquidation(): string;
+        makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+        makeCloseInvitation(): Promise<Invitation<R, A>>;
+        makeTransferInvitation(): Promise<Invitation<R, A>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>;
+    countVaultsBelow: (crKey: any) => number;
+}>;
+export type Vault = import('./vault').Vault;
+export type NormalizedDebt = import('./storeUtils.js').NormalizedDebt;
+//# 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":"AAuCO,+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;oBAvIa,OAAO,SAAS,EAAE,KAAK;6BACvB,OAAO,iBAAiB,EAAE,cAAc"}