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

package/src/provisionPoolKit.d.ts

@@ -0,0 +1,81 @@
+export function prepareBridgeProvisionTool(zone: Zone): (bankManager: ERef<import("@endo/exo").Guarded<{
+    getAssetSubscription(): import("@agoric/notifier").IterableEachTopic<AssetDescriptor>;
+    getRewardDistributorDepositFacet(denom: string, feeKit: AssetIssuerKit): ERef<import("@endo/far").EOnly<import("@agoric/ertp").DepositFacet>>;
+    getModuleAccountAddress(moduleName: string): Promise<string | null>;
+    addAsset(denom: string, issuerName: string, proposedName: string, kit: AssetIssuerKit & {
+        payment?: ERef<Payment<"nat">>;
+    }): Promise<void>;
+    getBankForAddress(address: string): Promise<Bank>;
+}>>, walletFactory: ERef<import("@endo/exo").Guarded<{
+    provideSmartWallet(address: string, bank: ERef<Bank>, namesByAddressAdmin: ERef<NameAdmin>): Promise<[wallet: import("@agoric/smart-wallet/src/smartWallet.js").SmartWallet, isNew: boolean]>;
+}>>, namesByAddressAdmin: ERef<NameAdmin>, forHandler: any) => import("@endo/exo").Guarded<{
+    /** @param {BridgeMessage} obj */
+    fromBridge(obj: BridgeMessage): Promise<void>;
+}>;
+export function prepareProvisionPoolKit(zone: Zone, { makeRecorderKit, params, poolBank, zcf, makeBridgeProvisionTool }: {
+    makeRecorderKit: MakeRecorderKit;
+    params: any;
+    poolBank: ERef<Bank>;
+    zcf: ZCF;
+    makeBridgeProvisionTool: ReturnType<typeof prepareBridgeProvisionTool>;
+}): ({ poolBrand, storageNode }: {
+    poolBrand: Brand<"nat">;
+    storageNode: ERemote<StorageNode>;
+}) => Promise<ProvisionPoolKit>;
+export type ProvisionPoolKit = {
+    machine: {
+        addRevivableAddresses: (oldAddresses: string[]) => void;
+        getWalletReviver: () => ERef<any>;
+        setReferences: (erefs: ProvisionPoolKitReferences) => Promise<void>;
+        makeHandler: () => ERef<BridgeHandler>;
+        initPSM: (brand: Brand, instance: Instance<typeof psmStart>) => void;
+    };
+    helper: any;
+    forHandler: any;
+    public: any;
+};
+export type PsmInstance = Instance<typeof psmStart>;
+export type ProvisionPoolKitReferences = {
+    bankManager: ERef<BankManager>;
+    namesByAddressAdmin: ERef<NameAdmin>;
+    walletFactory: ERef<WalletFactoryStartResult["creatorFacet"]>;
+};
+/**
+ * Metrics naming scheme is that nouns are
+ *   present values and past-participles are accumulative.
+ */
+export type MetricsNotification = {
+    /**
+     * count of new wallets provisioned
+     */
+    walletsProvisioned: bigint;
+    /**
+     * running sum of Minted provided
+     * to new wallets
+     */
+    totalMintedProvided: Amount<"nat">;
+    /**
+     * running sum of Minted ever
+     * received by the contract from PSM
+     */
+    totalMintedConverted: Amount<"nat">;
+};
+import type { Zone } from '@agoric/zone';
+import type { AssetDescriptor } from '@agoric/vats/src/vat-bank.js';
+import type { ERef } from '@endo/far';
+import type { Payment } from '@agoric/ertp';
+import type { Bank } from '@agoric/vats/src/vat-bank.js';
+import type { NameAdmin } from '@agoric/vats';
+import type { BridgeMessage } from '@agoric/cosmic-swingset/src/types.js';
+import type { MakeRecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
+import type { ZCF } from '@agoric/zoe';
+import type { Brand } from '@agoric/ertp';
+import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
+import type { ERemote } from '@agoric/internal';
+import type { BridgeHandler } from '@agoric/vats';
+import type { start as psmStart } from '@agoric/inter-protocol/src/psm/psm.js';
+import type { Instance } from '@agoric/zoe/src/zoeService/utils.js';
+import type { BankManager } from '@agoric/vats/src/vat-bank.js';
+import type { WalletFactoryStartResult } from '@agoric/vats/src/core/startWalletFactory.js';
+import type { Amount } from '@agoric/ertp';
+//# sourceMappingURL=provisionPoolKit.d.ts.map

package/src/provisionPoolKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provisionPoolKit.d.ts","sourceRoot":"","sources":["provisionPoolKit.js"],"names":[],"mappings":"AAiGO,iDAFI,IAAI;;;;;eA2gBgY,CAAC;;;;;;IAtf1Y,iCAAiC;oBAArB,aAAa;GA6B5B;AAYI,8CATI,IAAI,uEACJ;IACN,eAAe,EAAE,eAAe,CAAC;IACjC,MAAM,EAAE,GAAG,CAAC;IACZ,QAAQ,EAAE,KAAK,IAAI,CAAC,CAAC;IACrB,GAAG,EAAE,GAAG,CAAC;IACT,uBAAuB,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC;CACxE,gCA6bC;IAA2B,SAAS,EAA5B,MAAM,KAAK,CAAC;IACe,WAAW,EAAtC,QAAQ,WAAW,CAAC;CAC5B,KAAU,OAAO,CAAC,gBAAgB,CAAC,CAevC;+BAjjBY;IACR,OAAO,EAAE;QACP,qBAAqB,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;QACxD,gBAAgB,EAAE,MAAM,KAAK,GAAG,CAAC,CAAC;QAClC,aAAa,EAAE,CAAC,KAAK,EAAE,0BAA0B,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QACpE,WAAW,EAAE,MAAM,KAAK,aAAa,CAAC,CAAC;QACvC,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,eAAe,CAAC,KAAK,IAAI,CAAC;KACtE,CAAC;IACF,MAAM,EAAE,GAAG,CAAC;IACZ,UAAU,EAAE,GAAG,CAAC;IAChB,MAAM,EAAE,GAAG,CAAC;CACb;0BAIS,SAAS,eAAe,CAAC;;iBAKxB,KAAK,WAAW,CAAC;yBACjB,KAAK,SAAS,CAAC;mBACf,KAAK,wBAAwB,CAAC,cAAc,CAAC,CAAC;;;;;;;;;;wBAM9C,MAAM;;;;;yBACN,OAAO,KAAK,CAAC;;;;;0BAEb,OAAO,KAAK,CAAC;;0BA/CJ,cAAc;qCAKH,8BAA8B;0BAZzC,WAAW;6BAJc,cAAc;0BAK1B,8BAA8B;+BAItC,cAAc;mCAVV,sCAAsC;qCAcpC,6CAA6C;yBAVzD,aAAa;2BAHa,cAAc;iCAEhC,0CAA0C;6BADtC,kBAAkB;mCAcpB,cAAc;uCAPV,uCAAuC;8BADhD,qCAAqC;iCAF5B,8BAA8B;8CAKvB,6CAA6C;4BAVxC,cAAc"}

package/src/psm/psm.d.ts

@@ -0,0 +1,145 @@
+/**
+ * @file The Parity Stability Module supports efficiently minting/burning a
+ *   stable token at a specified fixed ratio to a reference stable token, which
+ *   thereby acts as an anchor to provide additional stability. For flexible
+ *   economic policies, the fee percentage for trading into and out of the
+ *   stable token are specified separately.
+ */
+/**
+ * @import {EReturn} from '@endo/far';
+ * @import {TypedPattern, Remote} from '@agoric/internal';
+ * @import {Baggage} from '@agoric/vat-data'
+ * @import {ContractMeta, FeeMintAccess, Invitation, ZCF, ZCFSeat} from '@agoric/zoe';
+ * @import {Ratio} from '@agoric/ertp';
+ * @import {GovernanceTerms} from '@agoric/governance/src/types.js';
+ * @import {Amount} from '@agoric/ertp';
+ * @import {Brand} from '@agoric/ertp';
+ * @import {StorageNode} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {Marshaller} from '@agoric/internal/src/lib-chainStorage.js';
+ */
+/**
+ * @typedef {object} MetricsNotification Metrics naming scheme is that nouns are
+ *   present values and past-participles are accumulative.
+ * @property {Amount<'nat'>} anchorPoolBalance amount of Anchor token available
+ *   to be swapped
+ * @property {Amount<'nat'>} mintedPoolBalance amount of Minted token
+ *   outstanding (the amount minted minus the amount burned).
+ * @property {Amount<'nat'>} feePoolBalance amount of Minted token fees
+ *   available to be collected
+ * @property {Amount<'nat'>} totalAnchorProvided running sum of Anchor ever
+ *   given by this contract
+ * @property {Amount<'nat'>} totalMintedProvided running sum of Minted ever
+ *   given by this contract
+ */
+/** @type {ContractMeta<typeof start>} */
+export const meta: ContractMeta<typeof start>;
+export function start(zcf: ZCF<GovernanceTerms<{
+    GiveMintedFee: "ratio";
+    WantMintedFee: "ratio";
+    MintLimit: "amount";
+}> & {
+    anchorBrand: Brand<"nat">;
+    anchorPerMinted: Ratio;
+}>, privateArgs: {
+    feeMintAccess: FeeMintAccess;
+    initialPoserInvitation: Invitation;
+    storageNode: Remote<StorageNode>;
+    marshaller: Remote<Marshaller>;
+}, baggage: Baggage): Promise<{
+    creatorFacet: import("@endo/exo").Guarded<{
+        getParamMgrRetriever: () => {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                GiveMintedFee: "ratio";
+                MintLimit: "amount";
+                WantMintedFee: "ratio";
+            } & {
+                Electorate: "invitation";
+            }>;
+        } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                GiveMintedFee: "ratio";
+                MintLimit: "amount";
+                WantMintedFee: "ratio";
+            } & {
+                Electorate: "invitation";
+            }>;
+        }>;
+        getInvitation: (name: any) => Promise<Invitation>;
+        getLimitedCreatorFacet: () => import("@endo/exo").Guarded<{
+            getRewardAllocation(): import("@agoric/zoe").Allocation;
+            makeCollectFeesInvitation(): Promise<Invitation<string>>;
+            makeRestoreMetricsInvitation(): Promise<Invitation<void, Omit<MetricsNotification, "anchorPoolBalance">>>;
+        }>;
+        getGovernedApis: () => import("@agoric/governance").GovernedApis;
+        getGovernedApiNames: () => string[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    }>;
+    publicFacet: import("@endo/exo").Guarded<{
+        getAmount: (name: string) => Amount;
+        getBrand: (name: string) => Brand;
+        getInstance: (name: string) => import("@agoric/zoe").Instance;
+        getInstallation: (name: string) => import("@agoric/zoe").Installation;
+        getInvitationAmount: (name: string) => import("@agoric/zoe").InvitationAmount;
+        getNat: (name: string) => bigint;
+        getRatio: (name: string) => Ratio;
+        getString: (name: string) => string;
+        getTimestamp: (name: string) => import("@agoric/time").TimestampRecord;
+        getRelativeTime: (name: string) => import("@agoric/time").RelativeTimeRecord;
+        getUnknown: (name: string) => any;
+        getSubscription: () => import("@agoric/notifier").StoredSubscription<import("@agoric/governance").GovernanceSubscriptionState>;
+        getGovernedParams: () => import("@endo/eventual-send").ERef<import("@agoric/governance").ParamStateRecord>;
+        getMetrics(): import("@agoric/notifier").Subscriber<MetricsNotification>;
+        getPoolBalance(): import("@agoric/ertp").NatAmount;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<MetricsNotification>;
+        };
+        makeWantMintedInvitation(): Promise<Invitation<void, undefined>>;
+        makeGiveMintedInvitation(): Promise<Invitation<void, undefined>>;
+    }>;
+}>;
+/**
+ * Metrics naming scheme is that nouns are
+ *   present values and past-participles are accumulative.
+ */
+export type MetricsNotification = {
+    /**
+     * amount of Anchor token available
+     * to be swapped
+     */
+    anchorPoolBalance: Amount<"nat">;
+    /**
+     * amount of Minted token
+     * outstanding (the amount minted minus the amount burned).
+     */
+    mintedPoolBalance: Amount<"nat">;
+    /**
+     * amount of Minted token fees
+     * available to be collected
+     */
+    feePoolBalance: Amount<"nat">;
+    /**
+     * running sum of Anchor ever
+     * given by this contract
+     */
+    totalAnchorProvided: Amount<"nat">;
+    /**
+     * running sum of Minted ever
+     * given by this contract
+     */
+    totalMintedProvided: Amount<"nat">;
+};
+export type PsmPublicFacet = EReturn<typeof start>["publicFacet"];
+import type { ContractMeta } from '@agoric/zoe';
+import type { GovernanceTerms } from '@agoric/governance/src/types.js';
+import type { Brand } from '@agoric/ertp';
+import type { Ratio } from '@agoric/ertp';
+import type { ZCF } from '@agoric/zoe';
+import type { FeeMintAccess } from '@agoric/zoe';
+import type { Invitation } from '@agoric/zoe';
+import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
+import type { Remote } from '@agoric/internal';
+import type { Marshaller } from '@agoric/internal/src/lib-chainStorage.js';
+import type { Baggage } from '@agoric/vat-data';
+import type { Amount } from '@agoric/ertp';
+import type { EReturn } from '@endo/far';
+//# sourceMappingURL=psm.d.ts.map

