@agoric/zoe 0.27.0-upgrade-19-devnet-dev-5428c4d.0 → 0.27.0-upgrade-21-dev-16519b2.0

package/src/zoeService/types.ts

@@ -0,0 +1,307 @@
+import type {
+  AnyAmount,
+  AssetKind,
+  DisplayInfo,
+  Issuer,
+  NatValue,
+  Payment,
+} from '@agoric/ertp';
+import type { Subscriber } from '@agoric/notifier';
+import type { ERef, EReturn } from '@endo/eventual-send';
+import type { Bundle, BundleID } from '@agoric/swingset-vat';
+import type { ContractStartFunction, StartParams } from './utils.js';
+import type {
+  Keyword,
+  InvitationHandle,
+  BrandKeywordRecord,
+  Handle,
+  IssuerKeywordRecord,
+} from '../types.js';
+import type { Allocation } from '../types-index.js';
+
+/**
+ * @see {@link https://github.com/sindresorhus/type-fest/blob/main/source/is-any.d.ts}
+ */
+type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+
+/**
+ * Zoe provides a framework for deploying and working with smart
+ * contracts. It is accessed as a long-lived and well-trusted service
+ * that enforces offer safety for the contracts that use it. Zoe has a
+ * single `invitationIssuer` for the entirety of its lifetime. By
+ * having a reference to Zoe, a user can get the `invitationIssuer`
+ * and thus validate any `invitation` they receive from someone else.
+ *
+ * Zoe has two different facets: the public Zoe service and the
+ * contract facet (ZCF). Each contract instance has a copy of ZCF
+ * within its vat. The contract and ZCF never have direct access to
+ * the users' payments or the Zoe purses.
+ */
+export type ZoeService = {
+  /**
+   * Zoe has a single `invitationIssuer` for the entirety of its
+   * lifetime. By having a reference to Zoe, a user can get the
+   * `invitationIssuer` and thus validate any `invitation` they receive
+   * from someone else. The mint associated with the invitationIssuer
+   * creates the ERTP payments that represent the right to interact with
+   * a smart contract in particular ways.
+   */
+  getInvitationIssuer: GetInvitationIssuer;
+  install: InstallBundle;
+  installBundleID: InstallBundleID;
+  startInstance: import('./utils.js').StartInstance;
+  offer: Offer;
+  getPublicFacet: <I extends Instance>(
+    instance: ERef<I>,
+  ) => Promise<
+    IsAny<I> extends true
+      ? any
+      : I extends import('./utils.js').Instance<
+            infer SF extends ContractStartFunction
+          >
+        ? IsAny<SF> extends true
+          ? unknown
+          : EReturn<SF>['publicFacet']
+        : never
+  >;
+  getIssuers: GetIssuers;
+  getBrands: GetBrands;
+  getTerms: <I extends ERef<Instance>>(
+    instance: I,
+  ) => IsAny<I> extends true
+    ? Promise<any>
+    : I extends ERef<
+          import('./utils.js').Instance<infer SF extends ContractStartFunction>
+        >
+      ? IsAny<SF> extends true
+        ? Promise<unknown>
+        : Promise<StartParams<SF>['terms']>
+      : never;
+  getOfferFilter: (instance: ERef<Instance>) => Promise<string[]>;
+  getInstallationForInstance: GetInstallationForInstance;
+  getInstance: GetInstance;
+  getInstallation: GetInstallation;
+  /**
+   *   Return an object with the instance, installation, description, invitation
+   *   handle, and any custom properties specific to the contract.
+   */
+  getInvitationDetails: GetInvitationDetails;
+  getFeeIssuer: GetFeeIssuer;
+  getConfiguration: GetConfiguration;
+  getBundleIDFromInstallation: GetBundleIDFromInstallation;
+  /**
+   *   Return the pattern (if any) associated with the invitationHandle that a
+   *   proposal is required to match to be accepted by zoe.offer().
+   */
+  getProposalShapeForInvitation: (
+    invitationHandle: InvitationHandle,
+  ) => import('@endo/patterns').Pattern | undefined;
+};
+type GetInvitationIssuer = () => Promise<Issuer<'set', InvitationDetails>>;
+type GetFeeIssuer = () => Promise<Issuer<'nat'>>;
+type GetConfiguration = () => {
+  feeIssuerConfig: FeeIssuerConfig;
+};
+export type GetIssuers = (
+  instance: import('./utils.js').Instance<any>,
+) => Promise<IssuerKeywordRecord>;
+export type GetBrands = (
+  instance: import('./utils.js').Instance<any>,
+) => Promise<BrandKeywordRecord>;
+type GetInstallationForInstance = (
+  instance: import('./utils.js').Instance<any>,
+) => Promise<Installation>;
+export type GetInstance = (
+  invitation: ERef<import('../types-index.js').Invitation>,
+) => Promise<import('./utils.js').Instance<any>>;
+export type GetInstallation = (
+  invitation: ERef<import('../types-index.js').Invitation>,
+) => Promise<Installation>;
+export type GetInvitationDetails = (
+  invitation: ERef<import('../types-index.js').Invitation<any, any>>,
+) => Promise<InvitationDetails>;
+/**
+ * Create an installation by safely evaluating the code and
+ * registering it with Zoe. Returns an installation.
+ */
+export type InstallBundle = (
+  bundle: Bundle | SourceBundle,
+  bundleLabel?: string | undefined,
+) => Promise<Installation>;
+/**
+ * Create an installation from a Bundle ID. Returns an installation.
+ */
+export type InstallBundleID = (
+  bundleID: BundleID,
+  bundleLabel?: string | undefined,
+) => Promise<Installation>;
+/**
+ * Verify that an alleged Installation is real, and return the Bundle ID it
+ * will use for contract code.
+ */
+export type GetBundleIDFromInstallation = (
+  allegedInstallation: ERef<Installation>,
+) => Promise<string>;
+/**
+ * To redeem an invitation, the user normally provides a proposal (their
+ * rules for the offer) as well as payments to be escrowed by Zoe.  If
+ * either the proposal or payments would be empty, indicate this by
+ * omitting that argument or passing undefined, rather than passing an
+ * empty record.
+ *
+ * The proposal has three parts: `want` and `give` are used by Zoe to
+ * enforce offer safety, and `exit` is used to specify the particular
+ * payout-liveness policy that Zoe can guarantee. `want` and `give`
+ * are objects with keywords as keys and amounts as values.
+ * `paymentKeywordRecord` is a record with keywords as keys, and the
+ * values are the actual payments to be escrowed. A payment is
+ * expected for every rule under `give`.
+ */
+export type Offer = <Result, Args = undefined>(
+  invitation: ERef<import('../types-index.js').Invitation<Result, Args>>,
+  proposal?: Proposal,
+  paymentKeywordRecord?: PaymentPKeywordRecord,
+  offerArgs?: Args,
+) => Promise<UserSeat<Result>>;
+/**
+ * Zoe uses seats to access or manipulate offers. They let contracts and users
+ * interact with them. Zoe has two kinds of seats. ZCFSeats are used within
+ * contracts and with zcf methods. UserSeats represent offers external to Zoe
+ * and the contract. The party who exercises an invitation and sends the offer()
+ * message to Zoe gets a UserSeat that can check payouts' status or retrieve the
+ * result of processing the offer in the contract. This varies, but examples are
+ * a string and an invitation for another seat.
+ *
+ * Also, a UserSeat can be handed to an agent outside Zoe and the contract,
+ * letting them query or monitor the current state, access the payouts and
+ * result, and, if it's allowed for this seat, call tryExit().
+ *
+ * Since anyone can attempt to exit the seat if they have a reference to it, you
+ * should only share a UserSeat with trusted parties.
+ *
+ * UserSeat includes queries for the associated offer's current state and an
+ * operation to request that the offer exit, as follows:
+ */
+export type UserSeat<OR = unknown> = {
+  getProposal: () => Promise<ProposalRecord>;
+  /**
+   * returns a promise for a KeywordPaymentRecord containing all the payouts from
+   * this seat. The promise will resolve after the seat has exited.
+   */
+  getPayouts: () => Promise<PaymentPKeywordRecord>;
+  /**
+   * returns a promise for the Payment corresponding to the indicated keyword.
+   * The promise will resolve after the seat has exited. If there is no payment
+   * corresponding to the keyword, an error will be thrown. (It used to return
+   * undefined.)
+   */
+  getPayout: (keyword: Keyword) => Promise<Payment<any, any>>;
+  getOfferResult: () => Promise<OR>;
+  /**
+   * Note: Only works if the seat's `proposal` has an `OnDemand` `exit` clause. Zoe's
+   * offer-safety guarantee applies no matter how a seat's interaction with a
+   * contract ends. Under normal circumstances, the participant might be able to
+   * call `tryExit()`, or the contract might do something explicitly. On exiting,
+   * the seat holder gets its current `allocation` and the `seat` can no longer
+   * interact with the contract.
+   */
+  tryExit?: (() => void) | undefined;
+  /**
+   * Returns true if the seat has exited, false if it is still active.
+   */
+  hasExited: () => Promise<boolean>;
+  /**
+   * returns 1 if the proposal's
+   * want clause was satisfied by the final allocation, otherwise 0. This is
+   * numeric to support a planned enhancement called "multiples" which will allow
+   * the return value to be any non-negative number. The promise will resolve
+   * after the seat has exited.
+   */
+  numWantsSatisfied: () => Promise<0 | 1>;
+  /**
+   * return a promise for the final allocation. The promise will resolve after the
+   * seat has exited.
+   */
+  getFinalAllocation: () => Promise<Allocation>;
+  /**
+   * returns a subscriber that
+   * will be notified when the seat has exited or failed.
+   */
+  getExitSubscriber: () => Subscriber<import('../types-index.js').Completion>;
+};
+export type Proposal = Partial<ProposalRecord>;
+export type ProposalRecord = {
+  give: AmountKeywordRecord;
+  want: AmountKeywordRecord;
+  exit: ExitRule;
+};
+/**
+ * The keys are keywords, and the values are amounts. For example:
+ * { Asset: AmountMath.make(assetBrand, 5n), Price:
+ * AmountMath.make(priceBrand, 9n) }
+ */
+export type AmountKeywordRecord = Record<Keyword, AnyAmount>;
+export type Waker = {
+  wake: () => void;
+};
+export type OnDemandExitRule = {
+  onDemand: null;
+};
+export type WaivedExitRule = {
+  waived: null;
+};
+export type AfterDeadlineExitRule = {
+  afterDeadline: {
+    timer: import('@agoric/time').TimerService;
+    deadline: import('@agoric/time').Timestamp;
+  };
+};
+/**
+ * The possible keys are 'waived', 'onDemand', and 'afterDeadline'.
+ * `timer` and `deadline` only are used for the `afterDeadline` key.
+ * The possible records are:
+ * `{ waived: null }`
+ * `{ onDemand: null }`
+ * `{ afterDeadline: { timer :Timer<Deadline>, deadline :Deadline } }`
+ */
+export type ExitRule =
+  | OnDemandExitRule
+  | WaivedExitRule
+  | AfterDeadlineExitRule;
+export type Instance<SF = any> = import('./utils.js').Instance<SF>;
+export type ZCFSpec =
+  | {
+      bundleCap: import('@agoric/swingset-vat').BundleCap;
+    }
+  | {
+      name: string;
+    }
+  | {
+      /** Bundle ID */
+      id: string;
+    };
+/**
+ * Opaque type for a JSONable source bundle
+ */
+export type SourceBundle = Record<string, any>;
+export type PaymentPKeywordRecord = Record<Keyword, ERef<Payment<any>>>;
+export type PaymentKeywordRecord = Record<Keyword, Payment<any>>;
+export type InvitationDetails = {
+  installation: Installation;
+  instance: import('./utils.js').Instance<any>;
+  handle: InvitationHandle;
+  description: string;
+  customDetails?: Record<string, any> | undefined;
+};
+export type Installation<SF = any> = import('./utils.js').Installation<SF>;
+export type InstallationStart<I extends Installation> =
+  import('./utils.js').InstallationStart<I>;
+export type FeeIssuerConfig = {
+  name: string;
+  assetKind: AssetKind;
+  displayInfo: DisplayInfo;
+};
+export type ZoeFeesConfig = {
+  getPublicFacetFee: NatValue;
+};
+export type FeeMintAccess = Handle<'feeMintAccess'>;

