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

package/src/vaultFactory/vaultFactory.d.ts

@@ -0,0 +1,159 @@
+/**
+ * @typedef {ZCF<GovernanceTerms<import('./params').VaultDirectorParams> & {
+ *   auctioneerPublicFacet: import('../auction/auctioneer.js').AuctioneerPublicFacet,
+ *   priceAuthority: ERef<PriceAuthority>,
+ *   reservePublicFacet: AssetReservePublicFacet,
+ *   timerService: import('@agoric/time/src/types').TimerService,
+ * }>} VaultFactoryZCF
+ */
+export const privateArgsShape: import("@endo/patterns").Matcher;
+export function prepare(zcf: VaultFactoryZCF, privateArgs: {
+    feeMintAccess: FeeMintAccess;
+    initialPoserInvitation: Invitation;
+    initialShortfallInvitation: Invitation;
+    storageNode: ERef<StorageNode>;
+    marshaller: ERef<Marshaller>;
+}, baggage: MapStore<string, unknown>): Promise<{
+    creatorFacet: {
+        getParamMgrRetriever: () => {
+            get: (paramPath?: VaultFactoryParamPath) => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                DebtLimit: "amount";
+                StabilityFee: "ratio";
+                LiquidationPadding: "ratio";
+                LiquidationMargin: "ratio";
+                LiquidationPenalty: "ratio";
+                MintFee: "ratio";
+            }> | import("./vaultDirector.js").VaultDirectorParamManager;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: (paramPath?: VaultFactoryParamPath) => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                DebtLimit: "amount";
+                StabilityFee: "ratio";
+                LiquidationPadding: "ratio";
+                LiquidationMargin: "ratio";
+                LiquidationPenalty: "ratio";
+                MintFee: "ratio";
+            }> | import("./vaultDirector.js").VaultDirectorParamManager;
+        }>;
+        getInvitation(name: string): Promise<Invitation<R, A>>;
+        getLimitedCreatorFacet(): {
+            addVaultType(collateralIssuer: Issuer<"nat">, collateralKeyword: string, initialParamValues: VaultManagerParamValues): Promise<{
+                getGovernedParams(): import("./vaultManager.js").GovernedParamGetters;
+                makeVaultKit(seat: ZCFSeat): Promise<{
+                    publicSubscribers: {
+                        vault: {
+                            description: string;
+                            subscriber: Subscriber<import("./vault.js").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.js").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.js").VaultNotification>;
+                }>;
+                getCollateralQuote(): PriceQuote;
+                getPublicFacet(): {
+                    makeVaultInvitation(): Promise<Invitation<R, A>>;
+                    getQuotes(): import("@agoric/notifier").StoredNotifier<PriceQuote>;
+                    getCompoundedStabilityFee(): Ratio;
+                    getPublicTopics(): {
+                        asset: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").AssetState>;
+                        metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").MetricsNotification>;
+                    };
+                };
+                lockOraclePrices(): PriceQuote;
+                liquidateVaults(auctionPF: 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>>;
+                }>>): Promise<void>;
+            }>;
+            makeCollectFeesInvitation(): Promise<Invitation<R, A>>;
+            getRewardAllocation(): AmountKeywordRecord;
+            makeLiquidationWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            makeReschedulerWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            makePriceLockWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+        };
+        getGovernedApis(): ERef<GovernedApis>;
+        getGovernedApiNames(): never[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    };
+    publicFacet: {
+        getCollateralManager(brandIn: Brand<AssetKind>): {
+            makeVaultInvitation(): Promise<Invitation<R, A>>;
+            getQuotes(): import("@agoric/notifier").StoredNotifier<PriceQuote>;
+            getCompoundedStabilityFee(): Ratio;
+            getPublicTopics(): {
+                asset: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").AssetState>;
+                metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultManager.js").MetricsNotification>;
+            };
+        };
+        getDebtIssuer(): Issuer<"nat">;
+        getSubscription({ collateralBrand }: {
+            collateralBrand: Brand<AssetKind>;
+        }): StoredSubscription<GovernanceSubscriptionState>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./vaultDirector.js").MetricsNotification>;
+        };
+        getElectorateSubscription(): StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams({ collateralBrand }: {
+            collateralBrand: Brand<AssetKind>;
+        }): ERef<ParamStateRecord>;
+        getInvitationAmount(name: string): Amount<"set">;
+    };
+}>;
+export type VaultFactoryZCF = ZCF<GovernanceTerms<import('./params').VaultDirectorParams> & {
+    auctioneerPublicFacet: import('../auction/auctioneer.js').AuctioneerPublicFacet;
+    priceAuthority: ERef<PriceAuthority>;
+    reservePublicFacet: AssetReservePublicFacet;
+    timerService: import('@agoric/time/src/types').TimerService;
+}>;
+export type VaultFactoryContract = ContractOf<typeof prepare>;
+//# sourceMappingURL=vaultFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vaultFactory.d.ts","sourceRoot":"","sources":["vaultFactory.js"],"names":[],"mappings":"AAmCA;;;;;;;GAOG;AAEH,gEAWE;AAcK,6BAVI,eAAe;mBAEN,aAAa;4BACJ,UAAU;gCACN,UAAU;iBACzB,KAAK,WAAW,CAAC;gBAClB,KAAK,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFhC;8BA9GY,IAAI,gBAAgB,OAAO,UAAU,EAAE,mBAAmB,CAAC,GAAG;IAC1E,qBAAyB,EAAE,OAAO,0BAA0B,EAAE,qBAAqB,CAAC;IACpF,cAAkB,EAAE,KAAK,cAAc,CAAC,CAAC;IACzC,kBAAsB,EAAE,uBAAuB,CAAC;IAChD,YAAgB,EAAE,OAAO,wBAAwB,EAAE,YAAY,CAAC;CAC7D,CAAC;mCA2GS,WAAW,cAAc,CAAC"}