package/src/psm/psm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psm.d.ts","sourceRoot":"","sources":["psm.js"],"names":[],"mappings":"AAkCA;;;;;;GAMG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;GAaG;AAEH,yCAAyC;AACzC,mBADW,aAAa,OAAO,KAAK,CAAC,CAmCnC;AAsBK,2BAlBI,IACV,gBAAoB;IACd,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,QAAQ,CAAC;CACrB,CAAC,GAAG;IACH,WAAW,EAAE,MAAM,KAAK,CAAC,CAAC;IAC1B,eAAe,EAAE,KAAK,CAAC;CACxB,CACF,eACO;IACN,aAAa,EAAE,aAAa,CAAC;IAC7B,sBAAsB,EAAE,UAAU,CAAC;IACnC,WAAW,EAAE,OAAO,WAAW,CAAC,CAAC;IACjC,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;CAChC,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqUjB;;;;;;;;;;uBAxYa,OAAO,KAAK,CAAC;;;;;uBAEb,OAAO,KAAK,CAAC;;;;;oBAEb,OAAO,KAAK,CAAC;;;;;yBAEb,OAAO,KAAK,CAAC;;;;;yBAEb,OAAO,KAAK,CAAC;;6BAmYb,QAAQ,OAAO,KAAK,CAAb,CAAe,aAAa,CAAC;kCAvZsB,aAAa;qCAEnD,iCAAiC;2BAE3C,cAAc;2BAHd,cAAc;yBADkC,aAAa;mCAAb,aAAa;gCAAb,aAAa;iCAKvD,0CAA0C;4BAPjC,kBAAkB;gCAQ5B,0CAA0C;6BAP7C,kBAAkB;4BAInB,cAAc;6BANb,WAAW"}

