@agoric/zoe 0.26.3-dev-fa844b5.0 → 0.26.3-dev-21fe8d9.0

package/src/zoeService/types.d.ts

@@ -0,0 +1,224 @@
+/**
+ * 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.
+ */
+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: import('./utils.js').GetPublicFacet;
+    getIssuers: GetIssuers;
+    getBrands: GetBrands;
+    getTerms: import('./utils.js').GetTerms;
+    getOfferFilter: GetOfferFilter;
+    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;
+    getProposalShapeForInvitation: (invitationHandle: InvitationHandle) => Pattern | undefined;
+};
+type GetInvitationIssuer = () => Promise<Issuer<'set'>>;
+type GetFeeIssuer = () => Promise<Issuer<'nat'>>;
+type GetConfiguration = () => {
+    feeIssuerConfig: FeeIssuerConfig;
+};
+type GetIssuers = (instance: import('./utils.js').Instance<any>) => Promise<IssuerKeywordRecord>;
+type GetBrands = (instance: import('./utils.js').Instance<any>) => Promise<BrandKeywordRecord>;
+type GetOfferFilter = (instance: import('./utils.js').Instance<any>) => string[];
+type SetOfferFilter = (instance: Instance, strings: string[]) => any;
+type GetInstallationForInstance = (instance: import('./utils.js').Instance<any>) => Promise<Installation>;
+type GetInstance = (invitation: ERef<Invitation<unknown, undefined>>) => Promise<import('./utils.js').Instance<any>>;
+type GetInstallation = (invitation: ERef<Invitation<unknown, undefined>>) => Promise<Installation>;
+type GetInvitationDetails = (invitation: ERef<Invitation<any, any>>) => Promise<InvitationDetails>;
+/**
+ * Create an installation by safely evaluating the code and
+ * registering it with Zoe. Returns an installation.
+ */
+type InstallBundle = (bundle: * Bundle | SourceBundle, bundleLabel?: string | undefined) => Promise<Installation>;
+/**
+ * Create an installation from a Bundle ID. Returns an installation.
+ */
+type InstallBundleID = (bundleID: string, bundleLabel?: string | undefined) => Promise<Installation>;
+/**
+ * Verify that an alleged Installation is real, and return the Bundle ID it
+ * will use for contract code.
+ */
+type GetBundleIDFromInstallation = (allegedInstallation: ERef<Installation<any>>) => 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`.
+ */
+type Offer = <Result, Args = undefined>(invitation: ERef<Invitation<Result, Args>>, proposal?: Proposal, paymentKeywordRecord?: PaymentPKeywordRecord, offerArgs?: Args | undefined) => 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:
+ */
+type UserSeat<OR extends unknown = 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.
+     */
+    getPayout: (keyword: Keyword) => Promise<Payment<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<Completion>;
+};
+type Proposal = Partial<ProposalRecord>;
+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) }
+ */
+type AmountKeywordRecord = Record<Keyword, Amount<any>>;
+type Waker = {
+    wake: () => void;
+};
+type OnDemandExitRule = {
+    onDemand: null;
+};
+type WaivedExitRule = {
+    waived: null;
+};
+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 } }`
+ */
+type ExitRule = OnDemandExitRule | WaivedExitRule | AfterDeadlineExitRule;
+type Instance = import('./utils.js').Instance<any>;
+type ZCFSpec = {
+    bundleCap: import('@agoric/swingset-vat').BundleCap;
+} | {
+    name: string;
+} | {
+    id: string;
+};
+/**
+ * Opaque type for a JSONable source bundle
+ */
+type SourceBundle = Record<string, any>;
+type PaymentPKeywordRecord = {
+    [x: string]: ERef<globalThis.Payment<any>>;
+};
+type PaymentKeywordRecord = Record<Keyword, Payment<any>>;
+type InvitationDetails = {
+    installation: Installation;
+    instance: import('./utils.js').Instance<any>;
+    handle: InvitationHandle;
+    description: string;
+    customDetails?: Record<string, any> | undefined;
+};
+type Installation<SF = any> = import('./utils.js').Installation<SF>;
+type InstallationStart<I extends Installation<any>> = import('./utils.js').InstallationStart<I>;
+type FeeIssuerConfig = {
+    name: string;
+    assetKind: AssetKind;
+    displayInfo: DisplayInfo;
+};
+type ZoeFeesConfig = {
+    getPublicFacetFee: NatValue;
+};
+type FeeMintAccess = Handle<'feeMintAccess'>;
+import type { VatAdminSvc } from '@agoric/swingset-vat';
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;yBAmBc,mBAAmB;aASnB,aAAa;qBACb,eAAe;mBACf,OAAO,YAAY,EAAE,aAAa;WAClC,KAAK;oBACL,OAAO,YAAY,EAAE,cAAc;gBACnC,UAAU;eACV,SAAS;cACT,OAAO,YAAY,EAAE,QAAQ;oBAC7B,cAAc;gCACd,0BAA0B;iBAC1B,WAAW;qBACX,eAAe;;;;;0BACf,oBAAoB;kBAGpB,YAAY;sBACZ,gBAAgB;iCAChB,2BAA2B;mCAC3B,CAAC,gBAAgB,EAAE,gBAAgB,KAAK,OAAO,GAAG,SAAS;;iCAK5D,QAAQ,OAAO,KAAK,CAAC,CAAC;0BAKtB,QAAQ,OAAO,KAAK,CAAC,CAAC;8BAKtB;IACZ,eAAmB,EAAE,eAAe,CAAC;CAClC;6BAKO,OAAO,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,KAChC,QAAQ,mBAAmB,CAAC;4BAK9B,OAAO,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,KAChC,QAAQ,kBAAkB,CAAC;iCAK7B,OAAO,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,KAChC,MAAM,EAAE;iCAKV,QAAQ,WACR,MAAM,EAAE;6CAKR,OAAO,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,KAChC,QAAQ,YAAY,CAAC;yEAMrB,QAAQ,OAAO,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC;6EAM3C,QAAQ,YAAY,CAAC;wEAMrB,QAAQ,iBAAiB,CAAC;;;;;4FAa1B,QAAQ,YAAY,CAAC;;;;+EAYrB,QAAQ,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;+FAgBlB,QAAQ,yBACI,qBAAqB;;;;;;;;;;;;;;;;;;;;;iBA0CnC,MAAM,QAAQ,cAAc,CAAC;;;;;gBAC7B,MAAM,QAAQ,qBAAqB,CAAC;;;;;eAGpC,CAAC,OAAO,EAAE,OAAO,KAAK,QAAQ,QAAQ,GAAG,CAAC,CAAC;oBAG3C,MAAM,QAAQ,EAAE,CAAC;;;;;;;;;qBACX,IAAI;;;;eAOV,MAAM,QAAQ,OAAO,CAAC;;;;;;;;uBAEtB,MAAM,QAAQ,CAAC,GAAC,CAAC,CAAC;;;;;wBAKlB,MAAM,QAAQ,UAAU,CAAC;;;;;uBAGzB,MAAM,WAAW,UAAU,CAAC;;gBAK7B,QAAQ,cAAc,CAAC;sBAEvB;IAAC,IAAI,EAAE,mBAAmB,CAAC;IACvC,IAAiB,EAAE,mBAAmB,CAAC;IACvC,IAAiB,EAAE,QAAQ,CAAA;CACd;;;;;;2BAID,OAAO,OAAO,EAAE,OAAO,GAAG,CAAC,CAAC;;UAS3B,MAAM,IAAI;;;cAKV,IAAI;;;YAKJ,IAAI;;;mBAKJ;QAAC,KAAK,EAAE,OAAO,cAAc,EAAE,YAAY,CAAC;QAAC,QAAQ,EAAE,OAAO,cAAc,EAAE,SAAS,CAAA;KAAC;;;;;;;;;;gBAIzF,gBAAgB,GAAG,cAAc,GAAG,qBAAqB;gBAWzD,OAAO,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC;;eAQtB,OAAO,sBAAsB,EAAE,SAAS;;UAAY,MAAM;;;;;;;oBAItE,OAAO,MAAM,EAAE,GAAG,CAAC;;;;4BAMnB,OAAO,OAAO,EAAC,QAAQ,GAAG,CAAC,CAAC;;kBAK3B,YAAY;cACZ,OAAO,YAAY,EAAE,QAAQ,CAAC,GAAG,CAAC;YAClC,gBAAgB;iBAChB,MAAM;;;8BAMP,OAAO,YAAY,EAAE,YAAY,CAAC,EAAE,CAAC;sDAKrC,OAAO,YAAY,EAAE,iBAAiB,CAAC,CAAC,CAAC;;UAKxC,MAAM;eACN,SAAS;iBACT,WAAW;;;uBAKX,QAAQ;;qBAIT,OAAO,eAAe,CAAC;iCAjDN,sBAAsB"}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test-d.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test-d.d.ts","sourceRoot":"","sources":["utils.test-d.ts"],"names":[],"mappings":""}

