@agoric/inter-protocol 0.13.3 → 0.13.4-dev-d32a66a.0

package/src/vaultFactory/params.js

@@ -1,16 +1,17 @@
-// @ts-check
+// @jessie-check
 
 import './types.js';
 
 import {
   CONTRACT_ELECTORATE,
   makeParamManagerSync,
-  makeParamManager,
   ParamTypes,
 } from '@agoric/governance';
 import { makeStoredPublisherKit } from '@agoric/notifier';
-import { M } from '@agoric/store';
-import { TimeMath } from '@agoric/swingset-vat/src/vats/timer/timeMath.js';
+import { M, makeScalarMapStore } from '@agoric/store';
+import { TimeMath } from '@agoric/time';
+import { provideDurableMapStore } from '@agoric/vat-data';
+import { subtractRatios } from '@agoric/zoe/src/contractSupport/ratio.js';
 import { amountPattern, ratioPattern } from '../contractSupport.js';
 
 export const CHARGING_PERIOD_KEY = 'ChargingPeriod';
@@ -18,41 +19,41 @@ export const RECORDING_PERIOD_KEY = 'RecordingPeriod';
 
 export const DEBT_LIMIT_KEY = 'DebtLimit';
 export const LIQUIDATION_MARGIN_KEY = 'LiquidationMargin';
+export const LIQUIDATION_PADDING_KEY = 'LiquidationPadding';
 export const LIQUIDATION_PENALTY_KEY = 'LiquidationPenalty';
 export const INTEREST_RATE_KEY = 'InterestRate';
-export const LOAN_FEE_KEY = 'LoanFee';
-export const LIQUIDATION_INSTALL_KEY = 'LiquidationInstall';
-export const LIQUIDATION_TERMS_KEY = 'LiquidationTerms';
+export const MINT_FEE_KEY = 'MintFee';
 export const MIN_INITIAL_DEBT_KEY = 'MinInitialDebt';
 export const SHORTFALL_INVITATION_KEY = 'ShortfallInvitation';
