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

package/src/proposals/price-feed-proposal.d.ts

@@ -0,0 +1,83 @@
+export function instanceNameFor(inBrandName: any, outBrandName: any): string;
+export function ensureOracleBrands({ namedVat: { consume: { agoricNames }, }, oracleBrand: { produce: oracleBrandProduce }, }: ChainBootstrapSpace & NamedVatPowers, { options: { priceFeedOptions: { brandIn: rawBrandIn, brandOut: rawBrandOut, IN_BRAND_NAME, IN_BRAND_DECIMALS, OUT_BRAND_NAME, OUT_BRAND_DECIMALS, }, }, }: {
+    options: {
+        priceFeedOptions: PriceFeedOptions;
+    };
+}): Promise<[Brand<'nat'>, Brand<'nat'>]>;
+export function createPriceFeed({ consume: { agoricNamesAdmin, board, chainStorage, chainTimerService, client, econCharterKit, highPrioritySendersManager, namesByAddressAdmin, priceAuthority, priceAuthorityAdmin, startGovernedUpgradable, }, instance: { produce: produceInstance }, }: ChainBootstrapSpace, { options: { priceFeedOptions: { AGORIC_INSTANCE_NAME, oracleAddresses, contractTerms, IN_BRAND_NAME, OUT_BRAND_NAME, }, }, }: {
+    options: {
+        priceFeedOptions: {
+            AGORIC_INSTANCE_NAME: string;
+            oracleAddresses: string[];
+            contractTerms: import('@agoric/inter-protocol/src/price/fluxAggregatorKit.js').ChainlinkConfig;
+            IN_BRAND_NAME: string;
+            OUT_BRAND_NAME: string;
+        };
+    };
+}): Promise<void>;
+export function getManifestForPriceFeed({ restoreRef }: {
+    restoreRef?: ((ref: unknown) => Promise<unknown>) | undefined;
+}, priceFeedOptions: PriceFeedOptions): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNamesAdmin: string;
+                board: string;
+                chainStorage: string;
+                chainTimerService: string;
+                client: string;
+                contractGovernor: string;
+                econCharterKit: string;
+                economicCommitteeCreatorFacet: string;
+                highPrioritySendersManager: string;
+                namesByAddressAdmin: string;
+                priceAuthority: string;
+                priceAuthorityAdmin: string;
+                startGovernedUpgradable: string;
+            };
+            instance: {
+                produce: string;
+            };
+            namedVat?: undefined;
+            oracleBrand?: undefined;
+        } | {
+            namedVat: {
+                consume: {
+                    agoricNames: string;
+                };
+            };
+            oracleBrand: {
+                produce: string;
+            };
+            consume?: undefined;
+            instance?: undefined;
+        };
+    };
+    installations: {
+        priceAggregator: Promise<unknown>;
+    };
+    options: {
+        priceFeedOptions: {
+            brandIn: any;
+            brandOut: any;
+            IN_BRAND_NAME: string;
+            IN_BRAND_DECIMALS: string;
+            OUT_BRAND_NAME: string;
+            OUT_BRAND_DECIMALS: string;
+        };
+    };
+}>;
+export function startPriceFeeds({ consume, produce, installation: { consume: { priceAggregator }, }, }: import('./econ-behaviors').EconomyBootstrapPowers, { options: { demoOracleAddresses } }?: {
+    options?: {
+        demoOracleAddresses?: string[] | undefined;
+    } | undefined;
+} | undefined): Promise<void>;
+export type PriceFeedOptions = {
+    brandIn?: ERef<Brand<'nat'> | undefined>;
+    brandOut?: ERef<Brand<'nat'> | undefined>;
+    IN_BRAND_NAME: string;
+    IN_BRAND_DECIMALS: string;
+    OUT_BRAND_NAME: string;
+    OUT_BRAND_DECIMALS: string;
+};
+//# sourceMappingURL=price-feed-proposal.d.ts.map