package/src/zoeService/utils.d.ts

@@ -1,13 +1,10 @@
-// Ambient types
-import '../types-ambient.js';
-import '../contractFacet/types-ambient.js';
-
 import type { Issuer } from '@agoric/ertp/src/types.js';
 import type { TagContainer } from '@agoric/internal/src/tagged.js';
 import type { Baggage } from '@agoric/swingset-liveslots';
 import type { VatUpgradeResults } from '@agoric/swingset-vat';
 import type { RemotableObject } from '@endo/marshal';
 import type { FarRef } from '@endo/far';
+import type { AnyTerms, Handle, Keyword, ZCF } from '../types-index.js';
 
 // XXX https://github.com/Agoric/agoric-sdk/issues/4565
 type SourceBundle = Record<string, any>;
@@ -29,7 +26,7 @@ export type InstallationStart<I> =
   I extends Installation<infer SF> ? SF : never;
 
 export type ContractStartFunction = (
-  zcf?: ZCF,
+  zcf?: ZCF<any>,
   privateArgs?: object,
   baggage?: Baggage,
 ) => ERef<{ creatorFacet?: object; publicFacet?: object }>;
@@ -66,6 +63,8 @@ type ZcfOf<SF extends ContractStartFunction> = Parameters<SF>[0] extends ZCF
   : ZCF<any>;
 
 /**
+ * @deprecated use the SF to pass the type
+ *
  * Convenience record for contract start function, merging its result with params.
  */
 export type ContractOf<S extends (...args: any) => any> = StartParams<S> &