package/src/zoeService/zoe.d.ts

@@ -0,0 +1,57 @@
+export type ZoeKit = ReturnType<typeof makeDurableZoeKit>;
+/**
+ * Create a durable instance of Zoe.
+ *
+ * @param {object} options
+ * @param {Baggage} options.zoeBaggage - the baggage for Zoe durability. Must be provided by caller
+ * @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
+ * shutdown the Zoe Vat. This function needs to use the vatPowers
+ * available to a vat.
+ * @param {FeeIssuerConfig} [options.feeIssuerConfig]
+ * @param {ZCFSpec} [options.zcfSpec] - Pointer to the contract facet bundle.
+ */
+export function makeDurableZoeKit({ zoeBaggage, vatAdminSvc, shutdownZoeVat, feeIssuerConfig, zcfSpec, }: {
+    zoeBaggage: Baggage;
+    vatAdminSvc?: VatAdminSvc | Promise<VatAdminSvc> | undefined;
+    shutdownZoeVat?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined;
+    feeIssuerConfig?: FeeIssuerConfig | undefined;
+    zcfSpec?: ZCFSpec | undefined;
+}): {
+    zoeService: ZoeService;
+    zoeConfigFacet: import("@endo/exo").Guarded<{
+        updateZcfBundleId(bundleId: any): void;
+    }>;
+    /** @type {FeeMintAccess} */
+    feeMintAccess: FeeMintAccess;
+    setVatAdminService: ((lateVatAdminSvc: any) => void) & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
+};
+/**
+ * @deprecated
+ * Create an instance of Zoe.
+ *
+ * This will fail upgrades and should only be used in tests through the helper
+ * `makeZoeKitForTest`.
+ *
+ * @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
+ * 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?: VatAdminSvc | Promise<VatAdminSvc> | undefined, shutdownZoeVat?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined, feeIssuerConfig?: FeeIssuerConfig | undefined, zcfSpec?: ZCFSpec | undefined): {
+    zoeService: ZoeService;
+    zoeConfigFacet: import("@endo/exo").Guarded<{
+        updateZcfBundleId(bundleId: any): void;
+    }>;
+    /** @type {FeeMintAccess} */
+    feeMintAccess: FeeMintAccess;
+    setVatAdminService: ((lateVatAdminSvc: any) => void) & import("@endo/eventual-send").RemotableBrand<{}, (lateVatAdminSvc: any) => void>;
+};
+import type { Baggage } from '@agoric/vat-data';
+//# sourceMappingURL=zoe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zoe.d.ts","sourceRoot":"","sources":["zoe.js"],"names":[],"mappings":"qBA+Ra,WAAW,wBAAwB,CAAC;AA/PjD;;;;;;;;;;;;;GAaG;AACH;;;;;;;;;;;IA6MI,4BAA4B;mBAAjB,aAAa;;EAK3B;AAED;;;;;;;;;;;;;;;GAeG;AACH;;;;;IAvBI,4BAA4B;mBAAjB,aAAa;;EA8BxB;6BA7PuB,kBAAkB"}

