@agoric/inter-protocol 0.16.2-dev-eb7e9eb.0 → 0.16.2-u11.0

package/src/provisionPoolKit.js

@@ -1,461 +0,0 @@
-// @ts-check
-import { AmountMath, BrandShape } from '@agoric/ertp';
-import { UnguardedHelperI } from '@agoric/internal/src/typeGuards.js';
-import {
-  observeIteration,
-  observeNotifier,
-  subscribeEach,
-} from '@agoric/notifier';
-import {
-  M,
-  makeScalarBigMapStore,
-  makeScalarBigSetStore,
-  prepareExoClassKit,
-} from '@agoric/vat-data';
-import { PowerFlags } from '@agoric/vats/src/walletFlags.js';
-import {
-  PublicTopicShape,
-  makeRecorderTopic,
-} from '@agoric/zoe/src/contractSupport/topics.js';
-import { InstanceHandleShape } from '@agoric/zoe/src/typeGuards.js';
-import { E } from '@endo/far';
-import { Far, deeplyFulfilled } from '@endo/marshal';
-
-const { details: X, quote: q, Fail } = assert;
-
-/**
- * @typedef {import('@agoric/zoe/src/zoeService/utils').Instance<
- *   import('@agoric/inter-protocol/src/psm/psm.js').start
- * >} PsmInstance
- */
-
-/**
- * @typedef {object} ProvisionPoolKitReferences
- * @property {ERef<BankManager>} bankManager
- * @property {ERef<import('@agoric/vats').NameAdmin>} namesByAddressAdmin
- * @property {ERef<
- *   import('@agoric/vats/src/core/startWalletFactory').WalletFactoryStartResult['creatorFacet']
- * >} walletFactory
- */
-
-/**
- * @typedef {object} MetricsNotification Metrics naming scheme is that nouns are
- *   present values and past-participles are accumulative.
- * @property {bigint} walletsProvisioned count of new wallets provisioned
- * @property {Amount<'nat'>} totalMintedProvided running sum of Minted provided
- *   to new wallets
- * @property {Amount<'nat'>} totalMintedConverted running sum of Minted ever
- *   received by the contract from PSM
- */
-
-/**
- * Given attenuated access to the funding purse, handle requests to provision
- * smart wallets.
- *
- * @param {(depositBank: ERef<Bank>) => Promise<void>} sendInitialPayment
- * @param {() => void} onProvisioned
- *
- * @typedef {import('@agoric/vats/src/vat-bank.js').Bank} Bank
- */
-export const makeBridgeProvisionTool = (sendInitialPayment, onProvisioned) => {
-  /** @param {ProvisionPoolKitReferences} refs */
-  const makeBridgeHandler = ({
-    bankManager,
-    namesByAddressAdmin,
-    walletFactory,
-  }) =>
-    Far('provisioningHandler', {
-      fromBridge: async obj => {
-        obj.type === 'PLEASE_PROVISION' ||
-          Fail`Unrecognized request ${obj.type}`;
-        console.info('PLEASE_PROVISION', obj);
-        const { address, powerFlags } = obj;
-        powerFlags.includes(PowerFlags.SMART_WALLET) ||
-          Fail`missing SMART_WALLET in powerFlags`;
-
-        const bank = E(bankManager).getBankForAddress(address);
-        // only proceed if we can provide funds
-        await sendInitialPayment(bank);
-
-        const [_, created] = await E(walletFactory).provideSmartWallet(
-          address,
-          bank,
-          namesByAddressAdmin,
-        );
-        if (created) {
-          onProvisioned();
-        }
-        console.info(created ? 'provisioned' : 're-provisioned', address);
-      },
-    });
-  return makeBridgeHandler;
-};
-
-/**
- * @param {import('@agoric/vat-data').Baggage} baggage
- * @param {{
- *   makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit;
- *   params: any;
- *   poolBank: import('@endo/far').ERef<Bank>;
- *   zcf: ZCF;
- * }} powers
- */
-export const prepareProvisionPoolKit = (
-  baggage,
-  { makeRecorderKit, params, poolBank, zcf },
-) => {
-  const zoe = zcf.getZoeService();
-
-  const makeProvisionPoolKitInternal = prepareExoClassKit(
-    baggage,
-    'ProvisionPoolKit',
-    {
-      machine: M.interface('ProvisionPoolKit machine', {
-        addRevivableAddresses: M.call(M.arrayOf(M.string())).returns(),
-        getWalletReviver: M.call().returns(
-          M.remotable('ProvisionPoolKit wallet reviver'),
-        ),
-        setReferences: M.callWhen({
-          bankManager: M.eref(M.remotable('bankManager')),
-          namesByAddressAdmin: M.eref(M.remotable('nameAdmin')),
-          walletFactory: M.eref(M.remotable('walletFactory')),
-        }).returns(),
-        makeHandler: M.call().returns(M.remotable('BridgeHandler')),
-        initPSM: M.call(BrandShape, InstanceHandleShape).returns(),
-      }),
-      walletReviver: M.interface('ProvisionPoolKit wallet reviver', {
-        reviveWallet: M.callWhen(M.string()).returns(
-          M.remotable('SmartWallet'),
-        ),
-        ackWallet: M.call(M.string()).returns(M.boolean()),
-      }),
-      helper: UnguardedHelperI,
-      public: M.interface('ProvisionPoolKit public', {
-        getPublicTopics: M.call().returns({ metrics: PublicTopicShape }),
-      }),
-    },
-    /**
-     * @param {object} opts
-     * @param {Purse<'nat'>} opts.fundPurse
-     * @param {Brand} opts.poolBrand
-     * @param {StorageNode} opts.metricsNode
-     */
-    ({ fundPurse, poolBrand, metricsNode }) => {
-      /** @type {import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<MetricsNotification>} */
-      const metricsRecorderKit = makeRecorderKit(metricsNode);
-
-      /** @type {MapStore<Brand, PsmInstance>} */
-      const brandToPSM = makeScalarBigMapStore('brandToPSM', { durable: true });
-      const revivableAddresses = makeScalarBigSetStore('revivableAddresses', {
-        durable: true,
-        keyShape: M.string(),
-      });
-
-      /**
-       * to be set by `setReferences`
-       *
-       * @type {Partial<ProvisionPoolKitReferences>}
-       */
-      const references = {
-        bankManager: undefined,
-        namesByAddressAdmin: undefined,
-        walletFactory: undefined,
-      };
-
-      return {
-        brandToPSM,
-        fundPurse,
-        metricsRecorderKit,
-        poolBrand,
-        walletsProvisioned: 0n,
-        totalMintedProvided: AmountMath.makeEmpty(poolBrand),
-        totalMintedConverted: AmountMath.makeEmpty(poolBrand),
-        revivableAddresses,
-        ...references,
-      };
-    },
-    {
-      // aka "limitedCreatorFacet"
-      machine: {
-        /** @param {string[]} oldAddresses */
-        addRevivableAddresses(oldAddresses) {
-          console.log('revivableAddresses count', oldAddresses.length);
-          this.state.revivableAddresses.addAll(oldAddresses);
-        },
-        getWalletReviver() {
-          return this.facets.walletReviver;
-        },
-        /** @param {ProvisionPoolKitReferences} erefs */
-        async setReferences(erefs) {
-          const { bankManager, namesByAddressAdmin, walletFactory } = erefs;
-          const obj = harden({
-            bankManager,
-            namesByAddressAdmin,
-            walletFactory,
-          });
-          const refs = await deeplyFulfilled(obj);
-          Object.assign(this.state, refs);
-        },
-        makeHandler() {
-          const { bankManager, namesByAddressAdmin, walletFactory } =
-            this.state;
-          if (!bankManager || !namesByAddressAdmin || !walletFactory) {
-            throw Fail`must set references before handling requests`;
-          }
-          const { helper } = this.facets;
-          // a bit obtuse but leave for backwards compatibility with tests
-          const innerMaker = makeBridgeProvisionTool(
-            bank => helper.sendInitialPayment(bank),
-            () => helper.onProvisioned(),
-          );
-          return innerMaker({
-            bankManager,
-            namesByAddressAdmin,
-            walletFactory,
-          });
-        },
-        /**
-         * @param {Brand} brand
-         * @param {PsmInstance} instance
-         */
-        initPSM(brand, instance) {
-          const { brandToPSM } = this.state;
-          brandToPSM.init(brand, instance);
-        },
-      },
-      walletReviver: {
-        /** @param {string} address */
-        async reviveWallet(address) {
-          const {
-            revivableAddresses,
-            bankManager,
-            namesByAddressAdmin,
-            walletFactory,
-          } = this.state;
-          if (!bankManager || !namesByAddressAdmin || !walletFactory) {
-            throw Fail`must set references before handling requests`;
-          }
-          revivableAddresses.has(address) ||
-            Fail`non-revivable address ${address}`;
-          const bank = E(bankManager).getBankForAddress(address);
-          const [wallet, _created] = await E(walletFactory).provideSmartWallet(
-            address,
-            bank,
-            namesByAddressAdmin,
-          );
-          return wallet;
-        },
-        /**
-         * @param {string} address
-         * @returns {boolean} isRevive
-         */
-        ackWallet(address) {
-          const { revivableAddresses } = this.state;
-          if (!revivableAddresses.has(address)) {
-            return false;
-          }
-          revivableAddresses.delete(address);
-          return true;
-        },
-      },
-      helper: {
-        publishMetrics() {
-          const {
-            metricsRecorderKit,
-            walletsProvisioned,
-            totalMintedConverted,
-            totalMintedProvided,
-          } = this.state;
-          void metricsRecorderKit.recorder.write(
-            harden({
-              walletsProvisioned,
-              totalMintedProvided,
-              totalMintedConverted,
-            }),
-          );
-        },
-        onTrade(converted) {
-          const { state, facets } = this;
-          state.totalMintedConverted = AmountMath.add(
-            state.totalMintedConverted,
-            converted,
-          );
-          facets.helper.publishMetrics();
-        },
-        onSendFunds(provided) {
-          const { state, facets } = this;
-          state.totalMintedProvided = AmountMath.add(
-            state.totalMintedProvided,
-            provided,
-          );
-          facets.helper.publishMetrics();
-        },
-        onProvisioned() {
-          const { state, facets } = this;
-          state.walletsProvisioned += 1n;
-          facets.helper.publishMetrics();
-        },
-        /** @param {ERef<Bank>} destBank */
-        async sendInitialPayment(destBank) {
-          const {
-            facets: { helper },
-            state: { fundPurse, poolBrand },
-          } = this;
-          const perAccountInitialAmount = /** @type {Amount<'nat'>} */ (
-            params.getPerAccountInitialAmount()
-          );
-          const initialPmt = await E(fundPurse).withdraw(
-            perAccountInitialAmount,
-          );
-
-          const destPurse = E(destBank).getPurse(poolBrand);
-          return E(destPurse)
-            .deposit(initialPmt)
-            .then(amt => {
-              helper.onSendFunds(perAccountInitialAmount);
-              console.log('provisionPool sent', amt);
-            })
-            .catch(reason => {
-              console.error(X`initial deposit failed: ${q(reason)}`);
-              void E(fundPurse).deposit(initialPmt);
-              throw reason;
-            });
-        },
-        /**
-         * @param {object} [options]
-         * @param {MetricsNotification} [options.metrics]
-         */
-        start({ metrics } = {}) {
-          const {
-            state: { brandToPSM, poolBrand },
-            facets: { helper },
-          } = this;
-
-          // Must match. poolBrand is from durable state and the param is from
-          // the contract, so it technically can change between incarnations.
-          // That would be a severe bug.
-          AmountMath.coerce(poolBrand, params.getPerAccountInitialAmount());
-
-          void observeIteration(
-            subscribeEach(E(poolBank).getAssetSubscription()),
-            {
-              updateState: async desc => {
-                console.log('provisionPool notified of new asset', desc.brand);
-                await zcf.saveIssuer(desc.issuer, desc.issuerName);
-                /** @type {ERef<Purse>} */
-                // @ts-expect-error vbank purse is close enough for our use.
-                const exchangePurse = E(poolBank).getPurse(desc.brand);
-                void observeNotifier(
-                  E(exchangePurse).getCurrentAmountNotifier(),
-                  {
-                    updateState: async amount => {
-                      console.log('provisionPool balance update', amount);
-                      if (
-                        AmountMath.isEmpty(amount) ||
-                        amount.brand === poolBrand
-                      ) {
-                        return;
-                      }
-                      if (!brandToPSM.has(desc.brand)) {
-                        console.error(
-                          'funds arrived but no PSM instance',
-                          desc.brand,
-                        );
-                        return;
-                      }
-                      const instance = brandToPSM.get(desc.brand);
-                      const payment = E(exchangePurse).withdraw(amount);
-                      await helper
-                        .swap(payment, amount, instance)
-                        .catch(async reason => {
-                          console.error(X`swap failed: ${reason}`);
-                          const resolvedPayment = await payment;
-                          return E(exchangePurse).deposit(resolvedPayment);
-                        });
-                    },
-                    fail: reason => console.error(reason),
-                  },
-                );
-              },
-            },
-          );
-
-          if (metrics) {
-            // Restore state.
-            // we publishMetrics() below
-            const {
-              walletsProvisioned,
-              totalMintedProvided,
-              totalMintedConverted,
-            } = metrics;
-            assert.typeof(walletsProvisioned, 'bigint');
-            AmountMath.coerce(poolBrand, totalMintedProvided);
-            AmountMath.coerce(poolBrand, totalMintedConverted);
-            Object.assign(this.state, {
-              walletsProvisioned,
-              totalMintedProvided,
-              totalMintedConverted,
-            });
-            helper.publishMetrics();
-          }
-        },
-        /**
-         * @param {ERef<Payment>} payIn
-         * @param {Amount} amount
-         * @param {PsmInstance} instance
-         */
-        async swap(payIn, amount, instance) {
-          const {
-            facets: { helper },
-            state: { fundPurse },
-          } = this;
-          const psmPub = E(zoe).getPublicFacet(instance);
-          const proposal = harden({ give: { In: amount } });
-          const invitation = E(psmPub).makeWantMintedInvitation();
-          const seat = E(zoe).offer(invitation, proposal, { In: payIn });
-          const payout = await E(seat).getPayout('Out');
-          const rxd = await E(fundPurse).deposit(payout);
-          helper.onTrade(rxd);
-          return rxd;
-        },
-      },
-      public: {
-        getPublicTopics() {
-          return {
-            metrics: makeRecorderTopic(
-              'Provision Pool metrics',
-              this.state.metricsRecorderKit,
-            ),
-          };
-        },
-      },
-    },
-    {
-      finish: ({ facets }) => {
-        facets.helper.publishMetrics();
-      },
-    },
-  );
-
-  /**
-   * Prepare synchronous values before passing to real Exo maker
-   *
-   * @param {object} opts
-   * @param {Brand} opts.poolBrand
-   * @param {ERef<StorageNode>} opts.storageNode
-   */
-  const makeProvisionPoolKit = async ({ poolBrand, storageNode }) => {
-    /** @type {Purse<'nat'>} */
-    // @ts-expect-error vbank purse is close enough for our use.
-    const fundPurse = await E(poolBank).getPurse(poolBrand);
-    const metricsNode = await E(storageNode).makeChildNode('metrics');
-
-    return makeProvisionPoolKitInternal({
-      fundPurse,
-      poolBrand,
-      metricsNode,
-    });
-  };
-
-  return makeProvisionPoolKit;
-};