@@ -125,3 +124,12 @@ export type GetTerms = <SF>(instance: Instance<SF>) => Promise<
     : // XXX returning `any` in this case
       any
 >;
+
+export type InstanceRecord = {
+  installation: Installation<any>;
+  instance: Instance<any>;
+  /**
+   * - contract parameters
+   */
+  terms: AnyTerms;
+};

package/src/zoeService/utils.test-d.ts

@@ -1,5 +1,6 @@
 import { E } from '@endo/far';
 import type { StartedInstanceKit } from './utils.js';
+import type { ZCF } from '../types-index.js';
 
 const someContractStartFn = (
   zcf: ZCF,

package/src/zoeService/zoe.d.ts

@@ -1,5 +1,10 @@
+export * from "../types-index.js";
 export type ZoeKit = ReturnType<typeof makeDurableZoeKit>;
-/** @import {Baggage} from '@agoric/vat-data' */
+/**
+ * @import {VatAdminSvc, ShutdownWithFailure} from '@agoric/swingset-vat';
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {FeeIssuerConfig, FeeMintAccess, ZCFSpec, ZoeService} from './types.js';
+ */
 /**
  * Create a durable instance of Zoe.
  *
@@ -8,7 +13,7 @@ export type ZoeKit = ReturnType<typeof makeDurableZoeKit>;
  * @param {Promise<VatAdminSvc> | VatAdminSvc} [options.vatAdminSvc] - The vatAdmin Service, which carries the
  * power to create a new vat. If it's not available when makeZoe() is called, it
  * must be provided later using setVatAdminService().
- * @param {import('@agoric/swingset-vat').ShutdownWithFailure} [options.shutdownZoeVat] - a function to
+ * @param {ShutdownWithFailure} [options.shutdownZoeVat] - a function to
  * shutdown the Zoe Vat. This function needs to use the vatPowers
  * available to a vat.
  * @param {FeeIssuerConfig} [options.feeIssuerConfig]
@@ -17,7 +22,7 @@ export type ZoeKit = ReturnType<typeof makeDurableZoeKit>;
 export function makeDurableZoeKit({ zoeBaggage, vatAdminSvc, shutdownZoeVat, feeIssuerConfig, zcfSpec, }: {
     zoeBaggage: Baggage;
     vatAdminSvc?: VatAdminSvc | Promise<VatAdminSvc> | undefined;
-    shutdownZoeVat?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined;
+    shutdownZoeVat?: ShutdownWithFailure | undefined;
     feeIssuerConfig?: FeeIssuerConfig | undefined;
     zcfSpec?: ZCFSpec | undefined;
 }): {
@@ -27,7 +32,7 @@ export function makeDurableZoeKit({ zoeBaggage, vatAdminSvc, shutdownZoeVat, fee
     }>;
     /** @type {FeeMintAccess} */
     feeMintAccess: FeeMintAccess;
-    setVatAdminService: ((lateVatAdminSvc: any) => void) & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
+    setVatAdminService: ((lateVatAdminSvc: any) => void) & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
 };
 /**
  * @deprecated
@@ -39,20 +44,26 @@ export function makeDurableZoeKit({ zoeBaggage, vatAdminSvc, shutdownZoeVat, fee
  * @param {Promise<VatAdminSvc> | VatAdminSvc} [vatAdminSvc] - The vatAdmin Service, which carries the
  * power to create a new vat. If it's not available when makeZoe() is called, it
  * must be provided later using setVatAdminService().
- * @param {import('@agoric/swingset-vat').ShutdownWithFailure} [shutdownZoeVat] - a function to
+ * @param {ShutdownWithFailure} [shutdownZoeVat] - a function to
  * shutdown the Zoe Vat. This function needs to use the vatPowers
  * available to a vat.
  * @param {FeeIssuerConfig} [feeIssuerConfig]
  * @param {ZCFSpec} [zcfSpec] - Pointer to the contract facet bundle.
  */