package/src/proposals/price-feed-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"price-feed-proposal.d.ts","sourceRoot":"","sources":["price-feed-proposal.js"],"names":[],"mappings":"AAoBO,6EACsC;AAoBtC,+HAJI,mBAAmB,GAAG,cAAc,8JACpC;IAAC,OAAO,EAAE;QAAC,gBAAgB,EAAE,gBAAgB,CAAA;KAAC,CAAA;CAAC,GAC7C,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,MAAM,KAAK,CAAC,CAAC,CAAC,CAwCjD;AAMM,4RAHI,mBAAmB,iIACnB;IAAC,OAAO,EAAE;QAAC,gBAAgB,EAAE;YAAC,oBAAoB,EAAE,MAAM,CAAC;YAAC,eAAe,EAAE,MAAM,EAAE,CAAC;YAAC,aAAa,EAAE,OAAO,uDAAuD,EAAE,eAAe,CAAC;YAAC,aAAa,EAAE,MAAM,CAAC;YAAC,cAAc,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAAA;CAAC,iBAkIjP;AAUM;IAH+C,UAAU,UAA/C,OAAO,KAAK,QAAQ,OAAO,CAAC;qBAClC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAlMT,MAAM;+BACF,MAAM;4BACT,MAAM;gCACF,MAAM;;;GAiP3B;AAQK,wGALI,OAAO,kBAAkB,EAAE,sBAAsB;;;;8BA8D3D;+BAxTY;IACZ,OAAS,CAAC,EAAE,KAAK,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC;IAC3C,QAAU,CAAC,EAAE,KAAK,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC;IAC5C,aAAe,EAAE,MAAM,CAAC;IACxB,iBAAmB,EAAE,MAAM,CAAC;IAC5B,cAAgB,EAAE,MAAM,CAAC;IACzB,kBAAoB,EAAE,MAAM,CAAC;CAC1B"}

package/src/proposals/startEconCommittee.d.ts

@@ -0,0 +1,34 @@
+export function startEconomicCommittee({ consume: { board, chainStorage, diagnostics, zoe }, produce: { economicCommitteeKit, economicCommitteeCreatorFacet }, installation: { consume: { committee }, }, instance: { produce: { economicCommittee }, }, }: import('./econ-behaviors').EconomyBootstrapPowers, { options: { econCommitteeOptions } }: {
+    options?: {
+        econCommitteeOptions?: EconCommitteeOptions | undefined;
+    } | undefined;
+}): Promise<void>;
+export const ECON_COMMITTEE_MANIFEST: {
+    [x: string]: {
+        consume: {
+            board: boolean;
+            chainStorage: boolean;
+            diagnostics: boolean;
+            zoe: boolean;
+        };
+        produce: {
+            economicCommitteeKit: boolean;
+            economicCommitteeCreatorFacet: string;
+        };
+        installation: {
+            consume: {
+                committee: string;
+            };
+        };
+        instance: {
+            produce: {
+                economicCommittee: string;
+            };
+        };
+    };
+};
+export type EconCommitteeOptions = {
+    committeeName?: string | undefined;
+    committeeSize?: number | undefined;
+};
+//# sourceMappingURL=startEconCommittee.d.ts.map

package/src/proposals/startEconCommittee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startEconCommittee.d.ts","sourceRoot":"","sources":["startEconCommittee.js"],"names":[],"mappings":"AA4BO,4PALI,OAAO,kBAAkB,EAAE,sBAAsB;IAEjC,OAAO;;;kBA0DjC;AAGD;;;;;;;;;;;;;;;;;;;;;;;EAmBG"}

package/src/proposals/startPSM.d.ts