package/src/zoeService/zoe.js

@@ -11,8 +11,6 @@
  * validate that.
  */
 
-/// <reference path="../../../ERTP/exported.js" />
-/// <reference path="../../../store/exported.js" />
 /// <reference path="../internal-types.js" />
 
 import { E } from '@endo/eventual-send';

package/src/zoeService/zoeSeat.d.ts

@@ -0,0 +1,26 @@
+export function makeZoeSeatAdminFactory(baggage: import('@agoric/vat-data').Baggage): (initialAllocation: Allocation, proposal: ProposalRecord, instanceAdminHelper: InstanceAdminHelper, withdrawFacet: WithdrawFacet, exitObj?: ERef<ExitObj> | undefined, offerResultIsUndefined?: boolean | undefined) => {
+    userSeat: import("@endo/exo").Guarded<{
+        getProposal(): Promise<any>;
+        getPayouts(): Promise<any>;
+        getPayout(keyword: any): Promise<any>;
+        getOfferResult(): Promise<any>;
+        hasExited(): Promise<any>;
+        tryExit(): Promise<any>;
+        numWantsSatisfied(): Promise<any>;
+        getExitSubscriber(): any;
+        getFinalAllocation(): any;
+    }>;
+    zoeSeatAdmin: import("@endo/exo").Guarded<{
+        replaceAllocation(replacementAllocation: any): void;
+        exit(completion: any): void;
+        fail(reason: any): void;
+        /** @param {HandleOfferResult} result */
+        resolveExitAndResult({ offerResultPromise, exitObj }: HandleOfferResult): void;
+        getExitSubscriber(): import("@endo/exo").Guarded<{
+            subscribeAfter(publishCount?: bigint): Promise<any>;
+            getUpdateSince(updateCount: any): any;
+        }>;
+        finalPayouts(payments: any): Promise<void>;
+    }>;
+};
+//# sourceMappingURL=zoeSeat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zoeSeat.d.ts","sourceRoot":"","sources":["zoeSeat.js"],"names":[],"mappings":"AAoDO,iDAFI,OAAO,kBAAkB,EAAE,OAAO,uBAuWhC,UAAU,YACV,cAAc,uBACd,mBAAmB,iBACnB,aAAa;;;;;;;;;;;;;;;;QAxIlB,wCAAwC;8DAA5B,iBAAiB;;;;;;;EAmKpC"}