-export function makeZoeKit(vatAdminSvc?: Promise<VatAdminSvc> | VatAdminSvc, shutdownZoeVat?: import("@agoric/swingset-vat").ShutdownWithFailure, feeIssuerConfig?: FeeIssuerConfig, zcfSpec?: ZCFSpec): {
+export function makeZoeKit(vatAdminSvc?: Promise<VatAdminSvc> | VatAdminSvc, shutdownZoeVat?: ShutdownWithFailure, feeIssuerConfig?: FeeIssuerConfig, zcfSpec?: ZCFSpec): {
     zoeService: import("@endo/exo").Guarded<ZoeService>;
     zoeConfigFacet: import("@endo/exo").Guarded<{
         updateZcfBundleId(bundleId: any): void;
     }>;
     /** @type {FeeMintAccess} */
     feeMintAccess: FeeMintAccess;
-    setVatAdminService: ((lateVatAdminSvc: any) => void) & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
+    setVatAdminService: ((lateVatAdminSvc: any) => void) & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
 };
 import type { Baggage } from '@agoric/vat-data';
+import type { VatAdminSvc } from '@agoric/swingset-vat';
+import type { ShutdownWithFailure } from '@agoric/swingset-vat';
+import type { FeeIssuerConfig } from './types.js';
+import type { ZCFSpec } from './types.js';
+import type { ZoeService } from './types.js';
+import type { FeeMintAccess } from './types.js';
 //# sourceMappingURL=zoe.d.ts.map

package/src/zoeService/zoe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zoe.d.ts","sourceRoot":"","sources":["zoe.js"],"names":[],"mappings":"qBAiSa,UAAU,CAAC,OAAO,iBAAiB,CAAC;AAnQjD,gDAAgD;AAEhD;;;;;;;;;;;;;GAaG;AACH,0GAVG;IAAyB,UAAU,EAA3B,OAAO;IACsC,WAAW;IAGK,cAAc;IAGjD,eAAe;IACvB,OAAO;CACnC;;;;;IAgNG,4BAA4B;mBAAjB,aAAa;;EAK3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,yCATW,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,mBAGlC,OAAO,sBAAsB,EAAE,mBAAmB,oBAGlD,eAAe,YACf,OAAO;;;;;IArBd,4BAA4B;mBAAjB,aAAa;;EA8BxB;6BA7PuB,kBAAkB"}
+{"version":3,"file":"zoe.d.ts","sourceRoot":"","sources":["zoe.js"],"names":[],"mappings":";qBAqSa,UAAU,CAAC,OAAO,iBAAiB,CAAC;AAvQjD;;;;GAIG;AAEH;;;;;;;;;;;;;GAaG;AACH,0GAVG;IAAyB,UAAU,EAA3B,OAAO;IACsC,WAAW;IAG1B,cAAc;IAGlB,eAAe;IACvB,OAAO;CACnC;;;;;IAgNG,4BAA4B;mBAAjB,aAAa;;EAK3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,yCATW,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,mBAGlC,mBAAmB,oBAGnB,eAAe,YACf,OAAO;;;;;IArBd,4BAA4B;mBAAjB,aAAa;;EA8BxB;6BA/PsB,kBAAkB;iCADO,sBAAsB;yCAAtB,sBAAsB;qCAEH,YAAY;6BAAZ,YAAY;gCAAZ,YAAY;mCAAZ,YAAY"}

package/src/zoeService/zoe.js

@@ -14,12 +14,12 @@
 /// <reference types="@agoric/notifier/exported.js" />
 /// <reference path="../internal-types.js" />
 
+import { Fail } from '@endo/errors';
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
+import { M } from '@endo/patterns';
 import { makeScalarBigMapStore, prepareExo } from '@agoric/vat-data';
-import { M } from '@agoric/store';
 
-import { Fail } from '@endo/errors';
 import { makeZoeStorageManager } from './zoeStorageManager.js';
 import { makeStartInstance } from './startInstance.js';
 import { makeOfferMethod } from './offer/offer.js';
@@ -28,7 +28,11 @@ import { getZcfBundleCap } from './createZCFVat.js';
 import { defaultFeeIssuerConfig, prepareFeeMint } from './feeMint.js';
 import { ZoeServiceI } from '../typeGuards.js';
 
-/** @import {Baggage} from '@agoric/vat-data' */
+/**
+ * @import {VatAdminSvc, ShutdownWithFailure} from '@agoric/swingset-vat';
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {FeeIssuerConfig, FeeMintAccess, ZCFSpec, ZoeService} from './types.js';
+ */
 
 /**
  * Create a durable instance of Zoe.
@@ -38,7 +42,7 @@ import { ZoeServiceI } from '../typeGuards.js';
  * @param {Promise<VatAdminSvc> | VatAdminSvc} [options.vatAdminSvc] - The vatAdmin Service, which carries the
  * power to create a new vat. If it's not available when makeZoe() is called, it
  * must be provided later using setVatAdminService().
- * @param {import('@agoric/swingset-vat').ShutdownWithFailure} [options.shutdownZoeVat] - a function to
+ * @param {ShutdownWithFailure} [options.shutdownZoeVat] - a function to
  * shutdown the Zoe Vat. This function needs to use the vatPowers
  * available to a vat.
  * @param {FeeIssuerConfig} [options.feeIssuerConfig]
@@ -268,7 +272,7 @@ const makeDurableZoeKit = ({
  * @param {Promise<VatAdminSvc> | VatAdminSvc} [vatAdminSvc] - The vatAdmin Service, which carries the
  * power to create a new vat. If it's not available when makeZoe() is called, it
  * must be provided later using setVatAdminService().
- * @param {import('@agoric/swingset-vat').ShutdownWithFailure} [shutdownZoeVat] - a function to
+ * @param {ShutdownWithFailure} [shutdownZoeVat] - a function to
  * shutdown the Zoe Vat. This function needs to use the vatPowers
  * available to a vat.
  * @param {FeeIssuerConfig} [feeIssuerConfig]
@@ -289,3 +293,6 @@ export { makeDurableZoeKit, makeZoeKit };
 /**
  * @typedef {ReturnType<typeof makeDurableZoeKit>} ZoeKit
  */
+
+// eslint-disable-next-line import/export -- no named value exports; only types
+export * from '../types-index.js';

package/src/zoeService/zoeSeat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zoeSeat.d.ts","sourceRoot":"","sources":["zoeSeat.js"],"names":[],"mappings":"AAmDO,iDAFI,OAAO,kBAAkB,EAAE,OAAO,uBA0WhC,UAAU,YACV,cAAc,uBACd,mBAAmB,iBACnB,aAAa,YACb,IAAI,CAAC,OAAO,CAAC,2BACb,OAAO;;;;;;;;;;;;;;;;QA3IZ,wCAAwC;8DAA5B,iBAAiB;;;;EAoKpC"}
+{"version":3,"file":"zoeSeat.d.ts","sourceRoot":"","sources":["zoeSeat.js"],"names":[],"mappings":"AAkDO,iDAFI,OAAO,kBAAkB,EAAE,OAAO,uBA0WhC,UAAU,YACV,cAAc,uBACd,mBAAmB,iBACnB,aAAa,YACb,IAAI,CAAC,OAAO,CAAC,2BACb,OAAO;;;;;;;;;;;;;;;;QA3IZ,wCAAwC;8DAA5B,iBAAiB;;;;EAoKpC"}

package/src/zoeService/zoeSeat.js

@@ -7,8 +7,7 @@ import { makePromiseKit } from '@endo/promise-kit';
 import { NonNullish } from '@agoric/internal';
 
 import { satisfiesWant } from '../contractFacet/offerSafety.js';
-import '../types-ambient.js';
-import '../internal-types.js';
+
 import {
   declareOldZoeSeatAdminKind,
   OriginalZoeSeatIKit,

package/src/zoeService/zoeStorageManager.d.ts

@@ -1,10 +1,10 @@
-export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapForID: GetBundleCapForID, shutdownZoeVat: import("@agoric/swingset-vat").ShutdownWithFailure, feeMint: {
+export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapForID: GetBundleCapForID, shutdownZoeVat: ShutdownWithFailure, feeMint: {
     getFeeIssuerKit: GetFeeIssuerKit;
     getFeeIssuer: () => Issuer;
     getFeeBrand: () => Brand;
 }, zoeBaggage: Baggage): import("@endo/exo").GuardedKit<{
     zoeServiceDataAccess: {
-        getInvitationIssuer: () => globalThis.Issuer<"set", InvitationDetails>;
+        getInvitationIssuer: () => globalThis.Issuer<"set", import("@agoric/zoe").InvitationDetails>;
         getBundleIDFromInstallation(allegedInstallation: any): Promise<string | undefined>;
         getPublicFacet(instance: any): any;
         getBrands(instance: any): any;
@@ -13,14 +13,14 @@ export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapFo
         getTerms(instance: any): any;
         getInstallation(instance: any): any;
         getProposalShapeForInvitation: (invitationHandle: any) => any;
-        installBundle: (allegedBundle: any, bundleLabel: any) => Promise<Installation<any>>;
-        installBundleID(bundleID: any, bundleLabel: any): Promise<Installation<unknown>>;
+        installBundle: (allegedBundle: any, bundleLabel: any) => Promise<globalThis.Installation>;
+        installBundleID(bundleID: any, bundleLabel: any): Promise<globalThis.Installation<unknown>>;
     };
     makeOfferAccess: {
         getAssetKindByBrand: GetAssetKindByBrand;
         getInstanceAdmin(instance: any): any;
         getProposalShapeForInvitation: (invitationHandle: any) => any;
-        getInvitationIssuer: () => globalThis.Issuer<"set", InvitationDetails>;
+        getInvitationIssuer: () => globalThis.Issuer<"set", import("@agoric/zoe").InvitationDetails>;
         depositPayments(proposal: any, payments: any): Promise<Allocation>;
     };
     startInstanceAccess: {
@@ -33,7 +33,7 @@ export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapFo
         }>;
     };
     invitationIssuerAccess: {
-        getInvitationIssuer: () => globalThis.Issuer<"set", InvitationDetails>;
+        getInvitationIssuer: () => globalThis.Issuer<"set", import("@agoric/zoe").InvitationDetails>;
     };
 }>;
 import type { Baggage } from '@agoric/vat-data';

package/src/zoeService/zoeStorageManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"zoeStorageManager.d.ts","sourceRoot":"","sources":["zoeStorageManager.js"],"names":[],"mappings":"AAwDO,oDAXI,YAAY,qBAEZ,iBAAiB,kBACjB,OAAO,sBAAsB,EAAE,mBAAmB,WAClD;IACL,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,KAAK,CAAC;CAC3B,cACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;kBAZkC,CAAC;qBAC3B,CAAC;oBAA0B,CAAC;;;;;;;GAsbrD;6BAlc0B,kBAAkB"}
+{"version":3,"file":"zoeStorageManager.d.ts","sourceRoot":"","sources":["zoeStorageManager.js"],"names":[],"mappings":"AAiEO,oDAXI,YAAY,qBAEZ,iBAAiB,kBACjB,mBAAmB,WACnB;IACL,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,KAAK,CAAC;CAC3B,cACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;kBAdyB,CAAC;qBACtC,CAAC;oBAA0B,CAAC;;;;;;;GAwbjC;6BApcyB,kBAAkB"}

