@agoric/zoe 0.26.2 → 0.26.3-calypso-dev-84eb287.0

package/src/contractFacet/zcfZygote.js

@@ -1,36 +1,37 @@
-import { E } from '@endo/eventual-send';
-import { passStyleOf, Remotable } from '@endo/marshal';
+/* eslint @typescript-eslint/no-floating-promises: "warn" */
 import { AssetKind } from '@agoric/ertp';
-import { makePromiseKit } from '@endo/promise-kit';
 import { assertPattern, mustMatch } from '@agoric/store';
 import {
   canBeDurable,
   M,
   makeScalarBigMapStore,
-  provideDurableMapStore,
   prepareExo,
   prepareExoClass,
+  provideDurableMapStore,
 } from '@agoric/vat-data';
+import { E } from '@endo/eventual-send';
+import { passStyleOf } from '@endo/pass-style';
+import { makePromiseKit } from '@endo/promise-kit';
 
 import { objectMap } from '@agoric/internal';
 import { cleanProposal } from '../cleanProposal.js';
+import { handlePKitWarning } from '../handleWarning.js';
+import { makeInstanceRecordStorage } from '../instanceRecordStorage.js';
+import { provideIssuerStorage } from '../issuerStorage.js';
+import { defineDurableHandle } from '../makeHandle.js';
 import { evalContractBundle } from './evalContractCode.js';
 import { makeMakeExiter } from './exit.js';
-import { defineDurableHandle } from '../makeHandle.js';
-import { provideIssuerStorage } from '../issuerStorage.js';
-import { createSeatManager } from './zcfSeat.js';
-import { makeInstanceRecordStorage } from '../instanceRecordStorage.js';
-import { handlePKitWarning } from '../handleWarning.js';
 import { makeOfferHandlerStorage } from './offerHandlerStorage.js';
+import { createSeatManager } from './zcfSeat.js';
 
-import '../internal-types.js';
-import './internal-types.js';
-
-import '@agoric/swingset-vat/src/types-ambient.js';
 import { HandleOfferI, InvitationHandleShape } from '../typeGuards.js';
 import { prepareZcMint } from './zcfMint.js';
+import { ZcfI } from './typeGuards.js';
+
+/// <reference path="../internal-types.js" />
+/// <reference path="./internal-types.js" />
 
-/** @typedef {import('@agoric/ertp').IssuerOptionsRecord} IssuerOptionsRecord */
+/** @import {IssuerOptionsRecord} from '@agoric/ertp' */
 
 const { Fail } = assert;
 
@@ -76,9 +77,9 @@ export const makeZCFZygote = async (
     instantiate: instantiateIssuerStorage,
   } = provideIssuerStorage(zcfBaggage);
 