package/src/vaultFactory/vaultHolder.d.ts

@@ -0,0 +1,205 @@
+export function prepareVaultHolder(baggage: MapStore<string, unknown>, makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit): (vault: {
+    getVaultSeat(): ZCFSeat;
+    initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+        publicSubscribers: {
+            vault: {
+                description: string;
+                subscriber: Subscriber<import("./vault.js").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.js").VaultNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+            makeCloseInvitation(): Promise<Invitation<R, A>>;
+            /**
+             * Starting a transfer revokes the vault holder. The associated updater will
+             * get a special notification that the vault is being transferred.
+             */
+            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.js").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;
+}, storageNode: StorageNode) => {
+    helper: {
+        /**
+         * @throws if this holder no longer owns the vault
+         */
+        owned(): {
+            getVaultSeat(): ZCFSeat;
+            initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+                publicSubscribers: {
+                    vault: {
+                        description: string;
+                        subscriber: Subscriber<import("./vault.js").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.js").VaultNotification>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+                    makeCloseInvitation(): Promise<Invitation<R, A>>;
+                    /**
+                     * Starting a transfer revokes the vault holder. The associated updater will
+                     * get a special notification that the vault is being transferred.
+                     */
+                    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.js").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;
+        };
+        getUpdater(): import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
+    };
+    invitationMakers: {
+        AdjustBalances(): Promise<Invitation<R, A>>;
+        CloseVault(): Promise<Invitation<R, A>>;
+        TransferVault(): Promise<Invitation<R, A>>;
+    };
+    holder: {
+        getPublicTopics(): {
+            vault: {
+                description: string;
+                subscriber: Subscriber<import("./vault.js").VaultNotification>;
+                storagePath: Promise<string>;
+            };
+        };
+        makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+        makeCloseInvitation(): Promise<Invitation<R, A>>;
+        /**
+         * Starting a transfer revokes the vault holder. The associated updater will
+         * get a special notification that the vault is being transferred.
+         */
+        makeTransferInvitation(): Promise<Invitation<R, A>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    };
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    helper: {
+        /**
+         * @throws if this holder no longer owns the vault
+         */
+        owned(): {
+            getVaultSeat(): ZCFSeat;
+            initVaultKit(seat: ZCFSeat, storageNode: StorageNode): Promise<{
+                publicSubscribers: {
+                    vault: {
+                        description: string;
+                        subscriber: Subscriber<import("./vault.js").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.js").VaultNotification>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+                    makeCloseInvitation(): Promise<Invitation<R, A>>;
+                    /**
+                     * Starting a transfer revokes the vault holder. The associated updater will
+                     * get a special notification that the vault is being transferred.
+                     */
+                    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.js").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;
+        };
+        getUpdater(): import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<import("./vault.js").VaultNotification>;
+    };
+    invitationMakers: {
+        AdjustBalances(): Promise<Invitation<R, A>>;
+        CloseVault(): Promise<Invitation<R, A>>;
+        TransferVault(): Promise<Invitation<R, A>>;
+    };
+    holder: {
+        getPublicTopics(): {
+            vault: {
+                description: string;
+                subscriber: Subscriber<import("./vault.js").VaultNotification>;
+                storagePath: Promise<string>;
+            };
+        };
+        makeAdjustBalancesInvitation(): Promise<Invitation<R, A>>;
+        makeCloseInvitation(): Promise<Invitation<R, A>>;
+        /**
+         * Starting a transfer revokes the vault holder. The associated updater will
+         * get a special notification that the vault is being transferred.
+         */
+        makeTransferInvitation(): Promise<Invitation<R, A>>;
+        getCollateralAmount(): Amount<"nat">;
+        getCurrentDebt(): Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    };
+}>;
+export type State = {
+    topicKit: import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<VaultNotification>;
+    vault: Vault | null;
+};
+//# sourceMappingURL=vaultHolder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vaultHolder.d.ts","sourceRoot":"","sources":["vaultHolder.js"],"names":[],"mappings":"AAoCO,wFAFI,OAAO,6CAA6C,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;YAuExE;;;eAGG;;;;;;;;;;;;;;;;;;;QA7CH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwCH;;;uBAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;;;QA7CH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;oBAwCH;;;uBAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAHH;;;WAGG;;;;;;GAoBV;oBArHY;IACZ,QAAU,EAAE,OAAO,6CAA6C,EAAE,WAAW,CAAC,iBAAiB,CAAC,CAAC;IACjG,KAAO,EAAE,KAAK,GAAG,IAAI,CAAC;CACnB"}

package/src/vaultFactory/vaultKit.d.ts

@@ -0,0 +1,32 @@
+export function prepareVaultKit(baggage: MapStore<string, unknown>, makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit): (vault: Vault, storageNode: StorageNode) => {
+    publicSubscribers: {
+        vault: {
+            description: string;
+            subscriber: Subscriber<import("./vault.js").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.js").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.js").VaultNotification>;
+};
+export type VaultKit = (ReturnType<ReturnType<typeof prepareVaultKit>>);
+//# sourceMappingURL=vaultKit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vaultKit.d.ts","sourceRoot":"","sources":["vaultKit.js"],"names":[],"mappings":"AAeO,qFAFI,OAAO,6CAA6C,EAAE,eAAe,WASnE,KAAK,eACL,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBvB;uBAEa,CAAC,WAAW,WAAW,sBAAsB,CAAC,CAAC,CAAC"}