package/src/zoeService/zoeStorageManager.js

@@ -21,15 +21,24 @@ import { prepareInvitationKit } from './makeInvitation.js';
 import { makeInstanceAdminStorage } from './instanceAdminStorage.js';
 import { makeInstallationStorage } from './installationStorage.js';
 
-/// <reference path="./types.js" />
-import './internal-types.js';
 import {
   InstanceStorageManagerIKit,
   ZoeMintI,
   ZoeStorageManagerIKit,
 } from '../typeGuards.js';
 
-/** @import {Baggage} from '@agoric/vat-data' */
+// Deleting this imperative-looking import does not break `yarn lint` in the
+// zoe package. However, clients of zoe such as governance then claim that
+// the `../zoe` package has many "Cannot find name <type>" errors for other
+// types in the zoe package.
+// See https://github.com/Agoric/agoric-sdk/pull/11243#discussion_r2059200058
+// TODO investigate and hopefully fix.
+import './internal-types.js';
+
+/**
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {InvitationAmount} from '@agoric/zoe';
+ */
 
 const { ownKeys } = Reflect;
 
@@ -46,7 +55,7 @@ const { ownKeys } = Reflect;
  * @param {CreateZCFVat} createZCFVat - the ability to create a new
  * ZCF Vat
  * @param {GetBundleCapForID} getBundleCapForID