package/src/zoeService/zoeStorageManager.d.ts

@@ -0,0 +1,41 @@
+export function makeZoeStorageManager(createZCFVat: CreateZCFVat, getBundleCapForID: GetBundleCapForID, shutdownZoeVat: import('@agoric/swingset-vat').ShutdownWithFailure, feeMint: {
+    getFeeIssuerKit: GetFeeIssuerKit;
+    getFeeIssuer: () => Issuer;
+    getFeeBrand: () => Brand;
+}, zoeBaggage: Baggage): import("@endo/exo").GuardedKit<{
+    zoeServiceDataAccess: {
+        getInvitationIssuer: () => globalThis.Issuer<"set">;
+        getBundleIDFromInstallation(allegedInstallation: any): any;
+        getPublicFacet(instance: any): any;
+        getBrands(instance: any): any;
+        getIssuers(instance: any): any;
+        getOfferFilter(instance: any): any;
+        getTerms(instance: any): any;
+        getInstallation(instance: any): any;
+        getProposalShapeForInvitation: (invitationHandle: any) => any;
+        installBundle: (allegedBundle: any, bundleLabel: any) => any;
+        installBundleID(bundleID: any, bundleLabel: any): Promise<Installation<unknown>>;
+    };
+    makeOfferAccess: {
+        getAssetKindByBrand: GetAssetKindByBrand;
+        getInstanceAdmin(instance: any): any;
+        getProposalShapeForInvitation: (invitationHandle: any) => any;
+        getInvitationIssuer: () => globalThis.Issuer<"set">;
+        depositPayments(proposal: any, payments: any): Promise<AmountKeywordRecord>;
+    };
+    startInstanceAccess: {
+        makeZoeInstanceStorageManager: MakeZoeInstanceStorageManager;
+        /** @type {UnwrapInstallation} */
+        unwrapInstallation(installationP: ERef<Installation<any>>): ERef<{
+            bundle?: SourceBundle | undefined;
+            bundleCap?: any;
+            bundleID?: string | undefined;
+            installation: Installation<any>;
+        }>;
+    };
+    invitationIssuerAccess: {
+        getInvitationIssuer: () => globalThis.Issuer<"set">;
+    };
+}>;
+import type { Baggage } from '@agoric/vat-data';
+//# sourceMappingURL=zoeStorageManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zoeStorageManager.d.ts","sourceRoot":"","sources":["zoeStorageManager.js"],"names":[],"mappings":"AAwDO,oDAXI,YAAY,qBAEZ,iBAAiB,kBACjB,OAAO,sBAAsB,EAAE,mBAAmB,WAClD;IACV,eAAoB,EAAE,eAAe,CAAC;IACtC,YAAiB,EAAE,MAAM,MAAM,CAAC;IAChC,WAAgB,EAAE,MAAM,KAAK,CAAC;CAC3B;;;;;;;;;;;;;;;;;;;;;;;QA+ZI,iCAAiC;;;;;;;;;;;GAYxC;6BAjc0B,kBAAkB"}