@@ -0,0 +1,61 @@
+export function startPSM({ vatParameters: { chainStorageEntries }, consume: { agoricNamesAdmin, board, diagnostics, zoe, feeMintAccess: feeMintAccessP, economicCommitteeCreatorFacet, econCharterKit, provisionPoolStartResult, chainStorage, chainTimerService, psmKit, anchorBalancePayments: anchorBalancePaymentsP, }, produce: { psmKit: producepsmKit }, installation: { consume: { contractGovernor, psm: psmInstall }, }, brand: { consume: { [Stable.symbol]: mintedP }, }, }: EconomyBootstrapPowers & WellKnownSpaces & ChainStorageVatParams, { options: { anchorOptions }, WantMintedFeeBP, GiveMintedFeeBP, MINT_LIMIT, }?: {
+    WantMintedFeeBP?: bigint | undefined;
+    GiveMintedFeeBP?: bigint | undefined;
+    MINT_LIMIT?: bigint | undefined;
+    options?: {
+        anchorOptions?: AnchorOptions | undefined;
+    } | undefined;
+} | undefined): Promise<void>;
+export function makeAnchorAsset({ vatParameters: { chainStorageEntries }, consume: { agoricNamesAdmin, bankManager, startUpgradable, anchorBalancePayments, }, installation: { consume: { mintHolder }, }, produce: { testFirstAnchorKit, anchorBalancePayments: produceAnchorBalancePayments, }, }: EconomyBootstrapPowers & WellKnownSpaces & ChainStorageVatParams, { options: { anchorOptions } }: {
+    options: {
+        anchorOptions?: AnchorOptions;
+    };
+}): Promise<void>;
+/** @typedef {import('./econ-behaviors.js').EconomyBootstrapSpace} EconomyBootstrapSpace */
+export const INVITE_PSM_COMMITTEE_MANIFEST: import("@agoric/vats/src/core/lib-boot.js").BootstrapManifest;
+/** @type {BootstrapManifest} */
+export const PSM_MANIFEST: BootstrapManifest;
+export function getManifestForPsmGovernance({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys }: {
+    installKeys: any;
+}): {
+    manifest: {};
+    installations: {
+        econCommitteeCharter: any;
+        contractGovernor: any;
+        committee: any;
+        binaryVoteCounter: any;
+    };
+};
+export function getManifestForPsm({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys, anchorOptions }: {
+    installKeys: any;
+    anchorOptions: any;
+}): {
+    manifest: import("@agoric/vats/src/core/lib-boot.js").BootstrapManifest;
+    installations: {
+        psm: any;
+        mintHolder: any;
+    };
+    options: {
+        anchorOptions: any;
+    };
+};
+export type BootstrapManifest = import('@agoric/vats/src/core/lib-boot.js').BootstrapManifest;
+export type MetricsNotification = import('../psm/psm.js').MetricsNotification;
+export type EconomyBootstrapPowers = import('./econ-behaviors.js').EconomyBootstrapPowers;
+export type AnchorOptions = {
+    denom?: string | undefined;
+    keyword?: string | undefined;
+    decimalPlaces?: number | undefined;
+    proposedName?: string | undefined;
+};
+export type EconomyBootstrapSpace = import('./econ-behaviors.js').EconomyBootstrapSpace;
+import { inviteCommitteeMembers } from './committee-proposal.js';
+import { startEconCharter } from './committee-proposal.js';
+import { inviteToEconCharter } from './committee-proposal.js';
+import { Stable } from '../tokens.js';
+export { inviteCommitteeMembers, startEconCharter, inviteToEconCharter };
+//# sourceMappingURL=startPSM.d.ts.map

package/src/proposals/startPSM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startPSM.d.ts","sourceRoot":"","sources":["startPSM.js"],"names":[],"mappings":"AAoFO,ydAPI,sBAAsB,GAAG,eAAe,GAAG,qBAAqB;;;;;;;8BA4M1E;AAuBM,qSAHI,sBAAsB,GAAG,eAAe,GAAG,qBAAqB,kCAChE;IAAC,OAAO,EAAE;QAAE,aAAa,CAAC,EAAE,aAAa,CAAA;KAAE,CAAA;CAAE,iBA8FvD;AAGD,2FAA2F;AAE3F,0GAiBE;AAEF,gCAAgC;AAChC,2BADW,iBAAiB,CA6C1B;AAGK;;;;;;;;;;;;EAaN;AAEM;;;;;;;;;;;;;;EAcN;gCAxda,OAAO,mCAAmC,EAAE,iBAAiB;kCAC7D,OAAO,eAAe,EAAE,mBAAmB;qCAC3C,OAAO,qBAAqB,EAAE,sBAAsB;;;;;;;oCAoXpD,OAAO,qBAAqB,EAAE,qBAAqB;uCAxX1D,yBAAyB;iCAAzB,yBAAyB;oCAAzB,yBAAyB;uBART,cAAc"}

package/src/proposals/startPSM.js

@@ -345,13 +345,14 @@ export const makeAnchorAsset = async (
     }),
   );
 
