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

package/src/proposals/econ-behaviors.d.ts

@@ -0,0 +1,541 @@
+export const SECONDS_PER_MINUTE: 60n;
+export const SECONDS_PER_HOUR: bigint;
+export const SECONDS_PER_DAY: bigint;
+export const SECONDS_PER_WEEK: bigint;
+export function setupReserve({ consume: { board, feeMintAccess: feeMintAccessP, chainStorage, chainTimerService, diagnostics, zoe, economicCommitteeCreatorFacet: committeeCreator, }, produce: { reserveKit }, issuer: { consume: { [Stable.symbol]: centralIssuer }, }, instance: { produce: { reserve: reserveInstanceProducer, reserveGovernor }, }, installation: { consume: { contractGovernor: governorInstallation, reserve: reserveInstallation, }, }, }: EconomyBootstrapPowers): Promise<Installation<(zcf: ZCF<GovernanceTerms<{}> & {
+    governedApis: ["burnFeesToReduceShortfall"];
+}>, privateArgs: {
+    feeMintAccess: FeeMintAccess;
+    initialPoserInvitation: Invitation;
+    marshaller: ERef<Marshaller>;
+    storageNode: ERef<StorageNode>;
+}, baggage: import("@agoric/vat-data").Baggage) => Promise<{
+    creatorFacet: GovernedCreatorFacet<import("@endo/exo").Guarded<{
+        addIssuer(issuer: Issuer, keyword: string): Promise<void>;
+        getAllocations(): Allocation;
+        makeShortfallReportingInvitation(): Promise<Invitation<import("@endo/exo").Guarded<{
+            increaseLiquidationShortfall(shortfall: Amount<"nat">): void;
+            reduceLiquidationShortfall(reduction: Amount<"nat">): void;
+        }>, undefined>>;
+    }>>;
+    publicFacet: GovernedPublicFacet<import("@endo/exo").Guarded<{
+        makeAddCollateralInvitation(): Promise<Invitation<string, never>>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../reserve/assetReserveKit.js").MetricsNotification>;
+        };
+    }>>;
+}>>>;
+export function setupVaultFactoryArguments(consume: EconomyBootstrapPowers["consume"], { interestTiming, options: { referencedUi }, }: {
+    interestTiming?: InterestTiming | undefined;
+    options?: {
+        referencedUi?: string | undefined;
+    } | undefined;
+} | undefined, minInitialDebt: Amount<"nat">): Promise<{
+    vaultFactoryTerms: {
+        priceAuthority: globalThis.ERef<import("@agoric/zoe/tools/types.js").PriceAuthority>;
+        reservePublicFacet: globalThis.GovernedPublicFacet<import("@endo/exo").Guarded<{
+            makeAddCollateralInvitation(): Promise<Invitation<string, never>>;
+            getPublicTopics(): {
+                metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../reserve/assetReserveKit.js").MetricsNotification>;
+            };
+        }>>;
+        timerService: globalThis.ERef<import("@agoric/time").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;
+    };
+    vaultFactoryPrivateArgs: {
+        auctioneerInstance: import("@agoric/internal/src/tagged.js").TagContainer<any> & import("@endo/pass-style").RemotableObject & Handle<"Instance">;
+        feeMintAccess: FeeMintAccess;
+        initialPoserInvitation: import("@endo/pass-style").RemotableObject & import("@agoric/ertp").PaymentMethods<"set"> & {
+            [OfferReturn]?: unknown;
+            [OfferArgs]?: undefined;
+        };
+        initialShortfallInvitation: import("@endo/pass-style").RemotableObject & import("@agoric/ertp").PaymentMethods<"set"> & {
+            [OfferReturn]?: import("@endo/exo").Guarded<{
+                increaseLiquidationShortfall(shortfall: Amount<"nat">): void;
+                reduceLiquidationShortfall(reduction: Amount<"nat">): void;
+            }> | undefined;
+            [OfferArgs]?: undefined;
+        };
+        marshaller: import("@endo/exo").Guarded<{
+            toCapData(val: any): import("@endo/marshal").CapData<string | null>;
+            fromCapData(data: any): any;
+            serialize(data: any): import("@endo/marshal").CapData<string | null>;
+            unserialize(data: any): any;
+        }>;
+        storageNode: globalThis.StorageNode;
+    };
+}>;
+export function startVaultFactory({ consume, produce: { vaultFactoryKit }, brand: { consume: { [Stable.symbol]: centralBrandP }, }, instance: { produce: instanceProduce }, installation: { consume: { VaultFactory: vaultFactoryInstallation, contractGovernor: contractGovernorInstallation, }, }, }: EconomyBootstrapPowers, config: {
+    interestTiming?: InterestTiming | undefined;
+    options?: {
+        referencedUi?: string | undefined;
+    } | undefined;
+}, minInitialDebt?: bigint): Promise<void>;
+export function grantVaultFactoryControl({ consume: { client, priceAuthorityAdmin, vaultFactoryKit } }: EconomyBootstrapPowers, { options: { vaultFactoryControllerAddress } }?: {
+    options?: {
+        vaultFactoryControllerAddress?: string | undefined;
+    } | undefined;
+} | undefined): Promise<void>;
+export function startRewardDistributor({ consume: { chainTimerService, bankManager, vaultFactoryKit, periodicFeeCollectors, reserveKit, zoe, }, produce: { feeDistributorKit, periodicFeeCollectors: periodicFeeCollectorsP }, instance: { produce: { feeDistributor: feeDistributorP }, }, installation: { consume: { feeDistributor }, }, issuer: { consume: { [Stable.symbol]: centralIssuerP }, }, brand: { consume: { [Stable.symbol]: centralBrandP }, }, }: EconomyBootstrapPowers): Promise<void>;
+export function startAuctioneer({ consume: { zoe, board, chainTimerService, priceAuthority, chainStorage, economicCommitteeCreatorFacet: electorateCreatorFacet, }, produce: { auctioneerKit }, instance: { produce: { auctioneer: auctionInstance }, consume: { reserve: reserveInstance }, }, installation: { consume: { auctioneer: auctionInstallation, contractGovernor: contractGovernorInstallation, }, }, issuer: { consume: { [Stable.symbol]: stableIssuerP }, }, }: EconomyBootstrapPowers, { auctionParams, }?: {
+    auctionParams?: any;
+}): Promise<void>;
+export type VaultFactoryPublicFacet = Awaited<ReturnType<(zcf: VaultFactoryZCF, privateArgs: {
+    feeMintAccess: FeeMintAccess;
+    initialPoserInvitation: Invitation;
+    initialShortfallInvitation: Invitation;
+    storageNode: ERef<StorageNode>;
+    marshaller: ERef<Marshaller>;
+    auctioneerInstance: Instance;
+    managerParams: Record<string, import("../vaultFactory/params.js").VaultManagerParamOverrides>;
+    directorParamOverrides: [object];
+}, baggage: import("@agoric/swingset-liveslots").Baggage) => Promise<{
+    creatorFacet: import("@endo/exo").Guarded<{
+        getParamMgrRetriever: () => {
+            get: (paramPath?: VaultFactoryParamPath) => import("../vaultFactory/vaultDirector.js").VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                DebtLimit: "amount";
+                InterestRate: "ratio";
+                LiquidationPadding: "ratio";
+                LiquidationMargin: "ratio";
+                LiquidationPenalty: "ratio";
+                MintFee: "ratio";
+            }>;
+        } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: (paramPath?: VaultFactoryParamPath) => import("../vaultFactory/vaultDirector.js").VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                DebtLimit: "amount";
+                InterestRate: "ratio";
+                LiquidationPadding: "ratio";
+                LiquidationMargin: "ratio";
+                LiquidationPenalty: "ratio";
+                MintFee: "ratio";
+            }>;
+        }>;
+        getInvitation(name: string): Promise<Invitation<unknown, undefined>>;
+        getLimitedCreatorFacet(): import("@endo/exo").Guarded<{
+            addVaultType(collateralIssuer: Issuer<"nat">, collateralKeyword: Keyword, initialParamValues: VaultManagerParamValues): Promise<import("@endo/exo").Guarded<{
+                getGovernedParams(): import("../vaultFactory/vaultManager.js").GovernedParamGetters;
+                makeVaultKit(seat: ZCFSeat): Promise<{
+                    publicSubscribers: {
+                        vault: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<VaultNotification>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    invitationMakers: import("@endo/exo").Guarded<{
+                        AdjustBalances(): Promise<Invitation<string, undefined>>;
+                        CloseVault(): Promise<Invitation<string, undefined>>;
+                        TransferVault(): Promise<Invitation<any, undefined>>;
+                    }>;
+                    vault: import("@endo/exo").Guarded<{
+                        getPublicTopics(): {
+                            vault: {
+                                description: string;
+                                subscriber: globalThis.Subscriber<VaultNotification>;
+                                storagePath: Promise<string>;
+                            };
+                        };
+                        makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                        makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                        makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                        getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                        getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                        getNormalizedDebt(): import("../vaultFactory/storeUtils.js").NormalizedDebt;
+                    }>;
+                    vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                }>;
+                getCollateralQuote(): import("@agoric/zoe/tools/types.js").PriceQuote;
+                getPublicFacet(): import("@endo/exo").Guarded<{
+                    makeVaultInvitation(): Promise<Invitation<{
+                        publicSubscribers: {
+                            vault: {
+                                description: string;
+                                subscriber: globalThis.Subscriber<VaultNotification>;
+                                storagePath: Promise<string>;
+                            };
+                        };
+                        invitationMakers: import("@endo/exo").Guarded<{
+                            AdjustBalances(): Promise<Invitation<string, undefined>>;
+                            CloseVault(): Promise<Invitation<string, undefined>>;
+                            TransferVault(): Promise<Invitation<any, undefined>>;
+                        }>;
+                        vault: import("@endo/exo").Guarded<{
+                            getPublicTopics(): {
+                                vault: {
+                                    description: string;
+                                    subscriber: globalThis.Subscriber<VaultNotification>;
+                                    storagePath: Promise<string>;
+                                };
+                            };
+                            makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                            makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                            makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                            getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                            getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                            getNormalizedDebt(): import("../vaultFactory/storeUtils.js").NormalizedDebt;
+                        }>;
+                        vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                    }, undefined>>;
+                    getQuotes(): import("@agoric/notifier").StoredNotifier<import("@agoric/zoe/tools/types.js").PriceQuote>;
+                    getCompoundedInterest(): Ratio;
+                    getPublicTopics(): {
+                        asset: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../vaultFactory/vaultManager.js").AssetState>;
+                        metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../vaultFactory/vaultManager.js").MetricsNotification>;
+                    };
+                }>;
+                lockOraclePrices(): import("@agoric/zoe/tools/types.js").PriceQuote;
+                liquidateVaults(auctionPF: ERef<AuctioneerPublicFacet>): Promise<void>;
+            }>>;
+            makeCollectFeesInvitation(): Promise<Invitation<string, undefined>>;
+            getRewardAllocation(): Allocation;
+            makeLiquidationWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            makeReschedulerWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            makePriceLockWaker(): {
+                wake: (timestamp: any) => any;
+            } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                wake: (timestamp: any) => any;
+            }>;
+            setShortfallReporter(newInvitation: any): Promise<void>;
+        }>;
+        getGovernedApis(): ERef<GovernedApis>;
+        getGovernedApiNames(): never[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    }>;
+    publicFacet: import("@endo/exo").Guarded<{
+        getCollateralManager(brandIn: Brand): import("@endo/exo").Guarded<{
+            makeVaultInvitation(): Promise<Invitation<{
+                publicSubscribers: {
+                    vault: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<VaultNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                invitationMakers: import("@endo/exo").Guarded<{
+                    AdjustBalances(): Promise<Invitation<string, undefined>>;
+                    CloseVault(): Promise<Invitation<string, undefined>>;
+                    TransferVault(): Promise<Invitation<any, undefined>>;
+                }>;
+                vault: import("@endo/exo").Guarded<{
+                    getPublicTopics(): {
+                        vault: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<VaultNotification>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                    makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                    makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                    getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                    getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                    getNormalizedDebt(): import("../vaultFactory/storeUtils.js").NormalizedDebt;
+                }>;
+                vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+            }, undefined>>;
+            getQuotes(): import("@agoric/notifier").StoredNotifier<import("@agoric/zoe/tools/types.js").PriceQuote>;
+            getCompoundedInterest(): Ratio;
+            getPublicTopics(): {
+                asset: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../vaultFactory/vaultManager.js").AssetState>;
+                metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../vaultFactory/vaultManager.js").MetricsNotification>;
+            };
+        }>;
+        getDebtIssuer(): globalThis.Issuer<"nat", import("@endo/patterns").Key>;
+        getSubscription({ collateralBrand }: {
+            collateralBrand: Brand;
+        }): globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../vaultFactory/vaultDirector.js").MetricsNotification>;
+        };
+        getElectorateSubscription(): globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+        getGovernedParams({ collateralBrand }: {
+            collateralBrand: Brand;
+        }): globalThis.ERef<globalThis.ParamStateRecord>;
+        getInvitationAmount(name: string): import("@agoric/ertp").SetAmount<InvitationDetails>;
+    }>;
+}>>>["publicFacet"];
+export type PSMKit = {
+    label: string;
+    psm: Instance;
+    psmGovernor: Instance;
+    psmCreatorFacet: Awaited<ReturnType<Awaited<ReturnType<typeof import("../psm/psm.js")["start"]>>["creatorFacet"]["getLimitedCreatorFacet"]>>;
+    psmGovernorCreatorFacet: GovernorCreatorFacet<typeof import("../psm/psm.js")["start"]>;
+    psmAdminFacet: AdminFacet;
+};
+export type AuctioneerKit = GovernanceFacetKit<(zcf: ZCF<GovernanceTerms<typeof import("../auction/params.js").auctioneerParamTypes> & {
+    timerService: import("@agoric/time").TimerService;
+    reservePublicFacet: AssetReservePublicFacet;
+    priceAuthority: import("@agoric/zoe/tools/types.js").PriceAuthority;
+}>, privateArgs: {
+    initialPoserInvitation: Invitation;
+    storageNode: StorageNode;
+    marshaller: Marshaller;
+}, baggage: import("@agoric/vat-data").Baggage) => Promise<{
+    publicFacet: globalThis.GovernedPublicFacet<{
+        getElectorate: () => import("@agoric/ertp").SetAmount<import("@endo/patterns").Key>;
+        getStartFrequency: () => RelativeTime;
+        getClockStep: () => RelativeTime;
+        getStartingRate: () => bigint;
+        getLowestRate: () => bigint;
+        getDiscountStep: () => bigint;
+        getAuctionStartDelay: () => RelativeTime;
+        getPriceLockPeriod: () => RelativeTime;
+        makeBidInvitation(collateralBrand: Brand<"nat">): Promise<Invitation<string, import("../auction/auctionBook.js").OfferSpec>>;
+        getSchedules(): {
+            liveAuctionSchedule: import("../auction/scheduler.js").Schedule | null;
+            nextAuctionSchedule: import("../auction/scheduler.js").Schedule | null;
+        };
+        getScheduleUpdates(): globalThis.Subscriber<import("../auction/scheduler.js").ScheduleNotification>;
+        getBookDataUpdates(brand: any): globalThis.Subscriber<import("../auction/auctionBook.js").BookDataNotification>;
+        getPublicTopics(brand: any): {
+            bookData: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../auction/auctionBook.js").BookDataNotification>;
+        } | {
+            schedule: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../auction/scheduler.js").ScheduleNotification>;
+        };
+        makeDepositInvitation: () => Promise<Invitation<string, {
+            goal: Amount<"nat">;
+        }>>;
+    }>;
+    creatorFacet: globalThis.GovernedCreatorFacet<{
+        addBrand(issuer: Issuer<"nat">, kwd: Keyword): Promise<void>;
+        getSchedule(): Promise<import("../auction/scheduler.js").FullSchedule>;
+    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        addBrand(issuer: Issuer<"nat">, kwd: Keyword): Promise<void>;
+        getSchedule(): Promise<import("../auction/scheduler.js").FullSchedule>;
+    }>>;
+}>>;
+export type EconomyBootstrapPowers = WellKnownSpaces & ChainBootstrapSpace & EconomyBootstrapSpace;
+export type EconomyBootstrapSpace = PromiseSpaceOf<{
+    economicCommitteeKit: CommitteeStartResult;
+    economicCommitteeCreatorFacet: import("@agoric/governance/src/committee.js").CommitteeElectorateCreatorFacet;
+    feeDistributorKit: StartedInstanceKit<typeof import("../feeDistributor.js").start>;
+    periodicFeeCollectors: MapStore<number, import("../feeDistributor.js").PeriodicFeeCollector>;
+    psmKit: MapStore<Brand, PSMKit>;
+    anchorBalancePayments: MapStore<Brand, Payment<"nat">>;
+    econCharterKit: EconCharterStartResult;
+    reserveKit: GovernanceFacetKit<typeof import("../reserve/assetReserve.js")["start"]>;
+    vaultFactoryKit: GovernanceFacetKit<(zcf: VaultFactoryZCF, privateArgs: {
+        feeMintAccess: FeeMintAccess;
+        initialPoserInvitation: Invitation;
+        initialShortfallInvitation: Invitation;
+        storageNode: ERef<StorageNode>;
+        marshaller: ERef<Marshaller>;
+        auctioneerInstance: Instance;
+        managerParams: Record<string, import("../vaultFactory/params.js").VaultManagerParamOverrides>;
+        directorParamOverrides: [object];
+    }, baggage: import("@agoric/swingset-liveslots").Baggage) => Promise<{
+        creatorFacet: import("@endo/exo").Guarded<{
+            getParamMgrRetriever: () => {
+                get: (paramPath?: VaultFactoryParamPath) => import("../vaultFactory/vaultDirector.js").VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                    DebtLimit: "amount";
+                    InterestRate: "ratio";
+                    LiquidationPadding: "ratio";
+                    LiquidationMargin: "ratio";
+                    LiquidationPenalty: "ratio";
+                    MintFee: "ratio";
+                }>;
+            } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                get: (paramPath?: VaultFactoryParamPath) => import("../vaultFactory/vaultDirector.js").VaultDirectorParamManager | import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                    DebtLimit: "amount";
+                    InterestRate: "ratio";
+                    LiquidationPadding: "ratio";
+                    LiquidationMargin: "ratio";
+                    LiquidationPenalty: "ratio";
+                    MintFee: "ratio";
+                }>;
+            }>;
+            getInvitation(name: string): Promise<Invitation<unknown, undefined>>;
+            getLimitedCreatorFacet(): import("@endo/exo").Guarded<{
+                addVaultType(collateralIssuer: Issuer<"nat">, collateralKeyword: Keyword, initialParamValues: VaultManagerParamValues): Promise<import("@endo/exo").Guarded<{
+                    getGovernedParams(): import("../vaultFactory/vaultManager.js").GovernedParamGetters;
+                    makeVaultKit(seat: ZCFSeat): Promise<{
+                        publicSubscribers: {
+                            vault: {
+                                description: string;
+                                subscriber: globalThis.Subscriber<VaultNotification>;
+                                storagePath: Promise<string>;
+                            };
+                        };
+                        invitationMakers: import("@endo/exo").Guarded<{
+                            AdjustBalances(): Promise<Invitation<string, undefined>>;
+                            CloseVault(): Promise<Invitation<string, undefined>>;
+                            TransferVault(): Promise<Invitation<any, undefined>>;
+                        }>;
+                        vault: import("@endo/exo").Guarded<{
+                            getPublicTopics(): {
+                                vault: {
+                                    description: string;
+                                    subscriber: globalThis.Subscriber<VaultNotification>;
+                                    storagePath: Promise<string>;
+                                };
+                            };
+                            makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                            makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                            makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                            getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                            getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                            getNormalizedDebt(): import("../vaultFactory/storeUtils.js").NormalizedDebt;
+                        }>;
+                        vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                    }>;
+                    getCollateralQuote(): import("@agoric/zoe/tools/types.js").PriceQuote;
+                    getPublicFacet(): import("@endo/exo").Guarded<{
+                        makeVaultInvitation(): Promise<Invitation<{
+                            publicSubscribers: {
+                                vault: {
+                                    description: string;
+                                    subscriber: globalThis.Subscriber<VaultNotification>;
+                                    storagePath: Promise<string>;
+                                };
+                            };
+                            invitationMakers: import("@endo/exo").Guarded<{
+                                AdjustBalances(): Promise<Invitation<string, undefined>>;
+                                CloseVault(): Promise<Invitation<string, undefined>>;
+                                TransferVault(): Promise<Invitation<any, undefined>>;
+                            }>;
+                            vault: import("@endo/exo").Guarded<{
+                                getPublicTopics(): {
+                                    vault: {
+                                        description: string;
+                                        subscriber: globalThis.Subscriber<VaultNotification>;
+                                        storagePath: Promise<string>;
+                                    };
+                                };
+                                makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                                makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                                makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                                getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                                getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                                getNormalizedDebt(): import("../vaultFactory/storeUtils.js").NormalizedDebt;
+                            }>;
+                            vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                        }, undefined>>;
+                        getQuotes(): import("@agoric/notifier").StoredNotifier<import("@agoric/zoe/tools/types.js").PriceQuote>;
+                        getCompoundedInterest(): Ratio;
+                        getPublicTopics(): {
+                            asset: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../vaultFactory/vaultManager.js").AssetState>;
+                            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../vaultFactory/vaultManager.js").MetricsNotification>;
+                        };
+                    }>;
+                    lockOraclePrices(): import("@agoric/zoe/tools/types.js").PriceQuote;
+                    liquidateVaults(auctionPF: ERef<AuctioneerPublicFacet>): Promise<void>;
+                }>>;
+                makeCollectFeesInvitation(): Promise<Invitation<string, undefined>>;
+                getRewardAllocation(): Allocation;
+                makeLiquidationWaker(): {
+                    wake: (timestamp: any) => any;
+                } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                    wake: (timestamp: any) => any;
+                }>;
+                makeReschedulerWaker(): {
+                    wake: (timestamp: any) => any;
+                } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                    wake: (timestamp: any) => any;
+                }>;
+                makePriceLockWaker(): {
+                    wake: (timestamp: any) => any;
+                } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                    wake: (timestamp: any) => any;
+                }>;
+                setShortfallReporter(newInvitation: any): Promise<void>;
+            }>;
+            getGovernedApis(): ERef<GovernedApis>;
+            getGovernedApiNames(): never[];
+            setOfferFilter: (strings: any) => Promise<void>;
+        }>;
+        publicFacet: import("@endo/exo").Guarded<{
+            getCollateralManager(brandIn: Brand): import("@endo/exo").Guarded<{
+                makeVaultInvitation(): Promise<Invitation<{
+                    publicSubscribers: {
+                        vault: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<VaultNotification>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    invitationMakers: import("@endo/exo").Guarded<{
+                        AdjustBalances(): Promise<Invitation<string, undefined>>;
+                        CloseVault(): Promise<Invitation<string, undefined>>;
+                        TransferVault(): Promise<Invitation<any, undefined>>;
+                    }>;
+                    vault: import("@endo/exo").Guarded<{
+                        getPublicTopics(): {
+                            vault: {
+                                description: string;
+                                subscriber: globalThis.Subscriber<VaultNotification>;
+                                storagePath: Promise<string>;
+                            };
+                        };
+                        makeAdjustBalancesInvitation(): Promise<Invitation<string, undefined>>;
+                        makeCloseInvitation(): Promise<Invitation<string, undefined>>;
+                        makeTransferInvitation(): Promise<Invitation<any, undefined>>;
+                        getCollateralAmount(): import("@agoric/ertp").NatAmount;
+                        getCurrentDebt(): import("@agoric/ertp").NatAmount;
+                        getNormalizedDebt(): import("../vaultFactory/storeUtils.js").NormalizedDebt;
+                    }>;
+                    vaultUpdater: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<VaultNotification>;
+                }, undefined>>;
+                getQuotes(): import("@agoric/notifier").StoredNotifier<import("@agoric/zoe/tools/types.js").PriceQuote>;
+                getCompoundedInterest(): Ratio;
+                getPublicTopics(): {
+                    asset: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../vaultFactory/vaultManager.js").AssetState>;
+                    metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../vaultFactory/vaultManager.js").MetricsNotification>;
+                };
+            }>;
+            getDebtIssuer(): globalThis.Issuer<"nat", import("@endo/patterns").Key>;
+            getSubscription({ collateralBrand }: {
+                collateralBrand: Brand;
+            }): globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+            getPublicTopics(): {
+                metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("../vaultFactory/vaultDirector.js").MetricsNotification>;
+            };
+            getElectorateSubscription(): globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+            getGovernedParams({ collateralBrand }: {
+                collateralBrand: Brand;
+            }): globalThis.ERef<globalThis.ParamStateRecord>;
+            getInvitationAmount(name: string): import("@agoric/ertp").SetAmount<InvitationDetails>;
+        }>;
+    }>>;
+    auctioneerKit: AuctioneerKit;
+    newAuctioneerKit: AuctioneerKit | undefined;
+    minInitialDebt: NatValue;
+}>;
+export type EconCharterStartResult = StartedInstanceKit<typeof import("../econCommitteeCharter.js")["start"]>;
+export type CommitteeStartResult = StartedInstanceKit<typeof import("@agoric/governance/src/committee.js")["start"]>;
+import { Stable } from '@agoric/internal/src/tokens.js';
+import type { StartedInstanceKit } from '@agoric/zoe/src/zoeService/utils.js';
+//# sourceMappingURL=econ-behaviors.d.ts.map