package/tools/fakePriceAuthority.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @typedef {object} FakePriceAuthorityOptions
+ * @property {Brand<'nat'>} actualBrandIn
+ * @property {Brand<'nat'>} actualBrandOut
+ * @property {Array<number>} [priceList]
+ * @property {Array<[number, number]>} [tradeList]
+ * @property {ERef<import('@agoric/time').TimerService>} timer
+ * @property {import('@agoric/time').RelativeTime} [quoteInterval]
+ * @property {ERef<Mint<'set'>>} [quoteMint]
+ * @property {Amount<'nat'>} [unitAmountIn]
+ */
+/**
+ * TODO: multiple price Schedules for different goods, or for moving the price
+ * in different directions?
+ *
+ * @param {FakePriceAuthorityOptions} options
+ * @returns {Promise<PriceAuthority>}
+ */
+export function makeFakePriceAuthority(options: FakePriceAuthorityOptions): Promise<PriceAuthority>;
+export type FakePriceAuthorityOptions = {
+    actualBrandIn: Brand<'nat'>;
+    actualBrandOut: Brand<'nat'>;
+    priceList?: number[] | undefined;
+    tradeList?: [number, number][] | undefined;
+    timer: ERef<import("@agoric/time").TimerService>;
+    quoteInterval?: import("@agoric/time").RelativeTime | undefined;
+    quoteMint?: ERef<globalThis.Mint<"set">> | undefined;
+    unitAmountIn?: globalThis.Amount<"nat"> | undefined;
+};
+//# sourceMappingURL=fakePriceAuthority.d.ts.map

package/tools/fakePriceAuthority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakePriceAuthority.d.ts","sourceRoot":"","sources":["fakePriceAuthority.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;GAUG;AAEH;;;;;;GAMG;AACH,gDAHW,yBAAyB,GACvB,QAAQ,cAAc,CAAC,CAqSnC;;mBApTa,MAAM,KAAK,CAAC;oBACZ,MAAM,KAAK,CAAC"}

package/tools/fakeVatAdmin.d.ts

@@ -0,0 +1,103 @@
+export const zcfBundleCap: any;
+export default fakeVatAdmin;
+export type BundleID = import('@agoric/swingset-vat').BundleID;
+export type EndoZipBase64Bundle = import('@agoric/swingset-vat').EndoZipBase64Bundle;
+export type BundleCap = import('@agoric/swingset-vat').BundleCap;
+declare const fakeVatAdmin: {
+    getBundleCap: (bundleID: any) => Promise<any>;
+    waitForBundleCap: (bundleID: any) => Promise<any>;
+    getNamedBundleCap: (name: any) => Promise<any>;
+    getBundleIDByName: (name: any) => Promise<string>;
+    createVat: (bundleCap: any, { vatParameters }?: {
+        vatParameters?: {} | undefined;
+    }) => Promise<{
+        root: unknown;
+        adminNode: {
+            done: () => Promise<any>;
+            terminateWithFailure: () => void;
+            upgrade: (_bundleCap: any, _options: any) => never;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            done: () => Promise<any>;
+            terminateWithFailure: () => void;
+            upgrade: (_bundleCap: any, _options: any) => never;
+        }>;
+    }>;
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    getBundleCap: (bundleID: any) => Promise<any>;
+    waitForBundleCap: (bundleID: any) => Promise<any>;
+    getNamedBundleCap: (name: any) => Promise<any>;
+    getBundleIDByName: (name: any) => Promise<string>;
+    createVat: (bundleCap: any, { vatParameters }?: {
+        vatParameters?: {} | undefined;
+    }) => Promise<{
+        root: unknown;
+        adminNode: {
+            done: () => Promise<any>;
+            terminateWithFailure: () => void;
+            upgrade: (_bundleCap: any, _options: any) => never;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            done: () => Promise<any>;
+            terminateWithFailure: () => void;
+            upgrade: (_bundleCap: any, _options: any) => never;
+        }>;
+    }>;
+}>;
+/**
+ * @param {(...args) => unknown} [testContextSetter]
+ * @param {(x: unknown) => unknown} [makeRemote]
+ */
+export function makeFakeVatAdmin(testContextSetter?: ((...args: any[]) => unknown) | undefined, makeRemote?: ((x: unknown) => unknown) | undefined): {
+    admin: {
+        getBundleCap: (bundleID: any) => Promise<any>;
+        waitForBundleCap: (bundleID: any) => Promise<any>;
+        getNamedBundleCap: (name: any) => Promise<any>;
+        getBundleIDByName: (name: any) => Promise<string>;
+        createVat: (bundleCap: any, { vatParameters }?: {
+            vatParameters?: {} | undefined;
+        }) => Promise<{
+            root: unknown;
+            adminNode: {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            }>;
+        }>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getBundleCap: (bundleID: any) => Promise<any>;
+        waitForBundleCap: (bundleID: any) => Promise<any>;
+        getNamedBundleCap: (name: any) => Promise<any>;
+        getBundleIDByName: (name: any) => Promise<string>;
+        createVat: (bundleCap: any, { vatParameters }?: {
+            vatParameters?: {} | undefined;
+        }) => Promise<{
+            root: unknown;
+            adminNode: {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                done: () => Promise<any>;
+                terminateWithFailure: () => void;
+                upgrade: (_bundleCap: any, _options: any) => never;
+            }>;
+        }>;
+    }>;
+    vatAdminState: {
+        getExitMessage: () => any;
+        getHasExited: () => boolean;
+        getExitWithFailure: () => any;
+        installBundle: (id: any, bundle: any) => any;
+        installNamedBundle: (name: any, id: any, bundle: any) => any;
+        getCriticalVatKey: () => {};
+        getVatPowers: () => {
+            D: (bcap: any) => {
+                getBundle: () => globalThis.EndoZipBase64Bundle;
+            };
+        };
+    };
+};
+//# sourceMappingURL=fakeVatAdmin.d.ts.map