- * @param {import('@agoric/swingset-vat').ShutdownWithFailure} shutdownZoeVat
+ * @param {ShutdownWithFailure} shutdownZoeVat
  * @param {{
  *    getFeeIssuerKit: GetFeeIssuerKit,
  *    getFeeIssuer: () => Issuer,

package/tools/fakeVatAdmin.d.ts

@@ -14,13 +14,13 @@ declare const fakeVatAdmin: {
             done: () => Promise<any>;
             terminateWithFailure: () => void;
             upgrade: (_bundleCap: any, _options: any) => never;
-        } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
             done: () => Promise<any>;
             terminateWithFailure: () => void;
             upgrade: (_bundleCap: any, _options: any) => never;
         }>;
     }>;
-} & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+} & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
     getBundleCap: (bundleID: any) => Promise<any>;
     waitForBundleCap: (bundleID: any) => Promise<any>;
     getNamedBundleCap: (name: any) => Promise<any>;
@@ -33,7 +33,7 @@ declare const fakeVatAdmin: {
             done: () => Promise<any>;
             terminateWithFailure: () => void;
             upgrade: (_bundleCap: any, _options: any) => never;
-        } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
             done: () => Promise<any>;
             terminateWithFailure: () => void;
             upgrade: (_bundleCap: any, _options: any) => never;