package/src/psm/psm.d.ts

@@ -1,178 +0,0 @@
-/**
- * @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.
- */
-/**
- * @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
- */
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
-/** @type {ContractMeta} */
-export const meta: ContractMeta;
-export function start(zcf: ZCF<GovernanceTerms<{
-    GiveMintedFee: 'ratio';
-    WantMintedFee: 'ratio';
-    MintLimit: 'amount';
-}> & {
-    anchorBrand: Brand<'nat'>;
-    anchorPerMinted: Ratio;
-}>, privateArgs: {
-    feeMintAccess: FeeMintAccess;
-    initialPoserInvitation: Invitation;
-    storageNode: StorageNode;
-    marshaller: Marshaller;
-}, baggage: Baggage): Promise<{
-    creatorFacet: {
-        getParamMgrRetriever: () => {
-            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
-                GiveMintedFee: "ratio";
-                MintLimit: "amount";
-                WantMintedFee: "ratio";
-            } & {
-                Electorate: "invitation";
-            }>;
-        } & 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<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";
-            }>;
-        } & 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<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 start>>['publicFacet'];
-//# sourceMappingURL=psm.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"psm.d.ts","sourceRoot":"","sources":["psm.js"],"names":[],"mappings":"AAyCA;;;;;;GAMG;AAEH;;;;;;;;;;;;;GAaG;AAEH,4DAA4D;AAE5D,2BAA2B;AAC3B,mBADW,YAAY,CAkCrB;AAsBK;mBAhBe,OAAO;mBACP,OAAO;eACX,QAAQ;;iBAEN,MAAM,KAAK,CAAC;qBACR,KAAK;iBAGlB;IACV,aAAiB,EAAE,aAAa,CAAC;IACjC,sBAA0B,EAAE,UAAU,CAAC;IACvC,WAAe,EAAE,WAAW,CAAC;IAC7B,UAAc,EAAE,UAAU,CAAC;CACxB,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsUjB;;;;;;;;;;uBA1Ya,OAAO,KAAK,CAAC;;;;;uBAEb,OAAO,KAAK,CAAC;;;;;oBAEb,OAAO,KAAK,CAAC;;;;;yBAEb,OAAO,KAAK,CAAC;;;;;yBAEb,OAAO,KAAK,CAAC;;sBAIb,OAAO,kBAAkB,EAAE,OAAO;6BAiYlC,QAAQ,WAAW,YAAY,CAAC,CAAC,CAAC,aAAa,CAAC"}

package/src/psm/types.d.ts

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

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

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

package/src/reserve/assetReserve.d.ts

@@ -1,44 +0,0 @@
-/** @type {ContractMeta} */
-export const meta: ContractMeta;
-export function start(zcf: ZCF<GovernanceTerms<{}> & {
-    governedApis: ['burnFeesToReduceShortfall'];
-}>, privateArgs: {
-    feeMintAccess: FeeMintAccess;
-    initialPoserInvitation: Invitation;
-    marshaller: ERef<Marshaller>;
-    storageNode: ERef<StorageNode>;
-}, baggage: Baggage): 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 start>>['publicFacet'];
-/**
- * the creator facet for the governor
- */
-export type AssetReserveCreatorFacet = Awaited<ReturnType<typeof start>>['creatorFacet'];
-//# sourceMappingURL=assetReserve.d.ts.map