package/tools/fakeVatAdmin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeVatAdmin.d.ts","sourceRoot":"","sources":["fakeVatAdmin.js"],"names":[],"mappings":"AAsBA,+BAA4C;;uBAR7B,OAAO,sBAAsB,EAAE,QAAQ;kCACvC,OAAO,sBAAsB,EAAE,mBAAmB;wBAGlD,OAAO,sBAAsB,EAAE,SAAS;AAmJvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA8C;AA7I9C;;;GAGG;AACH,0EAHwB,OAAO,iCAChB,OAAO,KAAK,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoIjC"}

package/tools/internal-types.d.ts

@@ -0,0 +1,12 @@
+type ManualTimerAdmin = {
+    /**
+     * Advance the timer by one tick.
+     * DEPRECATED: use `await tickN(1)` instead.  `tick` function errors might be
+     * thrown synchronously, even though success is signaled by returning anything
+     * other than a rejected promise.
+     */
+    tick: (msg?: string) => void | Promise<void>;
+    tickN: (nTimes: number, msg?: string) => Promise<void>;
+};
+type ManualTimer = import('@agoric/time').TimerService & ManualTimerAdmin;
+//# sourceMappingURL=internal-types.d.ts.map

package/tools/internal-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal-types.d.ts","sourceRoot":"","sources":["internal-types.js"],"names":[],"mappings":";;;;;;;UAIc,CAAC,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,GAAG,QAAQ,IAAI,CAAC;WAItC,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,QAAQ,IAAI,CAAC;;mBAIhD,OAAO,cAAc,EAAE,YAAY,GAAG,gBAAgB"}

package/tools/manualPriceAuthority.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @param {object} options
+ * @param {Brand<'nat'>} options.actualBrandIn
+ * @param {Brand<'nat'>} options.actualBrandOut
+ * @param {Ratio} options.initialPrice
+ * @param {import('@agoric/time').TimerService} options.timer
+ * @param {IssuerKit<'set'>} [options.quoteIssuerKit]
+ * @returns {PriceAuthority & { setPrice: (Ratio) => void; disable: () => void }}
+ */
+export function makeManualPriceAuthority(options: {
+    actualBrandIn: Brand<'nat'>;
+    actualBrandOut: Brand<'nat'>;
+    initialPrice: Ratio;
+    timer: import('@agoric/time').TimerService;
+    quoteIssuerKit?: globalThis.IssuerKit<"set"> | undefined;
+}): PriceAuthority & {
+    setPrice: (Ratio: any) => void;
+    disable: () => void;
+};
+export type ManualPriceAuthority = ReturnType<typeof makeManualPriceAuthority>;
+//# sourceMappingURL=manualPriceAuthority.d.ts.map