@@ -58,13 +58,13 @@ export function makeFakeVatAdmin(testContextSetter?: (...args: any) => unknown,
                 done: () => Promise<any>;
                 terminateWithFailure: () => void;
                 upgrade: (_bundleCap: any, _options: any) => never;
-            } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
                 done: () => Promise<any>;
                 terminateWithFailure: () => void;
                 upgrade: (_bundleCap: any, _options: any) => never;
             }>;
         }>;
-    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+    } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
         getBundleCap: (bundleID: any) => Promise<any>;
         waitForBundleCap: (bundleID: any) => Promise<any>;
         getNamedBundleCap: (name: any) => Promise<any>;
@@ -77,7 +77,7 @@ export function makeFakeVatAdmin(testContextSetter?: (...args: any) => unknown,
                 done: () => Promise<any>;
                 terminateWithFailure: () => void;
                 upgrade: (_bundleCap: any, _options: any) => never;
-            } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            } & RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
                 done: () => Promise<any>;
                 terminateWithFailure: () => void;
                 upgrade: (_bundleCap: any, _options: any) => never;
@@ -88,15 +88,22 @@ export function makeFakeVatAdmin(testContextSetter?: (...args: any) => unknown,
         getExitMessage: () => any;
         getHasExited: () => boolean;
         getExitWithFailure: () => any;
-        installBundle: (id: any, bundle: any) => any;
+        /**
+         * @param {string} id
+         * @param {EndoZipBase64Bundle | TestBundle} bundle
+         */
+        installBundle: (id: string, bundle: EndoZipBase64Bundle | TestBundle) => any;
         installNamedBundle: (name: any, id: any, bundle: any) => any;
         getCriticalVatKey: () => {};
         getVatPowers: () => {
             D: (bcap: any) => {
-                getBundle: () => EndoZipBase64Bundle;
+                getBundle: () => EndoZipBase64Bundle | {
+                    moduleFormat: "test";
+                } | undefined;
             };
         };
     };
 };
 import type { EndoZipBase64Bundle } from '@agoric/swingset-vat';