package/src/reserve/assetReserve.d.ts

@@ -0,0 +1,68 @@
+/** @type {ContractMeta<typeof start>} */
+export const meta: ContractMeta<typeof start>;
+export function start(zcf: ZCF<GovernanceTerms<{}> & {
+    governedApis: ["burnFeesToReduceShortfall"];
+}>, privateArgs: {
+    feeMintAccess: FeeMintAccess;
+    initialPoserInvitation: Invitation;
+    marshaller: ERemote<Marshaller>;
+    storageNode: ERemote<StorageNode>;
+}, baggage: Baggage): Promise<{
+    /** @type {GovernedCreatorFacet<typeof assetReserveKit.machine>} */
+    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>>;
+        makeSingleWithdrawalInvitation(): Promise<Invitation<any, undefined>>;
+        makeRepeatableWithdrawalInvitation(): Promise<Invitation<{
+            invitationMakers: Partial<any>;
+        }, undefined>>;
+        revokeOutstandingWithdrawalInvitations(): void;
+    }>>;
+    /** @type {GovernedPublicFacet<typeof assetReserveKit.public>} */
+    publicFacet: GovernedPublicFacet<import("@endo/exo").Guarded<{
+        makeAddCollateralInvitation(): Promise<Invitation<string, never>>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./assetReserveKit.js").MetricsNotification>;
+        };
+    }>>;
+}>;
+export type ShortfallReportingFacet = {
+    increaseLiquidationShortfall: (increase: Amount) => void;
+    reduceLiquidationShortfall: (reduction: Amount) => void;
+};
+export type ShortfallReporter = {
+    increaseLiquidationShortfall: (shortfall: Amount) => void;
+    reduceLiquidationShortfall: (shortfall: Amount) => void;
+};
+export type AssetReserveLimitedCreatorFacet = {
+    addIssuer: (issuer: Issuer, kwd: string) => void;
+    getAllocations: () => Allocation;
+    makeShortfallReportingInvitation: () => Promise<Invitation<ShortfallReporter>>;
+};
+export type AssetReservePublicFacet = EReturn<typeof start>["publicFacet"];
+/**
+ * the creator facet for the governor
+ */
+export type AssetReserveCreatorFacet = EReturn<typeof start>["creatorFacet"];
+export type ReserveContract = ContractOf<typeof start>;
+import type { ContractMeta } from '@agoric/zoe';
+import type { GovernanceTerms } from '@agoric/governance/src/types.js';
+import type { ZCF } from '@agoric/zoe';
+import type { FeeMintAccess } from '@agoric/zoe';
+import type { Invitation } from '@agoric/zoe';
+import type { Marshaller } from '@agoric/internal/src/lib-chainStorage.js';
+import type { ERemote } from '@agoric/internal';
+import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
+import type { Baggage } from '@agoric/vat-data';
+import type { Issuer } from '@agoric/ertp';
+import type { Allocation } from '@agoric/zoe';
+import type { Amount } from '@agoric/ertp';
+import type { GovernedCreatorFacet } from '@agoric/governance/src/types.js';
+import type { GovernedPublicFacet } from '@agoric/governance/src/types.js';
+import type { EReturn } from '@endo/far';
+import type { ContractOf } from '@agoric/zoe/src/zoeService/utils.js';
+//# sourceMappingURL=assetReserve.d.ts.map