package/tools/manualPriceAuthority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manualPriceAuthority.d.ts","sourceRoot":"","sources":["manualPriceAuthority.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH;IAPiC,aAAa,EAAnC,MAAM,KAAK,CAAC;IACU,cAAc,EAApC,MAAM,KAAK,CAAC;IACG,YAAY,EAA3B,KAAK;IACwC,KAAK,EAAlD,OAAO,cAAc,EAAE,YAAY;IACR,cAAc;IACvC,cAAc,GAAG;IAAE,QAAQ,EAAE,CAAC,KAAK,KAAA,KAAK,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CA8E/E;mCACa,WAAW,+BAA+B,CAAC"}

package/tools/manualTimer.d.ts

@@ -0,0 +1,44 @@
+export default buildManualTimer;
+export type ZoeManualTimerOptions = {
+    timeStep?: import('@agoric/time').RelativeTime | bigint;
+    eventLoopIteration?: () => Promise<void>;
+};
+/**
+ * A fake TimerService, for unit tests that do not use a real
+ * kernel. You can make time pass by calling `advanceTo(when)`, or one
+ * `timeStep` at a time by calling `tick()`.
+ *
+ * `advanceTo()` merely schedules a wakeup: the actual
+ * handlers (in the code under test) are invoked several turns
+ * later. Some zoe/etc tests want to poll for the consequences of
+ * those invocations. The best approach is to get an appropriate
+ * Promise from your code-under-test, wait for it to fire, and then
+ * poll. But some libraries do not offer this convenience, especially
+ * when they use internal "fire and forget" actions.
+ *
+ * To support those tests, the manual timer accepts a
+ * `eventLoopIteration` option. If provided, each call to `tick()`
+ * will wait for all triggered activity to complete before
+ * returning. That doesn't mean the `wake()` handler's result promise
+ * has fired; it just means there are no settled Promises still trying
+ * to execute their callbacks.
+ *
+ * The following will wait for all such Promise activity to finish
+ * before returning from `tick()`:
+ *
+ *  eventLoopIteration = () => new Promise(setImmediate);
+ *  mt = buildManualTimer(log, startTime, { eventLoopIteration })
+ *
+ * `tickN(count)` calls `tick()` multiple times, awaiting each one
+ *
+ * The first argument is called to log 'tick' events, which might help
+ * with "golden transcript" -style tests to distinguish tick
+ * boundaries
+ *
+ * @param {(...args: any[]) => void} [log]
+ * @param {import('@agoric/time').Timestamp | bigint} [startValue=0n]
+ * @param {ZoeManualTimerOptions} [options]
+ * @returns {ManualTimer}
+ */
+declare function buildManualTimer(log?: ((...args: any[]) => void) | undefined, startValue?: import("@agoric/time").Timestamp | undefined, options?: ZoeManualTimerOptions | undefined): ManualTimer;
+//# sourceMappingURL=manualTimer.d.ts.map

package/tools/manualTimer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manualTimer.d.ts","sourceRoot":"","sources":["manualTimer.js"],"names":[],"mappings":";oCAca;IACZ,QAAW,CAAC,EAAE,OAAO,cAAc,EAAE,YAAY,GAAG,MAAM,CAAC;IAC3D,kBAAqB,CAAC,EAAE,MAAM,QAAQ,IAAI,CAAC,CAAC;CACzC;AAKJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,mDANqB,GAAG,EAAE,KAAK,IAAI,wHAGtB,WAAW,CAuDvB"}

package/tools/prepare-test-env-ava.d.ts

@@ -0,0 +1,2 @@
+export { test, VatData } from "@agoric/swingset-vat/tools/prepare-test-env-ava.js";
+//# sourceMappingURL=prepare-test-env-ava.d.ts.map

package/tools/prepare-test-env-ava.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-test-env-ava.d.ts","sourceRoot":"","sources":["prepare-test-env-ava.js"],"names":[],"mappings":""}

package/tools/prepare-test-env.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prepare-test-env.d.ts.map

package/tools/prepare-test-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-test-env.d.ts","sourceRoot":"","sources":["prepare-test-env.js"],"names":[],"mappings":""}