+export const ENDORSED_UI_KEY = 'EndorsedUI';
+
+export const vaultDirectorParamTypes = {
+  [MIN_INITIAL_DEBT_KEY]: ParamTypes.AMOUNT,
+  [CHARGING_PERIOD_KEY]: ParamTypes.NAT,
+  [RECORDING_PERIOD_KEY]: ParamTypes.NAT,
+  [ENDORSED_UI_KEY]: ParamTypes.STRING,
+};
+harden(vaultDirectorParamTypes);
 
 /**
- * @param {Amount} electorateInvitationAmount
- * @param {Installation} liquidationInstall
- * @param {import('./liquidation.js').LiquidationTerms} liquidationTerms
- * @param {Amount} minInitialDebt
- * @param {Amount} shortfallInvitationAmount
+ * @param {Amount<'set'>} electorateInvitationAmount
+ * @param {Amount<'nat'>} minInitialDebt
+ * @param {Amount<'set'>} shortfallInvitationAmount
+ * @param {string} endorsedUi
+ * @param {InterestTiming} interestTiming
  */
 const makeVaultDirectorParams = (
   electorateInvitationAmount,
-  liquidationInstall,
-  liquidationTerms,
   minInitialDebt,
   shortfallInvitationAmount,
+  endorsedUi,
+  interestTiming,
 ) => {
   return harden({
     [CONTRACT_ELECTORATE]: {
       type: ParamTypes.INVITATION,
       value: electorateInvitationAmount,
     },
-    [LIQUIDATION_INSTALL_KEY]: {
-      type: ParamTypes.INSTALLATION,
-      value: liquidationInstall,
-    },
-    [LIQUIDATION_TERMS_KEY]: {
-      type: ParamTypes.UNKNOWN,
-      value: liquidationTerms,
-    },
     [MIN_INITIAL_DEBT_KEY]: {
       type: ParamTypes.AMOUNT,
       value: minInitialDebt,
@@ -61,136 +62,156 @@ const makeVaultDirectorParams = (
       type: ParamTypes.INVITATION,
       value: shortfallInvitationAmount,
     },
+    [ENDORSED_UI_KEY]: { type: ParamTypes.STRING, value: endorsedUi },
+    [CHARGING_PERIOD_KEY]: {
+      type: ParamTypes.NAT,
+      value: TimeMath.relValue(interestTiming.chargingPeriod),
+    },
+    [RECORDING_PERIOD_KEY]: {
+      type: ParamTypes.NAT,
+      value: TimeMath.relValue(interestTiming.recordingPeriod),
+    },
   });
 };
+harden(makeVaultDirectorParams);
 
 /** @typedef {import('@agoric/governance/src/contractGovernance/typedParamManager').ParamTypesMapFromRecord<ReturnType<typeof makeVaultDirectorParams>>} VaultDirectorParams */
 
+/** @type {(liquidationMargin: Ratio) => Ratio} */
+const zeroRatio = liquidationMargin =>
+  subtractRatios(liquidationMargin, liquidationMargin);
+
 /**
  * @param {import('@agoric/notifier').StoredPublisherKit<GovernanceSubscriptionState>} publisherKit
  * @param {VaultManagerParamValues} initial
  */
-const makeVaultParamManager = (publisherKit, initial) =>
+export const makeVaultParamManager = (
+  publisherKit,
+  {
+    debtLimit,
+    interestRate,
+    liquidationMargin,
+    liquidationPadding = zeroRatio(liquidationMargin),
+    liquidationPenalty,
+    mintFee,
+  },
+) =>
   makeParamManagerSync(publisherKit, {
-    [DEBT_LIMIT_KEY]: [ParamTypes.AMOUNT, initial.debtLimit],
-    [LIQUIDATION_MARGIN_KEY]: [ParamTypes.RATIO, initial.liquidationMargin],
-    [LIQUIDATION_PENALTY_KEY]: [ParamTypes.RATIO, initial.liquidationPenalty],
-    [INTEREST_RATE_KEY]: [ParamTypes.RATIO, initial.interestRate],
-    [LOAN_FEE_KEY]: [ParamTypes.RATIO, initial.loanFee],
+    [DEBT_LIMIT_KEY]: [ParamTypes.AMOUNT, debtLimit],
+    [INTEREST_RATE_KEY]: [ParamTypes.RATIO, interestRate],
+    [LIQUIDATION_PADDING_KEY]: [ParamTypes.RATIO, liquidationPadding],
+    [LIQUIDATION_MARGIN_KEY]: [ParamTypes.RATIO, liquidationMargin],
+    [LIQUIDATION_PENALTY_KEY]: [ParamTypes.RATIO, liquidationPenalty],
+    [MINT_FEE_KEY]: [ParamTypes.RATIO, mintFee],
   });
 /** @typedef {ReturnType<typeof makeVaultParamManager>} VaultParamManager */
 
-export const vaultParamPattern = M.split(
+export const vaultParamPattern = M.splitRecord(
   {
     liquidationMargin: ratioPattern,
     liquidationPenalty: ratioPattern,
     interestRate: ratioPattern,
-    loanFee: ratioPattern,
+    mintFee: ratioPattern,
     debtLimit: amountPattern,
   },
-  M.any(),
+  {
+    // optional for backwards compatibility, e.g. with loadgen
+    liquidationPadding: ratioPattern,
+  },
 );
 
 /**
- * @param {import('@agoric/notifier').StoredPublisherKit<GovernanceSubscriptionState>} publisherKit
- * @param {ERef<ZoeService>} zoe
- * @param {Invitation} electorateInvitation
- * @param {Installation} liquidationInstall
- * @param {object} liquidationTerms
- * @param {Amount} minInitialDebt
- * @param {Invitation} shortfallInvitation
- */
-const makeVaultDirectorParamManager = async (
-  publisherKit,
-  zoe,
-  electorateInvitation,
-  liquidationInstall,
-  liquidationTerms,
-  minInitialDebt,
-  shortfallInvitation,
-) => {
-  return makeParamManager(
-    publisherKit,
-    {
-      [CONTRACT_ELECTORATE]: [ParamTypes.INVITATION, electorateInvitation],
-      [LIQUIDATION_INSTALL_KEY]: [ParamTypes.INSTALLATION, liquidationInstall],
-      [LIQUIDATION_TERMS_KEY]: [ParamTypes.UNKNOWN, liquidationTerms],
-      [MIN_INITIAL_DEBT_KEY]: [ParamTypes.AMOUNT, minInitialDebt],
-      [SHORTFALL_INVITATION_KEY]: [ParamTypes.INVITATION, shortfallInvitation],
-    },
-    zoe,
-  );
-};
-
-/**
- * @param {{storageNode: ERef<StorageNode>, marshaller: ERef<Marshaller>}} caps
  * @param {{
- *   electorateInvitationAmount: Amount,
- *   minInitialDebt: Amount,
+ *   auctioneerPublicFacet: ERef<AuctioneerPublicFacet>,
+ *   electorateInvitationAmount: Amount<'set'>,
+ *   minInitialDebt: Amount<'nat'>,
  *   bootstrapPaymentValue: bigint,
  *   priceAuthority: ERef<PriceAuthority>,
- *   timer: ERef<TimerService>,
+ *   timer: ERef<import('@agoric/time/src/types').TimerService>,
  *   reservePublicFacet: AssetReservePublicFacet,
- *   liquidationInstall: Installation,
- *   loanTiming: LoanTiming,
- *   liquidationTerms: import('./liquidation.js').LiquidationTerms,
- *   ammPublicFacet: XYKAMMPublicFacet,
- *   shortfallInvitationAmount: Amount,
+ *   interestTiming: InterestTiming,
+ *   shortfallInvitationAmount: Amount<'set'>,
+ *   endorsedUi?: string,
  * }} opts
  */
-const makeGovernedTerms = (
-  { storageNode, marshaller },
-  {
-    ammPublicFacet,
-    bootstrapPaymentValue,
-    electorateInvitationAmount,
-    liquidationInstall,
-    liquidationTerms,
-    loanTiming,
-    minInitialDebt,
-    priceAuthority,
-    reservePublicFacet,
-    timer,
-    shortfallInvitationAmount,
-  },
-) => {
-  const loanTimingParams = makeParamManagerSync(
-    makeStoredPublisherKit(storageNode, marshaller, 'timingParams'),
-    {
-      [CHARGING_PERIOD_KEY]: [
-        'nat',
-        TimeMath.relValue(loanTiming.chargingPeriod),
-      ],
-      [RECORDING_PERIOD_KEY]: [
-        'nat',
-        TimeMath.relValue(loanTiming.recordingPeriod),
-      ],
-    },
-  ).getParams();
-
+export const makeGovernedTerms = ({
+  auctioneerPublicFacet,
+  bootstrapPaymentValue,
+  electorateInvitationAmount,
+  interestTiming,
+  minInitialDebt,
+  priceAuthority,
+  reservePublicFacet,
+  timer,
+  shortfallInvitationAmount,
+  endorsedUi = 'NO ENDORSEMENT',
+}) => {
   return harden({
-    ammPublicFacet,
+    auctioneerPublicFacet,
     priceAuthority,
-    loanTimingParams,
     reservePublicFacet,
     timerService: timer,
     governedParams: makeVaultDirectorParams(
       electorateInvitationAmount,
-      liquidationInstall,
-      liquidationTerms,
       minInitialDebt,
       shortfallInvitationAmount,
+      endorsedUi,
+      interestTiming,
     ),
     bootstrapPaymentValue,
   });
 };
-
-harden(makeVaultParamManager);
-harden(makeVaultDirectorParamManager);
 harden(makeGovernedTerms);
+/**
+ * Stop-gap which restores initial param values
+ * UNTIL https://github.com/Agoric/agoric-sdk/issues/5200
+ *
+ * NB: changes from initial values will be lost upon restart
+ *
+ * @param {import('@agoric/vat-data').Baggage} baggage
+ * @param {ERef<Marshaller>} marshaller
+ */
+export const provideVaultParamManagers = (baggage, marshaller) => {
+  /** @type {MapStore<Brand, VaultParamManager>} */
+  const managers = makeScalarMapStore();
+
+  // the managers aren't durable but their arguments are
+  /** @type {MapStore<Brand, {storageNode: StorageNode, initialParamValues: VaultManagerParamValues}>} */
+  const managerArgs = provideDurableMapStore(
+    baggage,
+    'vault param manager parts',
+  );
+
+  const makeManager = (brand, { storageNode, initialParamValues }) => {
+    const manager = makeVaultParamManager(
+      makeStoredPublisherKit(storageNode, marshaller, 'governance'),
+      initialParamValues,
+    );
+    managers.init(brand, manager);
+    return manager;
+  };
+
+  // restore from baggage
+  [...managerArgs.entries()].map(([brand, args]) => makeManager(brand, args));
 
-export {
-  makeVaultDirectorParamManager,
-  makeVaultParamManager,
-  makeGovernedTerms,
+  return {
+    /**
+     *
+     * @param {Brand} brand
+     * @param {StorageNode} storageNode
+     * @param {VaultManagerParamValues} initialParamValues
+     */
+    addParamManager(brand, storageNode, initialParamValues) {
+      const args = harden({ storageNode, initialParamValues });
+      managerArgs.init(brand, args);
+      return makeManager(brand, args);
+    },
+    /**
+     * @param {Brand} brand
+     */
+    get(brand) {
+      return managers.get(brand);
+    },
+  };
 };
+harden(provideVaultParamManagers);

package/src/vaultFactory/prioritizedVaults.js

@@ -1,22 +1,24 @@
-// @ts-check
 // @jessie-check
 
+import { makeTracer } from '@agoric/internal';
 import { makeRatioFromAmounts } from '@agoric/zoe/src/contractSupport/index.js';
 import { AmountMath } from '@agoric/ertp';
-import { ratioGTE } from '@agoric/zoe/src/contractSupport/ratio.js';
 import { Far } from '@endo/marshal';
-import { keyEQ, keyLT } from '@agoric/store';
+import { M } from '@agoric/vat-data';
+import { makeScalarMapStore } from '@agoric/store';
 import { makeOrderedVaultStore } from './orderedVaultStore.js';
-import { fromVaultKey, toVaultKey } from './storeUtils.js';
-import { makeTracer } from '../makeTracer.js';
-
-const trace = makeTracer('PV', false);
+import {
+  toVaultKey,
+  normalizedCollRatioKey,
+  normalizedCollRatio,
+} from './storeUtils.js';
 
 /** @typedef {import('./vault').Vault} Vault */
 /** @typedef {import('./storeUtils.js').NormalizedDebt} NormalizedDebt */
 
+const trace = makeTracer('PVaults', true);
+
 /**
- *
  * @param {Amount<'nat'>} debtAmount
  * @param {Amount<'nat'>} collateralAmount
  * @returns {Ratio}
@@ -32,7 +34,6 @@ const calculateDebtToCollateral = (debtAmount, collateralAmount) => {
 };
 
 /**
- *
  * @param {Vault} vault
  * @returns {Ratio}
  */
@@ -47,43 +48,15 @@ export const currentDebtToCollateral = vault =>
  * can be quickly found and liquidated.
  *
  * @param {MapStore<string, Vault>} store
- * @param {(highestRatio: Ratio) => void} [higherHighestCb] called when a new
  * vault has a higher debt ratio than the previous highest
  */
-export const makePrioritizedVaults = (store, higherHighestCb = () => {}) => {
+export const makePrioritizedVaults = store => {
   const vaults = makeOrderedVaultStore(store);
 
-  /**
-   * Called back when there's a new highestRatio and it's higher than the previous.
-   *
-   * In other words, when a new highestRatio results from adding a vault. Removing the
-   * first vault also changes the highest, but necessarily to a lower highest,
-   * for which there are no use cases requiring notification.
-   *
-   * @param {(highestRatio: Ratio) => void} callback
-   */
-  const onHigherHighest = callback => {
-    higherHighestCb = callback;
-  };
-
-  // To deal with fluctuating prices and varying collateralization, we schedule a
-  // new request to the priceAuthority when some vault's debtToCollateral ratio
-  // surpasses the current high-water mark. When the request that is at the
-  // current high-water mark fires, we reschedule at the new (presumably
-  // lower) rate.
-  // Without this we'd be calling reschedulePriceCheck() unnecessarily
-  /** @type {string=} */
-  let firstKey;
-
-  // Check if this ratio of debt to collateral would be the highest known. If
-  // so, reset our highest and invoke the callback. This can be called on new
-  // vaults and when we get a state update for a vault changing balances.
-  /** @param {Ratio} collateralToDebt */
-
   /**
    * Ratio of the least-collateralized vault, if there is one.
    *
-   * @returns {Ratio=} actual debt over collateral
+   * @returns {Ratio | undefined} actual debt over collateral
    */
   const highestRatio = () => {
     if (vaults.getSize() === 0) {
@@ -99,7 +72,6 @@ export const makePrioritizedVaults = (store, higherHighestCb = () => {}) => {
   };
 
   /**
-   *
    * @param {NormalizedDebt} oldDebt
    * @param {Amount<'nat'>} oldCollateral
    * @param {string} vaultId
@@ -115,16 +87,10 @@ export const makePrioritizedVaults = (store, higherHighestCb = () => {}) => {
    */
   const removeVault = key => {
     const vault = vaults.removeByKey(key);
-    trace('removeVault', key, fromVaultKey(key), 'when first:', firstKey);
-    if (keyEQ(key, firstKey)) {
-      const [secondKey] = vaults.keys();
-      firstKey = secondKey;
-    }
     return vault;
   };
 
   /**
-   *
    * @param {NormalizedDebt} oldDebt
    * @param {Amount<'nat'>} oldCollateral
    * @param {string} vaultId
@@ -135,7 +101,6 @@ export const makePrioritizedVaults = (store, higherHighestCb = () => {}) => {
   };
 
   /**
-   *
    * @param {VaultId} vaultId
    * @param {Vault} vault
    */
@@ -145,50 +110,42 @@ export const makePrioritizedVaults = (store, higherHighestCb = () => {}) => {
       !AmountMath.isEmpty(vault.getCollateralAmount()),
       'Tracked vaults must have collateral (be liquidatable)',
     );
-    trace('addVault', key, 'when first:', firstKey);
-    if (!firstKey || keyLT(key, firstKey)) {
-      firstKey = key;
-      higherHighestCb(currentDebtToCollateral(vault));
-    }
     return key;
   };
 
-  /**
-   * Invoke a function for vaults with debt to collateral at or above the ratio.
-   *
-   * Results are returned in order of priority, with highest debt to collateral first.
-   *
-   * Redundant tags until https://github.com/Microsoft/TypeScript/issues/23857
-   *
-   * @param {Ratio} ratio
-   * @yields {[string, Vault]>}
-   * @returns {IterableIterator<[string, Vault]>}
-   */
-  // Allow generator function
-  // eslint-disable-next-line func-names
-  // eslint-disable-next-line no-restricted-syntax
-  function* entriesPrioritizedGTE(ratio) {
-    // TODO use a Pattern to limit the query https://github.com/Agoric/agoric-sdk/issues/4550
-    for (const [key, vault] of vaults.entries()) {
-      const debtToCollateral = currentDebtToCollateral(vault);
-      if (ratioGTE(debtToCollateral, ratio)) {
-        yield [key, vault];
-      } else {
-        // stop once we are below the target ratio
-        break;
-      }
+  const removeVaultsBelow = ({ margin, quote, interest }) => {
+    // crKey represents a collateralizationRatio based on the locked price, the
+    // interest charged so far, and the liquidation margin.
+    // We'll remove all vaults below that ratio, and return them.
+    const crKey = normalizedCollRatioKey(quote, interest, margin);
+
+    trace(
+      `Liquidating vaults worse than`,
+      normalizedCollRatio(quote, interest, margin),
+    );
+
+    /** @type {MapStore<string, Vault>} */
+    const vaultsRemoved = makeScalarMapStore();
+
+    for (const [key, vault] of vaults.entries(M.lte(crKey))) {
+      vaultsRemoved.init(key, vault);
+      vaults.removeByKey(key);
     }
-  }
+
+    return vaultsRemoved;
+  };
 
   return Far('PrioritizedVaults', {
     addVault,
     entries: vaults.entries,
-    entriesPrioritizedGTE,
     getCount: vaults.getSize,
     hasVaultByAttributes,
     highestRatio,
     removeVault,
     removeVaultByAttributes,
-    onHigherHighest,
+    removeVaultsBelow,
+
+    // visible for testing
+    countVaultsBelow: crKey => vaults.getSize(M.lte(crKey)),
   });
 };

package/src/vaultFactory/storeUtils.js

@@ -1,4 +1,5 @@
-// @ts-check
+// @jessie-check
+
 /**
  * Module to improvise composite keys for orderedVaultStore until Collections
  * API supports them.
@@ -6,7 +7,17 @@
 
 // XXX importing these that are declared to be used only for testing
 // until @agoric/store supports composite keys
-import { makeDecodePassable, makeEncodePassable } from '@agoric/store';
+import { makeDecodePassable, makeEncodePassable } from '@endo/marshal';
+import {
+  getAmountIn,
+  getAmountOut,
+  natSafeMath,
+} from '@agoric/zoe/src/contractSupport/index.js';
+import { makeTracer } from '@agoric/internal';
+
+const { multiply } = natSafeMath;
+
+const trace = makeTracer('Store', true);
 
 /**
  * @typedef {import('@endo/marshal').PureData} PureData
@@ -25,7 +36,7 @@ import { makeDecodePassable, makeEncodePassable } from '@agoric/store';
  * @param {PureData} key
  * @returns {string}
  */
-const encodeData = makeEncodePassable();
+export const encodeData = makeEncodePassable();
 
 // `makeDecodePassable` has three named options:
 // `decodeRemotable`, `decodeError`, and `decodePromise`.
@@ -36,7 +47,7 @@ const encodeData = makeEncodePassable();
  * @param {string} encoded
  * @returns {PureData}
  */
-const decodeData = makeDecodePassable();
+export const decodeData = makeDecodePassable();
 
 /**
  * @param {number} n
@@ -86,7 +97,7 @@ const collateralizationRatio = (normalizedDebt, collateral) => {
  * @returns {string} lexically sortable string in which highest
  * debt-to-collateral is earliest
  */
-const toVaultKey = (normalizedDebt, collateral, vaultId) => {
+export const toVaultKey = (normalizedDebt, collateral, vaultId) => {
   assert(normalizedDebt);
   assert(collateral);
   assert(vaultId);
@@ -95,19 +106,66 @@ const toVaultKey = (normalizedDebt, collateral, vaultId) => {
   const numberPart = encodeNumber(
     collateralizationRatio(normalizedDebt, collateral),
   );
+
+  trace(`To Vault Key `, collateralizationRatio(normalizedDebt, collateral));
   return `${numberPart}:${vaultId}`;
 };
+harden(toVaultKey);
 
 /**
  * @param {string} key
  * @returns {[normalizedCollateralization: number, vaultId: VaultId]}
  */
-const fromVaultKey = key => {
+export const fromVaultKey = key => {
   const [numberPart, vaultIdPart] = key.split(':');
   return [decodeNumber(numberPart), vaultIdPart];
 };
-
 harden(fromVaultKey);
-harden(toVaultKey);
 
-export { fromVaultKey, toVaultKey };
+/**
+ * Create a float representing a Normalized Collateralization Ratio that can be
+ * compared to the NCRs of vaults. We want a float with as much resolution as we
+ * can get, so we multiply out the numerator and the denominator, and only
+ * divide the results once.
+ *
+ * For use by `normalizedCollRatioKey` and tests.
+ *
+ * @param {PriceQuote} quote
+ * @param {Ratio} compoundedInterest
+ * @param {Ratio} margin
+ * @returns {number}
+ */
+export const normalizedCollRatio = (quote, compoundedInterest, margin) => {
+  const amountIn = getAmountIn(quote).value;
+  const amountOut = getAmountOut(quote).value;
+  const interestNumerator = compoundedInterest.numerator.value;
+  const interestBase = compoundedInterest.denominator.value;
+  const numerator = multiply(
+    margin.numerator.value,
+    multiply(amountIn, interestNumerator),
+  );
+  const denominator = multiply(
+    amountOut,
+    multiply(interestBase, margin.denominator.value),
+  );
+
+  return Number(numerator) / Number(denominator);
+};
+harden(normalizedCollRatio);
+
+/**
+ * Create a sort key for a normalized collateralization ratio. We want the key
+ * to be based on a float with as much resolution as we can get, so we multiply
+ * out the numerator and the denominator, and divide only once.
+ *
+ * @param {PriceQuote} quote
+ * @param {Ratio} compoundedInterest
+ * @param {Ratio} margin
+ * @returns {string} lexically sortable string in which highest
+ * debt-to-collateral is earliest
+ */
+export const normalizedCollRatioKey = (quote, compoundedInterest, margin) => {
+  const collRatio = normalizedCollRatio(quote, compoundedInterest, margin);
+  return `${encodeNumber(collRatio)}:`;
+};
+harden(normalizedCollRatioKey);

package/src/vaultFactory/type-imports.js

@@ -1,2 +1,4 @@
+// @jessie-check
+
 import '@agoric/zoe/exported.js';
 import './types.js';