package/src/reserve/assetReserve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assetReserve.d.ts","sourceRoot":"","sources":["assetReserve.js"],"names":[],"mappings":"AAyBA,yCAAyC;AACzC,mBADW,aAAa,OAAO,KAAK,CAAC,CAGnC;AA8BK,2BAbI,IACV,gBAAoB,EAAE,CAAC,GAAG;IACpB,YAAY,EAAE,CAAC,2BAA2B,CAAC,CAAC;CAC7C,CACF,eACO;IACN,aAAa,EAAE,aAAa,CAAC;IAC7B,sBAAsB,EAAE,UAAU,CAAC;IACnC,UAAU,EAAE,QAAQ,UAAU,CAAC,CAAC;IAChC,WAAW,EAAE,QAAQ,WAAW,CAAC,CAAC;CACnC,WACO,OAAO;IAuDd,mEAAmE;kBAAxD;;;;;;;;;;;;OAAoD;IAE/D,iEAAiE;iBAAtD;;;;;OAAkD;GAKhE;sCAtFY;IACR,4BAA4B,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACzD,0BAA0B,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CACzD;;kCAwFU,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI;gCAC3B,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI;;;eAK3B,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI;oBACrC,MAAM,UAAU;sCAChB,MAAM,OAAO,CAAC,WAAW,iBAAiB,CAAC,CAAC;;sCAG5C,QAAQ,OAAO,KAAK,CAAb,CAAe,aAAa,CAAC;;;;uCAErC,QAAQ,OAAO,KAAK,CAAb,CAAe,cAAc,CAAC;8BAIpC,WAAW,OAAO,KAAK,CAAC;kCA9HqC,aAAa;qCACtD,iCAAiC;yBADQ,aAAa;mCAAb,aAAa;gCAAb,aAAa;gCAM9C,0CAA0C;6BAV1D,kBAAkB;iCAUF,0CAA0C;6BAT1D,kBAAkB;4BAQnB,cAAc;gCALoC,aAAa;4BAI/D,cAAc;0CAFA,iCAAiC;yCAClC,iCAAiC;6BAL7C,WAAW;gCACR,qCAAqC"}