-  /** @type {ShutdownWithFailure} */
+  /** @type {import('@agoric/swingset-vat').ShutdownWithFailure} */
   const shutdownWithFailure = reason => {
-    E(zoeInstanceAdmin).failAllSeats(reason);
+    void E(zoeInstanceAdmin).failAllSeats(reason);
     seatManager.dropAllReferences();
     // https://github.com/Agoric/agoric-sdk/issues/3239
     powers.exitVatWithFailure(reason);
@@ -114,7 +115,7 @@ export const makeZCFZygote = async (
     const zcfSeat = seatManager.makeZCFSeat(seatData);
 
     const exiter = makeExiter(seatData.proposal, zcfSeat);
-    E(zoeInstanceAdmin)
+    void E(zoeInstanceAdmin)
       .makeNoEscrowSeat(initialAllocation, proposal, exiter, seatHandle)
       .then(userSeat => userSeatPromiseKit.resolve(userSeat));
 
@@ -210,6 +211,25 @@ export const makeZCFZygote = async (
   });
   const handleOfferObj = makeHandleOfferObj(taker);
 
+  /**
+   * @type {() => Promise<
+   *   | {
+   *       buildRootObject: any;
+   *       start: undefined;
+   *       meta: undefined;
+   *     }
+   *   | {
+   *       prepare: ContractStartFn;
+   *       customTermsShape?: Pick<ContractMeta, 'customTermsShape'>,
+   *       privateArgsShape?: Pick<ContractMeta, 'privateArgsShape'>,
+   *     }
+   *   | {
+   *       buildRootObject: undefined;
+   *       start: ContractStartFn;
+   *       meta?: ContractMeta;
+   *     }
+   * >}
+   */
   const evaluateContract = () => {
     let bundle;
     if (passStyleOf(contractBundleCap) === 'remotable') {
@@ -222,29 +242,48 @@ export const makeZCFZygote = async (
     return evalContractBundle(bundle);
   };
   // evaluate the contract (either the first version, or an upgrade)
-  const {
-    start,
-    buildRootObject,
-    privateArgsShape,
-    customTermsShape,
-    prepare,
-  } = await evaluateContract();
-
-  if (start === undefined && prepare === undefined) {
-    buildRootObject === undefined ||
-      Fail`Did you provide a vat bundle instead of a contract bundle?`;
-    Fail`contract exports missing start/prepare`;
+  const bundleResult = await evaluateContract();
+
+  //#region backwards compatibility with prepare()
+  const { start, meta = {} } = (() => {
+    if ('prepare' in bundleResult) {
+      if ('start' in bundleResult) {
+        Fail`contract must provide exactly one of "start" and "prepare"`;
+      }
+      // A contract must have one expression of upgradability
+      if (/** @type {any} */ (bundleResult).meta?.upgradability) {
+        Fail`prepare() is deprecated and incompatible with the 'upgradability' indicator`;
+      }
+      return {
+        start: bundleResult.prepare,
+        meta: {
+          upgradability: 'canUpgrade',
+          customTermsShape: bundleResult.customTermsShape,
+          privateArgsShape: bundleResult.privateArgsShape,
+        },
+      };
+    }
+    // normal behavior
+    return bundleResult;
+  })();
+  //#endregion
+
+  if (start === undefined) {
+    if ('buildRootObject' in bundleResult) {
+      // diagnose a common mistake
+      throw Fail`Did you provide a vat bundle instead of a contract bundle?`;
+    }
+    throw Fail`contract exports missing start`;
   }
-  !start ||
-    !prepare ||
-    Fail`contract must provide exactly one of "start" and "prepare"`;
+
+  start.length <= 3 || Fail`invalid start parameters`;
+  const durabilityRequired =
+    meta.upgradability &&
+    ['canBeUpgraded', 'canUpgrade'].includes(meta.upgradability);
 
   /** @type {ZCF} */
-  // Using Remotable rather than Far because there are too many complications
-  // imposing checking wrappers: makeInvitation() and setJig() want to
-  // accept raw functions. assert cannot be a valid passable! (It's a function
-  // and has members.)
-  const zcf = Remotable('Alleged: zcf', undefined, {
+  const zcf = prepareExo(zcfBaggage, 'zcf', ZcfI, {
+    atomicRearrange: transfers => seatManager.atomicRearrange(transfers),
     reallocate: (...seats) => seatManager.reallocate(...seats),
     assertUniqueKeyword: kwd => getInstanceRecHolder().assertUniqueKeyword(kwd),
     saveIssuer: async (issuerP, keyword) => {
@@ -279,11 +318,12 @@ export const makeZCFZygote = async (
         customDetails,
         proposalShape,
       );
-      return invitationP;
+      // rely on the ZCF type signature
+      return /** @type {any} */ (invitationP);
     },
     // Shutdown the entire vat and give payouts
     shutdown: completion => {
-      E(zoeInstanceAdmin).exitAllSeats(completion);
+      void E(zoeInstanceAdmin).exitAllSeats(completion);
       seatManager.dropAllReferences();
       powers.exitVat(completion);
     },
@@ -300,6 +340,7 @@ export const makeZCFZygote = async (
       const terms = getInstanceRecHolder().getTerms();
 
       // If the contract provided customTermsShape, validate the customTerms.
+      const { customTermsShape } = meta;
       if (customTermsShape) {
         const { brands: _b, issuers: _i, ...customTerms } = terms;
         mustMatch(harden(customTerms), customTermsShape, 'customTerms');
@@ -371,14 +412,15 @@ export const makeZCFZygote = async (
       instanceRecHolder = makeInstanceRecord(instanceRecordFromZoe);
       instantiateIssuerStorage(issuerStorageFromZoe);
       zcfBaggage.init('instanceRecHolder', instanceRecHolder);
+      zcfBaggage.init('repairedContractCompletionWatcher', true);
 
-      const startFn = start || prepare;
+      const { privateArgsShape } = meta;
       if (privateArgsShape) {
         mustMatch(privateArgs, privateArgsShape, 'privateArgs');
       }
       // start a contract for the first time
       return E.when(
-        startFn(zcf, privateArgs, contractBaggage),
+        start(zcf, privateArgs, contractBaggage),
         ({
           creatorFacet = undefined,
           publicFacet = undefined,
@@ -387,18 +429,16 @@ export const makeZCFZygote = async (
         }) => {
           const unexpectedKeys = Object.keys(unexpected);
           unexpectedKeys.length === 0 ||
-            Fail`contract ${
-              prepare ? 'prepare' : 'start'
-            } returned unrecognized properties ${unexpectedKeys}`;
+            Fail`contract "start" returned unrecognized properties ${unexpectedKeys}`;
 
           const areDurable = objectMap(
             { creatorFacet, publicFacet, creatorInvitation },
             canBeDurable,
           );
           const allDurable = Object.values(areDurable).every(Boolean);
-          if (prepare) {
+          if (durabilityRequired) {
             allDurable ||
-              Fail`values from prepare() must be durable ${areDurable}`;
+              Fail`with ${meta.upgradability}, values from start() must be durable ${areDurable}`;
           }
 
           if (allDurable) {
@@ -418,18 +458,32 @@ export const makeZCFZygote = async (
     },
 
     restartContract: async (privateArgs = undefined) => {
-      prepare || Fail`prepare must be defined to upgrade a contract`;
+      if (meta.upgradability) {
+        meta.upgradability === 'canUpgrade' || Fail`contract cannot upgrade`;
+      }
       zoeInstanceAdmin = zcfBaggage.get('zcfInstanceAdmin');
       instanceRecHolder = zcfBaggage.get('instanceRecHolder');
       initSeatMgrAndMintKind();
 
+      await null;
+      if (!zcfBaggage.has('repairedContractCompletionWatcher')) {
+        // We don't wait because it's a cross-vat call (to Zoe) that can't be
+        // completed during this vat's start-up
+        E(zoeInstanceAdmin)
+          .repairContractCompletionWatcher()
+          .catch(() => {});
+
+        zcfBaggage.init('repairedContractCompletionWatcher', true);
+      }
+
+      const { privateArgsShape } = meta;
       if (privateArgsShape) {
         mustMatch(privateArgs, privateArgsShape, 'privateArgs');
       }
 
       // restart an upgradeable contract
       return E.when(
-        prepare(zcf, privateArgs, contractBaggage),
+        start(zcf, privateArgs, contractBaggage),
         ({
           creatorFacet = undefined,
           publicFacet = undefined,

package/src/contractSupport/atomicTransfer.d.ts

@@ -3,10 +3,4 @@ export function atomicRearrange(zcf: ZCF, transfers: TransferPart[]): void;
 export function fromOnly(fromSeat: ZCFSeat, fromAmounts: AmountKeywordRecord): TransferPart;
 export function toOnly(toSeat: ZCFSeat, toAmounts: AmountKeywordRecord): TransferPart;
 export function atomicTransfer(zcf: ZCF, fromSeat?: ZCFSeat | undefined, toSeat?: ZCFSeat | undefined, fromAmounts?: AmountKeywordRecord | undefined, toAmounts?: AmountKeywordRecord | undefined): void;
-export type TransferPart = [
-    fromSeat?: ZCFSeat,
-    toSeat?: ZCFSeat,
-    fromAmounts?: AmountKeywordRecord,
-    toAmounts?: AmountKeywordRecord
-];
 //# sourceMappingURL=atomicTransfer.d.ts.map

package/src/contractSupport/atomicTransfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atomicTransfer.d.ts","sourceRoot":"","sources":["atomicTransfer.js"],"names":[],"mappings":"AAMA,iEAGE;AAgDK,qCAHI,GAAG,aACH,cAAc,QA+ExB;AAcM,mCAJI,OAAO,eACP,mBAAmB,gBAIc;AAcrC,+BAJI,OAAO,aACP,mBAAmB,gBAIqB;AAW5C,oCANI,GAAG,kKAYiE;2BAzKlE;IACZ,QAAY,CAAC,EAAE,OAAO;IACtB,MAAU,CAAC,EAAE,OAAO;IACpB,WAAe,CAAC,EAAE,mBAAmB;IACrC,SAAa,CAAC,EAAE,mBAAmB;CAChC"}
+{"version":3,"file":"atomicTransfer.d.ts","sourceRoot":"","sources":["atomicTransfer.js"],"names":[],"mappings":"AAGA,iEAGE;AAyCK,qCAHI,GAAG,aACH,YAAY,EAAE,QAIxB;AAcM,mCAJI,OAAO,eACP,mBAAmB,GACjB,YAAY,CAGmB;AAcrC,+BAJI,OAAO,aACP,mBAAmB,GACjB,YAAY,CAG0B;AAW5C,oCANI,GAAG,kKAYgE"}

package/src/contractSupport/atomicTransfer.js

@@ -1,23 +1,11 @@
-import { mustMatch, M } from '@agoric/store';
-import { assertRightsConserved } from '../contractFacet/rightsConservation.js';
+import { M } from '@agoric/store';
 import { AmountKeywordRecordShape, SeatShape } from '../typeGuards.js';
 
-const { Fail, quote: q } = assert;
-
 export const TransferPartShape = M.splitArray(
   harden([M.opt(SeatShape), M.opt(SeatShape), M.opt(AmountKeywordRecordShape)]),
   harden([M.opt(AmountKeywordRecordShape)]),
 );
 
-/**
- * @typedef {[
- *   fromSeat?: ZCFSeat,
- *   toSeat?: ZCFSeat,
- *   fromAmounts?: AmountKeywordRecord,
- *   toAmounts?: AmountKeywordRecord
- * ]} TransferPart
- */
-
 /**
  * Asks Zoe (via zcf) to rearrange the allocations among the seats
  * mentioned. This is a set of changes to allocations that must satisfy
@@ -52,86 +40,13 @@ export const TransferPartShape = M.splitArray(
  * which will remain helpers. These helper are for convenience
  * in expressing atomic rearrangements clearly.
  *
+ * @deprecated use the zcf builtin instead
+ *
  * @param {ZCF} zcf
  * @param {TransferPart[]} transfers
  */
 export const atomicRearrange = (zcf, transfers) => {
-  mustMatch(transfers, M.arrayOf(M.array()), 'transfers');
-  const uniqueSeatSet = new Set();
-  for (const [
-    fromSeat = undefined,
-    toSeat = undefined,
-    fromAmounts = undefined,
-    toAmounts = undefined,
-  ] of transfers) {
-    if (fromSeat) {
-      if (!fromAmounts) {
-        throw Fail`Transfer from ${fromSeat} must say how much`;
-      }
-      uniqueSeatSet.add(fromSeat);
-      if (toSeat) {
-        // Conserved transfer between seats
-        if (toAmounts) {
-          // distinct amounts, so we check conservation.
-          assertRightsConserved(
-            Object.values(fromAmounts),
-            Object.values(toAmounts),
-          );
-        } // else fromAmounts will be used as toAmounts
-        uniqueSeatSet.add(toSeat);
-      } else {
-        // Transfer only from fromSeat
-        !toAmounts ||
-          Fail`Transfer without toSeat cannot have toAmounts ${toAmounts}`;
-      }
-    } else {
-      toSeat || Fail`Transfer must have at least one of fromSeat or toSeat`;
-      // Transfer only to toSeat
-      !fromAmounts ||
-        Fail`Transfer without fromSeat cannot have fromAmounts ${fromAmounts}`;
-      toAmounts || Fail`Transfer to ${toSeat} must say how much`;
-      uniqueSeatSet.add(toSeat);
-    }
-  }
-
-  const uniqueSeats = harden([...uniqueSeatSet.keys()]);
-  for (const seat of uniqueSeats) {
-    !seat.hasStagedAllocation() ||
-      Fail`Cannot mix atomicRearrange with seat stagings: ${seat}`;
-  }
-
-  // At this point the basic shape has been validated
-
-  try {
-    for (const [
-      fromSeat = undefined,
-      toSeat = undefined,
-      fromAmounts = undefined,
-      toAmounts = toSeat && fromAmounts,
-    ] of transfers) {
-      if (fromSeat && fromAmounts) {
-        // testing both just to satisfy the type checker
-        fromSeat.decrementBy(fromAmounts);
-      }
-      if (toSeat && toAmounts) {
-        // testing both just to satisfy the type checker
-        toSeat.incrementBy(toAmounts);
-      }
-    }
-
-    // Perhaps deprecate this >= 2 restriction?
-    uniqueSeats.length >= 2 ||
-      Fail`Can only commit a reallocation among at least 2 seats: ${q(
-        uniqueSeats.length,
-      )}`;
-    // Take it apart and put it back together to satisfy the type checker
-    const [seat0, seat1, ...restSeats] = uniqueSeats;
-    zcf.reallocate(seat0, seat1, ...restSeats);
-  } finally {
-    for (const seat of uniqueSeats) {
-      seat.clear();
-    }
-  }
+  zcf.atomicRearrange(transfers);
 };
 
 /**
@@ -179,4 +94,4 @@ export const atomicTransfer = (
   toSeat = undefined,
   fromAmounts = undefined,
   toAmounts = undefined,
-) => atomicRearrange(zcf, harden([[fromSeat, toSeat, fromAmounts, toAmounts]]));
+) => zcf.atomicRearrange(harden([[fromSeat, toSeat, fromAmounts, toAmounts]]));

package/src/contractSupport/bondingCurves.js

@@ -27,7 +27,7 @@ const BASIS_POINTS = 10000n; // TODO change to 10_000n once tooling copes.
  * pool of the kind of asset sent in
  * @param {any} outputReserve - the value in the liquidity
  * pool of the kind of asset to be sent out
- * @param {bigint} [feeBasisPoints=30n] - the fee taken in
+ * @param {bigint} [feeBasisPoints] - the fee taken in
  * basis points. The default is 0.3% or 30 basis points. The fee
  * is taken from inputValue
  * @returns {NatValue} outputValue - the current price, in value form
@@ -66,7 +66,7 @@ export const getInputPrice = (
  * pool of the asset being spent
  * @param {any} outputReserve - the value in the liquidity
  * pool of the kind of asset to be sent out
- * @param {bigint} [feeBasisPoints=30n] - the fee taken in
+ * @param {bigint} [feeBasisPoints] - the fee taken in
  * basis points. The default is 0.3% or 30 basis points. The fee is taken from
  * outputValue
  * @returns {NatValue} inputValue - the value of input required to purchase output

package/src/contractSupport/durability.d.ts

@@ -1,5 +1,5 @@
-export function makeEphemeraProvider<E extends {}, K extends {} = any>(init: (key: K) => E): (key: K) => E;
-export function provideEmptySeat(zcf: ZCF, baggage: MapStore<string, unknown>, name: string): ZCFSeat;
+export function makeEphemeraProvider<E extends {}, K extends WeakKey>(init: (key: K) => E): (key: K) => E;
+export function provideEmptySeat(zcf: ZCF, baggage: import("@agoric/swingset-liveslots").Baggage, name: string): ZCFSeat;
 export function provideAll<T extends Record<string, () => ERef<any>>>(baggage: MapStore<string, any>, thunks: T): Promise<{ [K in keyof T]: Awaited<ReturnType<T[K]>>; }>;
-export function provideSingleton<T extends () => ERef<any>>(mapStore: MapStore<string, unknown>, key: string, makeValue: T, withValue?: ((value: Awaited<ReturnType<T>>) => void) | undefined): Promise<Awaited<ReturnType<T>>>;
+export function provideSingleton<T extends () => ERef<any>>(mapStore: import("@agoric/vat-data").Baggage, key: string, makeValue: T, withValue?: ((value: Awaited<ReturnType<T>>) => void) | undefined): Promise<Awaited<ReturnType<T>>>;
 //# sourceMappingURL=durability.d.ts.map

package/src/contractSupport/durability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"durability.d.ts","sourceRoot":"","sources":["durability.js"],"names":[],"mappings":"AAaO,2GAkBN;AAWM,sCALI,GAAG,4CAEH,MAAM,GACJ,OAAO,CAInB;AAiCM,0DAL4B,KAAK,GAAG,CAAC,YACjC,SAAS,MAAM,EAAE,GAAG,CAAC,sEAyB/B;AAgBM,iDAPa,KAAK,GAAG,CAAC,4CAElB,MAAM,gEAE6B,IAAI,gDAejD"}
+{"version":3,"file":"durability.d.ts","sourceRoot":"","sources":["durability.js"],"names":[],"mappings":"AAaO,qCAJW,CAAC,SAAN,EAAI,EACM,CAAC,SAAV,OAAQ,QACX,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,eASA,CAAC,CAWxB;AAWM,sCALI,GAAG,WACH,OAAO,4BAA4B,EAAE,OAAO,QAC5C,MAAM,GACJ,OAAO,CAInB;AAiCM,2BALwC,CAAC,SAAlC,MAAM,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,GAAG,CAAC,CAAE,WACnC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,UACrB,CAAC,GACC,OAAO,CAAC,GAAG,CAAY,IAAP,MAAM,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAE,CAAC,CAuBlE;AAgBM,iCAPwB,CAAC,SAAnB,MAAO,IAAI,CAAC,GAAG,CAAE,YACnB,OAAO,kBAAkB,EAAE,OAAO,OAClC,MAAM,aACN,CAAC,uBACO,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,gBACrC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAc3C"}

package/src/contractSupport/durability.js

@@ -8,7 +8,7 @@ import { E } from '@endo/eventual-send';
  * representative also remains.
  *
  * @template {{}} E Ephemeral state
- * @template {{}} [K=any] key on which to provision
+ * @template {WeakKey} K key on which to provision
  * @param {(key: K) => E} init
  */
 export const makeEphemeraProvider = init => {
@@ -36,7 +36,7 @@ harden(makeEphemeraProvider);
  * Provide an empty ZCF seat.
  *
  * @param {ZCF} zcf
- * @param {import('@agoric/ertp').Baggage} baggage
+ * @param {import('@agoric/swingset-liveslots').Baggage} baggage
  * @param {string} name
  * @returns {ZCFSeat}
  */
@@ -113,9 +113,9 @@ harden(provideAll);
  * @returns {Promise<Awaited<ReturnType<T>>>}
  */
 export const provideSingleton = (mapStore, key, makeValue, withValue) => {
-  const stored =
-    mapStore.has(key) ||
-    E.when(makeValue(), v => mapStore.init(key, harden(v)));
+  const stored = mapStore.has(key)
+    ? undefined
+    : E.when(makeValue(), v => mapStore.init(key, harden(v)));
 
   return E.when(stored, () => {
     const value = mapStore.get(key);

package/src/contractSupport/index.d.ts

@@ -1,6 +1,7 @@
 export { natSafeMath } from "./safeMath.js";
 export { makeStateMachine } from "./stateMachine.js";
 export * from "./durability.js";
+export * from "./prepare-ownable.js";
 export * from "./priceAuthority.js";
 export * from "./priceQuote.js";
 export * from "./statistics.js";

package/src/contractSupport/index.js

@@ -54,6 +54,7 @@ export {
 } from './ratio.js';
 
 export * from './durability.js';
+export * from './prepare-ownable.js';
 export * from './priceAuthority.js';
 export * from './priceQuote.js';
 export * from './statistics.js';

package/src/contractSupport/prepare-ownable.d.ts

@@ -0,0 +1,11 @@
+export function prepareOwnable<MN extends (string | symbol)[]>(zone: import("@agoric/base-zone").Zone, makeInvitation: ZCF["makeInvitation"], uKindName: string, uMethodNames: MN, options?: OwnableOptions | undefined): <U>(underlying: U) => Pick<U, MN[number]> & {
+    makeTransferInvitation: () => Invitation<U>;
+};
+export type OwnableOptions = {
+    /**
+     * The `interfaceName` of the underlying interface guard.
+     * Defaults to the `uKindName`.
+     */
+    uInterfaceName?: string | undefined;
+};
+//# sourceMappingURL=prepare-ownable.d.ts.map

package/src/contractSupport/prepare-ownable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-ownable.d.ts","sourceRoot":"","sources":["prepare-ownable.js"],"names":[],"mappings":"AA0CO,+BAlB4B,EAAE,SAAvB,CAAC,MAAM,GAAG,MAAM,CAAC,EAAG,QACvB,OAAO,mBAAmB,EAAE,IAAI,kBAChC,GAAG,CAAC,gBAAgB,CAAC,aAQrB,MAAM,gBAEN,EAAE,yCAIA,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG;IAAC,sBAAsB,EAAE,MAAM,UAAU,CAAC,CAAC,CAAC,CAAA;CAAC,CA0DrG"}

package/src/contractSupport/prepare-ownable.js

@@ -0,0 +1,100 @@
+import { M } from '@endo/patterns';
+import { prepareRevocableMakerKit } from '@agoric/base-zone/zone-helpers.js';
+import { OfferHandlerI } from '../typeGuards.js';
+
+const TransferProposalShape = M.splitRecord({
+  give: {},
+  want: {},
+  exit: {
+    onDemand: null,
+  },
+});
+
+/**
+ * @typedef {object} OwnableOptions
+ * @property {string} [uInterfaceName]
+ *   The `interfaceName` of the underlying interface guard.
+ *   Defaults to the `uKindName`.
+ */
+
+/**
+ * Prepare a kind that wraps an 'ownable' object with a `makeTransferInvitation`
+ * ability and delegates to the underlying object methods specified in an
+ * allowlist of method names.
+ *
+ * @template {(string | symbol)[]} MN Method names
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {ZCF['makeInvitation']} makeInvitation
+ *   A function with the same behavior as `zcf.makeInvitation`.
+ *   A contract will normally just extract it from its own zcf using the
+ *   argument expression
+ *   ```js
+ *   (...args) => zcf.makeInvitation(...args)
+ *   ```
+ *   See ownable-counter.js for the canonical example.
+ * @param {string} uKindName
+ *   The `kindName` of the underlying exo class
+ * @param {MN} uMethodNames
+ *   The method names of the underlying exo class that should be represented
+ *   by transparently-forwarding methods of the wrapping ownable object.
+ * @param {OwnableOptions} [options]
+ * @returns {<U>(underlying: U) => Pick<U, MN[number]> & {makeTransferInvitation: () => Invitation<U>}}
+ */
+export const prepareOwnable = (
+  zone,
+  makeInvitation,
+  uKindName,
+  uMethodNames,
+  options = {},
+) => {
+  const { uInterfaceName = uKindName } = options;
+  const { revoke, makeRevocable } = prepareRevocableMakerKit(
+    zone,
+    uKindName,
+    uMethodNames,
+    {
+      uInterfaceName,
+      extraMethodGuards: {
+        makeTransferInvitation: M.call().returns(M.promise()),
+      },
+      extraMethods: {
+        makeTransferInvitation() {
+          const { underlying } = this.state;
+          const { revocable } = this.facets;
+          const customDetails = underlying.getInvitationCustomDetails();
+          // eslint-disable-next-line no-use-before-define
+          const transferHandler = makeTransferHandler(underlying);
+
+          const invitation = makeInvitation(
+            transferHandler,
+            'transfer',
+            customDetails,
+            TransferProposalShape,
+          );
+          revoke(revocable);
+          return invitation;
+        },
+      },
+    },
+  );
+
+  const makeTransferHandler = zone.exoClass(
+    'TransferHandler',
+    OfferHandlerI,
+    underlying => ({
+      underlying,
+    }),
+    {
+      handle(seat) {
+        const { underlying } = this.state;
+        const revocable = makeRevocable(underlying);
+        seat.exit();
+        return revocable;
+      },
+    },
+  );
+
+  const makeOwnable = underlying => makeRevocable(underlying);
+  return harden(makeOwnable);
+};
+harden(prepareOwnable);

package/src/contractSupport/priceAuthority.d.ts

@@ -1,22 +1,30 @@
-/**
- * @param {object} opts
- * @param {Issuer<'set'>} opts.quoteIssuer
- * @param {ERef<Notifier<unknown>>} opts.notifier
- * @param {ERef<import('@agoric/time/src/types').TimerService>} opts.timer
- * @param {PriceQuoteCreate} opts.createQuote
- * @param {Brand<'nat'>} opts.actualBrandIn
- * @param {Brand<'nat'>} opts.actualBrandOut
- * @returns {PriceAuthorityKit}
- */
+export const PriceAuthorityI: import("@endo/patterns").InterfaceGuard<{
+    getQuoteIssuer: import("@endo/patterns").MethodGuard;
+    getTimerService: import("@endo/patterns").MethodGuard;
+    quoteGiven: import("@endo/patterns").MethodGuard;
+    quoteWanted: import("@endo/patterns").MethodGuard;
+    makeQuoteNotifier: import("@endo/patterns").MethodGuard;
+    quoteAtTime: import("@endo/patterns").MethodGuard;
+    quoteWhenLT: import("@endo/patterns").MethodGuard;
+    quoteWhenLTE: import("@endo/patterns").MethodGuard;
+    quoteWhenGTE: import("@endo/patterns").MethodGuard;
+    quoteWhenGT: import("@endo/patterns").MethodGuard;
+    mutableQuoteWhenLT: import("@endo/patterns").MethodGuard;
+    mutableQuoteWhenLTE: import("@endo/patterns").MethodGuard;
+    mutableQuoteWhenGTE: import("@endo/patterns").MethodGuard;
+    mutableQuoteWhenGT: import("@endo/patterns").MethodGuard;
+}>;
 export function makeOnewayPriceAuthorityKit(opts: {
-    quoteIssuer: Issuer<'set'>;
+    quoteIssuer: Issuer<"set", PriceDescription>;
     notifier: ERef<Notifier<unknown>>;
-    timer: ERef<import('@agoric/time/src/types').TimerService>;
+    timer: ERef<import("@agoric/time").TimerService>;
     createQuote: PriceQuoteCreate;
-    actualBrandIn: Brand<'nat'>;
-    actualBrandOut: Brand<'nat'>;
+    actualBrandIn: Brand<"nat">;
+    actualBrandOut: Brand<"nat">;
 }): PriceAuthorityKit;
-export const PriceAuthorityI: import("@endo/patterns").InterfaceGuard;
 export type CompareAmount = (amount: Amount, amountLimit: Amount) => boolean;
 export type Trigger = (createInstantQuote: PriceQuoteCreate) => Promise<void>;
+import type { PriceDescription } from '@agoric/zoe/tools/types.js';
+import type { PriceQuoteCreate } from '@agoric/zoe/tools/types.js';
+import type { PriceAuthorityKit } from '@agoric/zoe/tools/types.js';
 //# sourceMappingURL=priceAuthority.d.ts.map

package/src/contractSupport/priceAuthority.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"priceAuthority.d.ts","sourceRoot":"","sources":["priceAuthority.js"],"names":[],"mappings":"AA6DA;;;;;;;;;GASG;AACH;IAR+B,WAAW,EAA/B,OAAO,KAAK,CAAC;IACiB,QAAQ,EAAtC,KAAK,SAAS,OAAO,CAAC,CAAC;IACmC,KAAK,EAA/D,KAAK,OAAO,wBAAwB,EAAE,YAAY,CAAC;IAC5B,WAAW,EAAlC,gBAAgB;IACG,aAAa,EAAhC,MAAM,KAAK,CAAC;IACO,cAAc,EAAjC,MAAM,KAAK,CAAC;IACV,iBAAiB,CA6S7B;AAxUD,sEAiBG;qCA3CQ,MAAM,eACN,MAAM,KACJ,OAAO;2CAiBT,gBAAgB,KACd,QAAQ,IAAI,CAAC"}
+{"version":3,"file":"priceAuthority.d.ts","sourceRoot":"","sources":["priceAuthority.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;;GAiBG;AAYI,kDARJ;IAA8C,WAAW,EAAjD,MAAM,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACD,QAAQ,EAAtC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACyB,KAAK,EAArD,IAAI,CAAC,OAAO,cAAc,EAAE,YAAY,CAAC;IAClB,WAAW,EAAlC,gBAAgB;IACG,aAAa,EAAhC,KAAK,CAAC,KAAK,CAAC;IACO,cAAc,EAAjC,KAAK,CAAC,KAAK,CAAC;CACpB,GAAU,iBAAiB,CAwT7B;qCA7WU,MAAM,eACN,MAAM,KACJ,OAAO;2CAiBT,gBAAgB,KACd,OAAO,CAAC,IAAI,CAAC;sCA7ByI,4BAA4B;sCAA5B,4BAA4B;uCAA5B,4BAA4B"}