-  /** @type {{ creatorFacet: ERef<Mint<'nat'>>, publicFacet: ERef<Issuer<'nat'>> }} */
-  // @ts-expect-error cast
-  const { creatorFacet: mint, publicFacet: issuer } = await E(startUpgradable)({
-    installation: mintHolder,
-    label: keyword,
-    terms,
-  });
+  const { creatorFacet: mint, publicFacet: issuer } =
+    /** @type {{ creatorFacet: ERef<Mint<'nat'>>, publicFacet: ERef<Issuer<'nat'>> }} */ (
+      await E(startUpgradable)({
+        installation: mintHolder,
+        label: keyword,
+        terms,
+      })
+    );
 
   const brand = await E(issuer).getBrand();
   const kit = harden({ mint, issuer, brand });

package/src/proposals/utils.d.ts

@@ -0,0 +1,15 @@
+export function reserveThenGetNamePaths(nameAdmin: ERef<import('@agoric/vats').NameAdmin>, paths: string[][]): Promise<any[]>;
+export function reserveThenGetNames(nameAdmin: ERef<import('@agoric/vats').NameAdmin>, names: string[]): Promise<any[]>;
+export function reserveThenDeposit(debugName: string, namesByAddressAdmin: ERef<import('@agoric/vats').NameAdmin>, addr: string, payments: Array<ERef<Payment>>): Promise<void>;
+export function makeInstallCache(homeP: {
+    scratch: ERef<import('@agoric/internal/src/scratch.js').ScratchPad>;
+}, { installCacheKey, loadBundle }: {
+    loadBundle: (specifier: string) => Promise<{
+        default: Bundle;
+    }>;
+    installCacheKey?: string | undefined;
+}): Promise<{
+    wrapInstall: (install: any) => (mPath: any, bPath: any, opts: any) => Promise<any>;
+    saveCache: () => Promise<void>;
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/src/proposals/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"AAUO,mDAHI,KAAK,OAAO,cAAc,EAAE,SAAS,CAAC,SACtC,MAAM,EAAE,EAAE,kBAgCpB;AAMM,+CAHI,KAAK,OAAO,cAAc,EAAE,SAAS,CAAC,SACtC,MAAM,EAAE,kBAMhB;AAQI,8CALI,MAAM,uBACN,KAAK,OAAO,cAAc,EAAE,SAAS,CAAC,QACtC,MAAM,YACN,MAAM,KAAK,OAAO,CAAC,CAAC,iBAuB9B;AAmBM,wCALI;IAAE,OAAO,EAAE,KAAK,OAAO,iCAAiC,EAAE,UAAU,CAAC,CAAA;CAAE;4BAE3D,MAAM,KAAK,QAAQ;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC;;;;;GA2C3D"}

package/src/psm/psm.d.ts