package/src/reserve/assetReserveKit.d.ts

@@ -0,0 +1,106 @@
+export function prepareAssetReserveKit(baggage: Baggage, { feeMint, makeRecorderKit, storageNode, zcf }: {
+    feeMint: ZCFMint<"nat">;
+    makeRecorderKit: MakeRecorderKit;
+    storageNode: ERemote<StorageNode>;
+    zcf: ZCF;
+}): Promise<() => Promise<import("@endo/exo").GuardedKit<{
+    helper: {
+        /** @param {Brand} brand */
+        getKeywordForBrand(brand: Brand): string;
+        /**
+         * @param {Brand} brand
+         * @param {Keyword} keyword
+         */
+        saveBrandKeyword(brand: Brand, keyword: Keyword): void;
+        writeMetrics(): void;
+    };
+    governedApis: {
+        /**
+         * @param {Amount<'nat'>} reduction
+         * @returns {void}
+         */
+        burnFeesToReduceShortfall(reduction: Amount<"nat">): void;
+    };
+    withdrawalHandler: {
+        handle(seat: any): Promise<string>;
+    };
+    withdrawalFacet: {
+        Withdraw(): Promise<import("@agoric/zoe").Invitation<any, undefined>>;
+    };
+    repeatableWithdrawalHandler: {
+        /**
+         * @param {ZCFSeat} seat
+         */
+        handle(seat: ZCFSeat): {
+            invitationMakers: Partial<any>;
+        };
+    };
+    machine: {
+        /**
+         * @param {Issuer} issuer
+         * @param {string} keyword
+         */
+        addIssuer(issuer: Issuer, keyword: string): Promise<void>;
+        /** XXX redundant with getPublicTopics metrics `allocation` */
+        getAllocations(): import("@agoric/zoe").Allocation;
+        makeShortfallReportingInvitation(): Promise<import("@agoric/zoe").Invitation<import("@endo/exo").Guarded<{
+            /** @param {Amount<'nat'>} shortfall */
+            increaseLiquidationShortfall(shortfall: Amount<"nat">): void;
+            /** @param {Amount<'nat'>} reduction */
+            reduceLiquidationShortfall(reduction: Amount<"nat">): void;
+        }>, undefined>>;
+        makeSingleWithdrawalInvitation(): Promise<import("@agoric/zoe").Invitation<any, undefined>>;
+        makeRepeatableWithdrawalInvitation(): Promise<import("@agoric/zoe").Invitation<{
+            invitationMakers: Partial<any>;
+        }, undefined>>;
+        revokeOutstandingWithdrawalInvitations(): void;
+    };
+    /**
+     * XXX missing governance public methods
+     * https://github.com/Agoric/agoric-sdk/issues/5200
+     */
+    public: {
+        /** Anyone can deposit any assets to the reserve */
+        makeAddCollateralInvitation(): Promise<import("@agoric/zoe").Invitation<string, never>>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<MetricsNotification>;
+        };
+    };
+    shortfallReportingFacet: {
+        /** @param {Amount<'nat'>} shortfall */
+        increaseLiquidationShortfall(shortfall: Amount<"nat">): void;
+        /** @param {Amount<'nat'>} reduction */
+        reduceLiquidationShortfall(reduction: Amount<"nat">): void;
+    };
+}>>>;
+export type MetricsNotification = {
+    allocations: AmountKeywordRecord;
+    /**
+     * shortfall from liquidation that
+     * has not yet been compensated.
+     */
+    shortfallBalance: Amount<"nat">;
+    /**
+     * total Fee tokens minted to date
+     */
+    totalFeeMinted: Amount<"nat">;
+    /**
+     * total Fee tokens burned to date
+     */
+    totalFeeBurned: Amount<"nat">;
+};
+export type AssetReserveKit = EReturn<EReturn<typeof prepareAssetReserveKit>>;
+import type { Baggage } from '@agoric/vat-data';
+import type { ZCFMint } from '@agoric/zoe';
+import type { MakeRecorderKit } from '@agoric/zoe/src/contractSupport/recorder.js';
+import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
+import type { ERemote } from '@agoric/internal';
+import type { ZCF } from '@agoric/zoe';
+import type { Brand } from '@agoric/ertp';
+import type { Keyword } from '@agoric/zoe';
+import type { Amount } from '@agoric/ertp';
+import type { ZCFSeat } from '@agoric/zoe';
+import type { Issuer } from '@agoric/ertp';
+import type { AmountKeywordRecord } from '@agoric/zoe/src/zoeService/types.js';
+import type { EReturn } from '@endo/far';
+//# sourceMappingURL=assetReserveKit.d.ts.map