package/src/proposals/econ-behaviors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"econ-behaviors.d.ts","sourceRoot":"","sources":["econ-behaviors.js"],"names":[],"mappings":"AAgBA,qCAAsC;AACtC,sCAA0C;AAC1C,qCAAsD;AACtD,sCAAqD;AAwE9C,mcADK,sBAAsB;;;;;;;;;;;;;;;;;;;;;;KA+FjC;AAUM,oDAPI,sBAAsB,CAAC,SAAS,CAAC,kDAEzC;IAAgC,cAAc;IACtB,OAAO;;;CAE/B,8BAAQ,MAAM,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EvB;AAUM,wSAPI,sBAAsB,UAE9B;IAAgC,cAAc;IACtB,OAAO;;;CAE/B,mBAAQ,MAAM,iBA6FhB;AAWM,wGALI,sBAAsB;;;;8BAuBhC;AAQM,mcAFI,sBAAsB,iBA0GhC;AAQM,+cAJI,sBAAsB,uBAE9B;IAAqB,aAAa,GAA1B,GAAG;CAAwB,iBA0HrC;sCAxmBa,OAAO,CAAC,UAAU;;;;;;;yCA2D2C,2BACpE;;mBAGW,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA/DL,CAAC,CAAC,aAAa,CAAC;;WAI3C,MAAM;SACN,QAAQ;iBACR,QAAQ;qBACR,OAAO,CAChB,UAAU,CACR,OAAO,CACL,UAAU,CAAC,8BAAuB,CAAC,OAAO,CAAC,CAAC,CAC7C,CAAC,cAAc,CAAC,CAAC,wBAAwB,CAAC,CAC5C,CACF;6BACU,oBAAoB,CAAC,8BAA8B,CAAC,OAAO,CAAC,CAAC;mBAC7D,UAAU;;4BAGV,kBAAkB,CAAC;yBA8f3B,cAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sCAyFi4N,yBAAgB;;;;;EAvlBr1N,CAAC;qCAG7D,eAAe,GAAG,mBAAmB,GAAG,qBAAqB;oCAG7D,cAAc,CAAC;IACvB,oBAAoB,EAAE,oBAAoB,CAAC;IAC3C,6BAA6B,EAAE,OAAO,qCAAqC,EAAE,+BAA+B,CAAC;IAC7G,iBAAiB,EAAE,mBACvB,cAAoB,sBAAsB,EAAE,KAAK,CAC5C,CAAC;IACF,qBAAqB,EAAE,QAAQ,CACnC,MAAY,EACZ,OAAa,sBAAsB,EAAE,oBAAoB,CACpD,CAAC;IACF,MAAM,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAChC,qBAAqB,EAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;IACvD,cAAc,EAAE,sBAAsB,CAAC;IACvC,UAAU,EAAE,kBAAkB,CAClC,2CAA0C,CAAC,OAAO,CAAC,CAC9C,CAAC;IACF,eAAe,EAAE,kBAAkB;;;;;;;6CAmBmC,2BACpE;;uBAGW,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAvBG,CAAC;IAC7C,aAAa,EAAE,aAAa,CAAC;IAC7B,gBAAgB,EAAE,aAAa,GAAG,SAAS,CAAC;IAC5C,cAAc,EAAE,QAAQ,CAAC;CAC1B,CAAC;qCAIQ,mBACZ,2CAAwC,CAAC,OAAO,CAAC,CAC9C;mCAGS,mBACZ,oDAAiD,CAAC,OAAO,CAAC,CACvD;uBAtEmB,gCAAgC;wCAKjB,qCAAqC"}