@@ -0,0 +1,193 @@
+export namespace customTermsShape {
+    export { BrandShape as anchorBrand };
+    export { RatioShape as anchorPerMinted };
+    export { InstanceHandleShape as electionManager };
+    export namespace governedParams {
+        namespace Electorate {
+            export let type: "invitation";
+            export { AmountShape as value };
+        }
+        namespace WantMintedFee {
+            let type_1: "ratio";
+            export { type_1 as type };
+            export { RatioShape as value };
+        }
+        namespace GiveMintedFee {
+            let type_2: "ratio";
+            export { type_2 as type };
+            export { RatioShape as value };
+        }
+        namespace MintLimit {
+            let type_3: "amount";
+            export { type_3 as type };
+            export { AmountShape as value };
+        }
+    }
+}
+export const privateArgsShape: import("@endo/patterns").Matcher;
+export function prepare(zcf: ZCF<GovernanceTerms<{
+    GiveMintedFee: 'ratio';
+    WantMintedFee: 'ratio';
+    MintLimit: 'amount';
+}> & {
+    anchorBrand: Brand<'nat'>;
+    anchorPerMinted: Ratio;
+}>, privateArgs: {
+    feeMintAccess: FeeMintAccess;
+    initialPoserInvitation: Invitation;
+    storageNode: StorageNode;
+    marshaller: Marshaller;
+}, baggage: MapStore<string, unknown>): Promise<{
+    creatorFacet: {
+        getParamMgrRetriever: () => {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                GiveMintedFee: "ratio";
+                MintLimit: "amount";
+                WantMintedFee: "ratio";
+            } & {
+                Electorate: "invitation";
+            }>; /**
+             * @param {Amount<'nat'>} toMint
+             */
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                GiveMintedFee: "ratio";
+                MintLimit: "amount";
+                WantMintedFee: "ratio";
+            } & {
+                Electorate: "invitation";
+            }>; /**
+             * @param {Amount<'nat'>} toMint
+             */
+        }>;
+        getInvitation: (name: any) => Promise<Invitation<R, A>>;
+        getLimitedCreatorFacet: () => {
+            getRewardAllocation(): AmountKeywordRecord;
+            makeCollectFeesInvitation(): Promise<Invitation<R, A>>;
+            makeRestoreMetricsInvitation(): Promise<Invitation<R, A>>;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            getRewardAllocation(): AmountKeywordRecord;
+            makeCollectFeesInvitation(): Promise<Invitation<R, A>>;
+            makeRestoreMetricsInvitation(): Promise<Invitation<R, A>>;
+        }>;
+        getGovernedApis: () => GovernedApis;
+        getGovernedApiNames: () => string[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getParamMgrRetriever: () => {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                GiveMintedFee: "ratio";
+                MintLimit: "amount";
+                WantMintedFee: "ratio";
+            } & {
+                Electorate: "invitation";
+            }>; /**
+             * @param {Amount<'nat'>} toMint
+             */
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                GiveMintedFee: "ratio";
+                MintLimit: "amount";
+                WantMintedFee: "ratio";
+            } & {
+                Electorate: "invitation";
+            }>; /**
+             * @param {Amount<'nat'>} toMint
+             */
+        }>;
+        getInvitation: (name: any) => Promise<Invitation<R, A>>;
+        getLimitedCreatorFacet: () => {
+            getRewardAllocation(): AmountKeywordRecord;
+            makeCollectFeesInvitation(): Promise<Invitation<R, A>>;
+            makeRestoreMetricsInvitation(): Promise<Invitation<R, A>>;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            getRewardAllocation(): AmountKeywordRecord;
+            makeCollectFeesInvitation(): Promise<Invitation<R, A>>;
+            makeRestoreMetricsInvitation(): Promise<Invitation<R, A>>;
+        }>;
+        getGovernedApis: () => GovernedApis;
+        getGovernedApiNames: () => string[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    }>;
+    publicFacet: {
+        getAmount: (name: string) => Amount<AssetKind>;
+        getBrand: (name: string) => Brand<AssetKind>;
+        getInstance: (name: string) => Instance;
+        getInstallation: (name: string) => Installation<any>;
+        getInvitationAmount: (name: string) => Amount<"set">;
+        getNat: (name: string) => bigint;
+        getRatio: (name: string) => Ratio;
+        getString: (name: string) => string;
+        getTimestamp: (name: string) => import("@agoric/time/src/types.js").TimestampRecord;
+        getRelativeTime: (name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord;
+        getUnknown: (name: string) => any;
+        getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams: () => ERef<ParamStateRecord>;
+        getMetrics(): Subscriber<MetricsNotification>;
+        getPoolBalance(): Amount<any>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<MetricsNotification>;
+        };
+        makeWantMintedInvitation(): Promise<Invitation<R, A>>;
+        makeGiveMintedInvitation(): Promise<Invitation<R, A>>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getAmount: (name: string) => Amount<AssetKind>;
+        getBrand: (name: string) => Brand<AssetKind>;
+        getInstance: (name: string) => Instance;
+        getInstallation: (name: string) => Installation<any>;
+        getInvitationAmount: (name: string) => Amount<"set">;
+        getNat: (name: string) => bigint;
+        getRatio: (name: string) => Ratio;
+        getString: (name: string) => string;
+        getTimestamp: (name: string) => import("@agoric/time/src/types.js").TimestampRecord;
+        getRelativeTime: (name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord;
+        getUnknown: (name: string) => any;
+        getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams: () => ERef<ParamStateRecord>;
+        getMetrics(): Subscriber<MetricsNotification>;
+        getPoolBalance(): Amount<any>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<MetricsNotification>;
+        };
+        makeWantMintedInvitation(): Promise<Invitation<R, A>>;
+        makeGiveMintedInvitation(): Promise<Invitation<R, A>>;
+    }>;
+}>;
+/**
+ * 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 Baggage = import('@agoric/vat-data').Baggage;
+export type PsmPublicFacet = Awaited<ReturnType<typeof prepare>>['publicFacet'];
+import { BrandShape } from '@agoric/ertp';
+import { RatioShape } from '@agoric/ertp';
+import { InstanceHandleShape } from '@agoric/zoe/src/typeGuards.js';
+import { AmountShape } from '@agoric/ertp';
+//# 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":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2FA,gEAUE;AAeK;mBAVc,OAAO;mBACP,OAAO;eACX,QAAQ;;iBAEN,MAAM,KAAK,CAAC;qBACR,KAAK;iBAEjB;IAAC,aAAa,EAAE,aAAa,CAAC;IAAC,sBAAsB,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAC;;;;;;;;;gBAwH7H;;eAEG;;;;;;;;gBAFH;;eAEG;;;;;;;;;;;;;;;;;;;;;;;gBAFH;;eAEG;;;;;;;;gBAFH;;eAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8MJ;;;;;;;;;;uBAnYa,OAAO,KAAK,CAAC;;;;;uBAEb,OAAO,KAAK,CAAC;;;;;oBAEb,OAAO,KAAK,CAAC;;;;;yBAGb,OAAO,KAAK,CAAC;;;;;yBAEb,OAAO,KAAK,CAAC;;sBAIb,OAAO,kBAAkB,EAAE,OAAO;6BAwXlC,QAAQ,WAAW,cAAc,CAAC,CAAC,CAAC,aAAa,CAAC;2BArbA,cAAc;2BAAd,cAAc;oCA0BvE,+BAA+B;4BA1B0B,cAAc"}

package/src/psm/types.d.ts

@@ -0,0 +1,2 @@
+type PsmPublicFacet = import('./psm').PsmPublicFacet;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"sBAEc,OAAO,OAAO,EAAE,cAAc"}

package/src/reserve/assetReserve.d.ts

@@ -0,0 +1,42 @@
+export function prepare(zcf: ZCF<GovernanceTerms<{}> & {
+    governedApis: ['burnFeesToReduceShortfall'];
+}>, privateArgs: {
+    feeMintAccess: FeeMintAccess;
+    initialPoserInvitation: Invitation;
+    marshaller: ERef<Marshaller>;
+    storageNode: ERef<StorageNode>;
+}, baggage: MapStore<string, unknown>): Promise<{
+    /** @type {GovernedCreatorFacet<typeof assetReserveKit.machine>} */
+    creatorFacet: GovernedCreatorFacet<{
+        addIssuer(issuer: Issuer<AssetKind>, keyword: string): Promise<void>;
+        getAllocations(): AmountKeywordRecord;
+        makeShortfallReportingInvitation(): Promise<Invitation<R, A>>;
+    }>;
+    /** @type {GovernedPublicFacet<typeof assetReserveKit.public>} */
+    publicFacet: GovernedPublicFacet<{
+        makeAddCollateralInvitation(): Promise<Invitation<R, A>>;
+        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 Baggage = import('@agoric/vat-data').Baggage;
+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 = Awaited<ReturnType<typeof prepare>>['publicFacet'];
+/**
+ * the creator facet for the governor
+ */
+export type AssetReserveCreatorFacet = Awaited<ReturnType<typeof prepare>>['creatorFacet'];
+//# 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":"AAyCO,6BAbI,IAAI,gBAAgB,EAAE,CAAC,GACjC;IACA,YAAgB,EAAE,CAAC,2BAA2B,CAAC,CAAC;CAC7C,CACA;mBAEgB,aAAa;4BACJ,UAAU;gBACtB,KAAK,UAAU,CAAC;iBACf,KAAK,WAAW,CAAC;;IA+D/B,mEAAmE;;;;;;IAEnE,iEAAiE;;;;;;;GAKpE;;6CA7F6C,MAAM,KAAK,IAAI;4CAChB,MAAM,KAAK,IAAI;;sBAI9C,OAAO,kBAAkB,EAAE,OAAO;;8CA6FtB,MAAM,KAAK,IAAI;4CACf,MAAM,KAAK,IAAI;;;wBAKlB,MAAM,OAAO,MAAM,KAAK,IAAI;oBACrC,MAAM,UAAU;sCAChB,MAAM,QAAQ,WAAW,iBAAiB,CAAC,CAAC;;sCAG5C,QAAQ,WAAW,cAAc,CAAC,CAAC,CAAC,aAAa,CAAC;;;;uCAClD,QAAQ,WAAW,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC"}

package/src/reserve/assetReserveKit.d.ts

@@ -0,0 +1,126 @@
+export function prepareAssetReserveKit(baggage: MapStore<string, unknown>, { feeMint, makeRecorderKit, storageNode, zcf }: {
+    feeMint: ZCFMint<'nat'>;
+    makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit;
+    storageNode: StorageNode;
+    zcf: ZCF;
+}): Promise<() => Promise<{
+    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;
+    };
+    machine: {
+        /**
+         * @param {Issuer} issuer
+         * @param {string} keyword
+         */
+        addIssuer(issuer: Issuer, keyword: string): Promise<void>;
+        /** XXX redundant with getPublicTopics metrics `allocation` */
+        getAllocations(): AmountKeywordRecord;
+        makeShortfallReportingInvitation(): Promise<Invitation<R, A>>;
+    };
+    /**
+     * XXX missing governance public methods https://github.com/Agoric/agoric-sdk/issues/5200
+     */
+    public: {
+        /**
+         * Anyone can deposit any assets to the reserve
+         */
+        makeAddCollateralInvitation(): Promise<Invitation<R, A>>;
+        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;
+    };
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    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;
+    };
+    machine: {
+        /**
+         * @param {Issuer} issuer
+         * @param {string} keyword
+         */
+        addIssuer(issuer: Issuer, keyword: string): Promise<void>;
+        /** XXX redundant with getPublicTopics metrics `allocation` */
+        getAllocations(): AmountKeywordRecord;
+        makeShortfallReportingInvitation(): Promise<Invitation<R, A>>;
+    };
+    /**
+     * XXX missing governance public methods https://github.com/Agoric/agoric-sdk/issues/5200
+     */
+    public: {
+        /**
+         * Anyone can deposit any assets to the reserve
+         */
+        makeAddCollateralInvitation(): Promise<Invitation<R, A>>;
+        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 = ReturnType<Awaited<ReturnType<typeof prepareAssetReserveKit>>>;
+//# 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":"AAmCO,2HANI;IACV,OAAS,EAAE,QAAQ,KAAK,CAAC,CAAC;IAC1B,eAAiB,EAAE,OAAO,6CAA6C,EAAE,eAAe,CAAC;IACzF,WAAa,EAAE,WAAW,CAAC;IAC3B,GAAK,EAAE,GAAG,CAAA;CAAC;;QAwEJ,2BAA2B;kCAAf,KAAK;QAUjB;;;WAGG;gCAFQ,KAAK,WACL,OAAO;;;;QAqBlB;;;;WAIG;6CAFQ,OAAO,KAAK,CAAC,GACX,IAAI;;;QA2BjB;;;WAGG;0BAFQ,MAAM,WACN,MAAM;QAmBjB,8DAA8D;;;;IAiBhE;;OAEG;;QAED;;WAEG;;;;;;;QAqCH;;WAEG;gDADQ,OAAO,KAAK,CAAC;QAYxB;;WAEG;8CADQ,OAAO,KAAK,CAAC;;;;QA9JxB,2BAA2B;kCAAf,KAAK;QAUjB;;;WAGG;gCAFQ,KAAK,WACL,OAAO;;;;QAqBlB;;;;WAIG;6CAFQ,OAAO,KAAK,CAAC,GACX,IAAI;;;QA2BjB;;;WAGG;0BAFQ,MAAM,WACN,MAAM;QAmBjB,8DAA8D;;;;IAiBhE;;OAEG;;QAED;;WAEG;;;;;;;QAqCH;;WAEG;gDADQ,OAAO,KAAK,CAAC;QAYxB;;WAEG;8CADQ,OAAO,KAAK,CAAC;;KA+B/B;;iBAlRa,mBAAmB;;;;;sBACnB,OAAO,KAAK,CAAC;;;;oBAEb,OAAO,KAAK,CAAC;;;;oBACb,OAAO,KAAK,CAAC;;8BAgRb,WAAW,QAAQ,WAAW,6BAA6B,CAAC,CAAC,CAAC"}

package/src/reserve/params.d.ts

@@ -0,0 +1,10 @@
+export function makeReserveTerms(poserInvitationAmount: any, timer: any): {
+    timer: any;
+    governedParams: {
+        Electorate: {
+            type: "invitation";
+            value: any;
+        };
+    };
+};
+//# 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":"AAIA;;;;;;;;EAQE"}