package/src/reserve/assetReserveKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assetReserveKit.d.ts","sourceRoot":"","sources":["assetReserveKit.js"],"names":[],"mappings":"AAmDO,gDARI,OAAO,kDACP;IACN,OAAO,EAAE,QAAQ,KAAK,CAAC,CAAC;IACxB,eAAe,EAAE,eAAe,CAAC;IACjC,WAAW,EAAE,QAAQ,WAAW,CAAC,CAAC;IAClC,GAAG,EAAE,GAAG,CAAC;CACV;;QA8GI,2BAA2B;kCAAf,KAAK;QAUjB;;;WAGG;gCAFQ,KAAK,WACL,OAAO;;;;QAqBlB;;;WAGG;6CAFQ,OAAO,KAAK,CAAC,GACX,IAAI;;;;;;;;;QAsDjB;;WAEG;qBADQ,OAAO;;;;;QAYlB;;;WAGG;0BAFQ,MAAM,WACN,MAAM;QAmBjB,8DAA8D;;;YA2E9D,uCAAuC;oDAA3B,OAAO,KAAK,CAAC;YAWzB,uCAAuC;kDAA3B,OAAO,KAAK,CAAC;;;;;;;;IArD3B;;;OAGG;;QAED,mDAAmD;;;;;;;QAqCnD,uCAAuC;gDAA3B,OAAO,KAAK,CAAC;QAWzB,uCAAuC;8CAA3B,OAAO,KAAK,CAAC;;KA8BhC;;iBA3Wa,mBAAmB;;;;;sBACnB,OAAO,KAAK,CAAC;;;;oBAEb,OAAO,KAAK,CAAC;;;;oBACb,OAAO,KAAK,CAAC;;8BAyWb,QAAQ,QAAQ,OAAO,sBAAsB,CAAC,CAAC;6BAnXnC,kBAAkB;6BADmB,aAAa;qCAE1C,6CAA6C;iCANjD,0CAA0C;6BADxB,kBAAkB;yBAKH,aAAa;2BAHpC,cAAc;6BAGS,aAAa;4BAHpC,cAAc;6BAGS,aAAa;4BAHpC,cAAc;yCAEhB,qCAAqC;6BALjD,WAAW"}