+import type { TestBundle } from '@agoric/swingset-vat';
 //# sourceMappingURL=fakeVatAdmin.d.ts.map

package/tools/fakeVatAdmin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fakeVatAdmin.d.ts","sourceRoot":"","sources":["fakeVatAdmin.js"],"names":[],"mappings":"AAyBA,+BAA4C;;wBAJ7B,OAAO,sBAAsB,EAAE,SAAS;AAoJvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA8C;AA9I9C;;;GAGG;AACH,qDAHW,CAAC,GAAG,IAAI,KAAA,KAAK,OAAO,eACpB,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqIjC;yCAjJ+C,sBAAsB"}
+{"version":3,"file":"fakeVatAdmin.d.ts","sourceRoot":"","sources":["fakeVatAdmin.js"],"names":[],"mappings":"AAyBA,+BAA4C;;wBAJ7B,OAAO,sBAAsB,EAAE,SAAS;AA4JvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA8C;AAtJ9C;;;GAGG;AACH,qDAHW,CAAC,GAAG,IAAI,KAAA,KAAK,OAAO,eACpB,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAgH9B;;;WAGG;4BAFQ,MAAM,UACN,mBAAmB,GAAG,UAAU;;;;;;kCAxGkB,MAAM;;;;;EAmItE;yCAzJ2D,sBAAsB;gCAAtB,sBAAsB"}