package/src/reserve/params.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @import {AdminFacet, InvitationAmount, ZCFMint} from '@agoric/zoe';
+ */
+/**
+ * @param {InvitationAmount} poserInvitationAmount
+ */
+export function makeReserveTerms(poserInvitationAmount: InvitationAmount): {
+    governedParams: {
+        Electorate: {
+            type: "invitation";
+            value: import("@agoric/ertp").SetAmount<import("@agoric/zoe").InvitationDetails>;
+        };
+    };
+};
+import type { InvitationAmount } from '@agoric/zoe';
+//# sourceMappingURL=params.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["params.js"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;GAEG;AACH,wDAFW,gBAAgB;;;;;;;EASzB;sCAbsD,aAAa"}

package/src/tokens.d.ts

@@ -0,0 +1,3 @@
+export type TokenKeyword = "IST" | "BLD";
+export { Stable, Stake } from "@agoric/internal/src/tokens.js";
+//# 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":"2BAEc,KAAK,GAAG,KAAK"}

package/src/vaultFactory/burn.d.ts

@@ -0,0 +1,5 @@
+export function paymentFromZCFMint(zcf: ZCF, zcfMint: ZCFMint, amount: Amount): Promise<import("@agoric/ertp").Payment<any, any>>;
+import type { ZCF } from '@agoric/zoe';
+import type { ZCFMint } from '@agoric/zoe';
+import type { Amount } from '@agoric/ertp';
+//# 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":"AAYO,wCAJI,GAAG,WACH,OAAO,UACP,MAAM,qDAOhB;yBAd8B,aAAa;6BAAb,aAAa;4BACnB,cAAc"}

package/src/vaultFactory/math.d.ts

@@ -0,0 +1,13 @@
+export function calculateMinimumCollateralization(liquidationMargin: Ratio, liquidationPadding: Ratio): Ratio;
+export function minimumPrice(quoteA: PriceQuote, quoteB?: PriceQuote): 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: import("@agoric/ertp").NatAmount;
+    toMint: import("@agoric/ertp").NatAmount;
+    fee: import("@agoric/ertp").NatAmount;
+    surplus: import("@agoric/ertp").NatAmount;
+};
+import type { Ratio } from '@agoric/ertp';
+import type { PriceQuote } from '@agoric/zoe/tools/types.js';
+import type { Amount } from '@agoric/ertp';
+//# 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":"AA8BO,qEAJI,KAAK,sBACL,KAAK,GACH,KAAK,CAKmC;AAS9C,qCAJI,UAAU,WACV,UAAU,GACR,KAAK,CAajB;AAYM,6CALI,UAAU,qBACV,KAAK,sBACL,KAAK,GACH,OAAO,KAAK,CAAC,CAczB;AAaM,gDALI,OAAO,KAAK,CAAC,QACb,OAAO,KAAK,CAAC,QACb,OAAO,KAAK,CAAC,WACb,KAAK;;;;;EASf;2BA/EuB,cAAc;gCADuD,4BAA4B;4BAEhG,cAAc"}

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?: import("@endo/patterns").Pattern, valuePatt?: import("@endo/patterns").Pattern) => Iterable<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(): 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<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(): import("@agoric/ertp").Amount<"nat">;
+        getCurrentDebt(): import("@agoric/ertp").Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>]>;
+    getSize: (keyPatt?: import("@endo/patterns").Pattern, valuePatt?: import("@endo/patterns").Pattern) => number;
+    values: (keyPatt?: import("@endo/patterns").Pattern, valuePatt?: import("@endo/patterns").Pattern) => Iterable<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(): 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<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(): import("@agoric/ertp").Amount<"nat">;
+        getCurrentDebt(): import("@agoric/ertp").Amount<"nat">;
+        getNormalizedDebt(): import("./storeUtils.js").NormalizedDebt;
+    }>>;
+};
+import type { Vault } from './vault.js';
+import type { MapStore } from '@agoric/store';
+//# 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":"AAmBO,6CADK,SAAS,MAAM,EAAE,KAAK,CAAC;wBAGtB,MAAM,SACN,KAAK;uBAWL,MAAM,KACJ,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCnB;2BApDuB,YAAY;8BADT,eAAe"}