@agoric/zoe 0.28.0-u23.0 → 0.28.0-u23.1

package/src/typeGuards.d.ts

@@ -0,0 +1,185 @@
+/**
+ * @import {TypedPattern} from '@agoric/internal';
+ * @import {AfterDeadlineExitRule, Installation, ZoeIssuerRecord} from '@agoric/zoe';
+ * @import {ExitRule, Invitation, InvitationHandle, WaivedExitRule} from './types-index.js';
+ * @import {InvitationDetails} from './types-index.js';
+ */
+export const KeywordShape: import("@endo/patterns").Matcher;
+/** @type {TypedPattern<InvitationHandle>} */
+export const InvitationHandleShape: TypedPattern<InvitationHandle>;
+/** @type {TypedPattern<Invitation>} */
+export const InvitationShape: TypedPattern<Invitation>;
+export const InstanceHandleShape: import("@endo/patterns").Matcher;
+/** @type {TypedPattern<Installation>} */
+export const InstallationShape: TypedPattern<Installation>;
+export const SeatShape: import("@endo/patterns").Matcher;
+export const AmountKeywordRecordShape: import("@endo/patterns").Matcher;
+export const AmountPatternKeywordRecordShape: import("@endo/patterns").Matcher;
+export const PaymentPKeywordRecordShape: import("@endo/patterns").Matcher;
+export const IssuerKeywordRecordShape: import("@endo/patterns").Matcher;
+export const IssuerPKeywordRecordShape: import("@endo/patterns").Matcher;
+export const BrandKeywordRecordShape: import("@endo/patterns").Matcher;
+/** @type {TypedPattern<ZoeIssuerRecord>} */
+export const IssuerRecordShape: TypedPattern<ZoeIssuerRecord>;
+export namespace TermsShape {
+    export { IssuerKeywordRecordShape as issuers };
+    export { BrandKeywordRecordShape as brands };
+}
+export namespace InstanceRecordShape {
+    export { InstallationShape as installation };
+    export { InstanceHandleShape as instance };
+    export let terms: import("@endo/patterns").Matcher;
+}
+export const HandleI: import("@endo/patterns").InterfaceGuard<{}>;
+export function makeHandleShape(name: any): import("@endo/patterns").Matcher;
+export const TimerShape: import("@endo/patterns").Matcher;
+export namespace FullProposalShape {
+    export { AmountPatternKeywordRecordShape as want };
+    export { AmountKeywordRecordShape as give };
+    export let exit: import("@endo/patterns").Matcher;
+}
+/** @see {Proposal} type */
+export const ProposalShape: import("@endo/patterns").Matcher;
+export const EmptyProposalShape: import("@endo/patterns").Matcher;
+export function isOnDemandExitRule(exit: any): boolean;
+export function isWaivedExitRule(exit: ExitRule): exit is WaivedExitRule;
+export function isAfterDeadlineExitRule(exit: ExitRule): exit is AfterDeadlineExitRule;
+/** @type {TypedPattern<InvitationDetails>} */
+export const InvitationElementShape: TypedPattern<InvitationDetails>;
+export const OfferHandlerI: import("@endo/patterns").InterfaceGuard<{
+    handle: import("@endo/patterns").MethodGuard;
+}>;
+export const SeatHandleAllocationsShape: import("@endo/patterns").Matcher;
+export const ZoeMintShape: import("@endo/patterns").Matcher;
+export const ZoeMintI: import("@endo/patterns").InterfaceGuard<{
+    getIssuerRecord: import("@endo/patterns").MethodGuard;
+    mintAndEscrow: import("@endo/patterns").MethodGuard;
+    withdrawAndBurn: import("@endo/patterns").MethodGuard;
+}>;
+export const FeeMintAccessShape: import("@endo/patterns").Matcher;
+export const ExitObjectI: import("@endo/patterns").InterfaceGuard<{
+    exit: import("@endo/patterns").MethodGuard;
+}>;
+export const ExitObjectShape: import("@endo/patterns").Matcher;
+export const InstanceAdminShape: import("@endo/patterns").Matcher;
+export const InstanceAdminI: import("@endo/patterns").InterfaceGuard<{
+    makeInvitation: import("@endo/patterns").MethodGuard;
+    saveIssuer: import("@endo/patterns").MethodGuard;
+    makeNoEscrowSeat: import("@endo/patterns").MethodGuard;
+    exitAllSeats: import("@endo/patterns").MethodGuard;
+    failAllSeats: import("@endo/patterns").MethodGuard;
+    exitSeat: import("@endo/patterns").MethodGuard;
+    failSeat: import("@endo/patterns").MethodGuard;
+    makeZoeMint: import("@endo/patterns").MethodGuard;
+    registerFeeMint: import("@endo/patterns").MethodGuard;
+    replaceAllocations: import("@endo/patterns").MethodGuard;
+    stopAcceptingOffers: import("@endo/patterns").MethodGuard;
+    setOfferFilter: import("@endo/patterns").MethodGuard;
+    getOfferFilter: import("@endo/patterns").MethodGuard;
+    getExitSubscriber: import("@endo/patterns").MethodGuard;
+    isBlocked: import("@endo/patterns").MethodGuard;
+    repairContractCompletionWatcher: import("@endo/patterns").MethodGuard;
+}>;
+export namespace InstanceStorageManagerIKit {
+    let instanceStorageManager: import("@endo/patterns").InterfaceGuard<{
+        getTerms: import("@endo/patterns").MethodGuard;
+        getIssuers: import("@endo/patterns").MethodGuard;
+        getBrands: import("@endo/patterns").MethodGuard;
+        getInstallation: import("@endo/patterns").MethodGuard;
+        getInvitationIssuer: import("@endo/patterns").MethodGuard;
+        saveIssuer: import("@endo/patterns").MethodGuard;
+        makeZoeMint: import("@endo/patterns").MethodGuard;
+        registerFeeMint: import("@endo/patterns").MethodGuard;
+        getInstanceRecord: import("@endo/patterns").MethodGuard;
+        getIssuerRecords: import("@endo/patterns").MethodGuard;
+        getWithdrawFacet: import("@endo/patterns").MethodGuard;
+        initInstanceAdmin: import("@endo/patterns").MethodGuard;
+        deleteInstanceAdmin: import("@endo/patterns").MethodGuard;
+        makeInvitation: import("@endo/patterns").MethodGuard;
+        getRoot: import("@endo/patterns").MethodGuard;
+        getAdminNode: import("@endo/patterns").MethodGuard;
+    }>;
+    let withdrawFacet: import("@endo/patterns").InterfaceGuard<{
+        withdrawPayments: import("@endo/patterns").MethodGuard;
+    }>;
+    let helpers: import("@endo/patterns").InterfaceGuard<{
+        wrapIssuerKitWithZoeMint: import("@endo/patterns").MethodGuard;
+    }>;
+}
+export const BundleCapShape: import("@endo/patterns").Matcher;
+export const BundleShape: import("@endo/patterns").Matcher;
+export const UnwrappedInstallationShape: import("@endo/patterns").Matcher;
+export namespace ZoeStorageManagerIKit {
+    let zoeServiceDataAccess: import("@endo/patterns").InterfaceGuard<{
+        getTerms: import("@endo/patterns").MethodGuard;
+        getIssuers: import("@endo/patterns").MethodGuard;
+        getBrands: import("@endo/patterns").MethodGuard;
+        getInstallation: import("@endo/patterns").MethodGuard;
+        getInvitationIssuer: import("@endo/patterns").MethodGuard;
+        getBundleIDFromInstallation: import("@endo/patterns").MethodGuard;
+        installBundle: import("@endo/patterns").MethodGuard;
+        installBundleID: import("@endo/patterns").MethodGuard;
+        getPublicFacet: import("@endo/patterns").MethodGuard;
+        getOfferFilter: import("@endo/patterns").MethodGuard;
+        getProposalShapeForInvitation: import("@endo/patterns").MethodGuard;
+    }>;
+    let makeOfferAccess: import("@endo/patterns").InterfaceGuard<{
+        getAssetKindByBrand: import("@endo/patterns").MethodGuard;
+        getInstanceAdmin: import("@endo/patterns").MethodGuard;
+        getProposalShapeForInvitation: import("@endo/patterns").MethodGuard;
+        getInvitationIssuer: import("@endo/patterns").MethodGuard;
+        depositPayments: import("@endo/patterns").MethodGuard;
+    }>;
+    let startInstanceAccess: import("@endo/patterns").InterfaceGuard<{
+        makeZoeInstanceStorageManager: import("@endo/patterns").MethodGuard;
+        unwrapInstallation: import("@endo/patterns").MethodGuard;
+    }>;
+    let invitationIssuerAccess: import("@endo/patterns").InterfaceGuard<{
+        getInvitationIssuer: import("@endo/patterns").MethodGuard;
+    }>;
+}
+export const ZoeServiceI: import("@endo/patterns").InterfaceGuard<{
+    install: import("@endo/patterns").MethodGuard;
+    installBundleID: import("@endo/patterns").MethodGuard;
+    startInstance: import("@endo/patterns").MethodGuard;
+    offer: import("@endo/patterns").MethodGuard;
+    getOfferFilter: import("@endo/patterns").MethodGuard;
+    getInvitationIssuer: import("@endo/patterns").MethodGuard;
+    getFeeIssuer: import("@endo/patterns").MethodGuard;
+    getBrands: import("@endo/patterns").MethodGuard;
+    getIssuers: import("@endo/patterns").MethodGuard;
+    getPublicFacet: import("@endo/patterns").MethodGuard;
+    getTerms: import("@endo/patterns").MethodGuard;
+    getInstallationForInstance: import("@endo/patterns").MethodGuard;
+    getBundleIDFromInstallation: import("@endo/patterns").MethodGuard;
+    getInstallation: import("@endo/patterns").MethodGuard;
+    getInstance: import("@endo/patterns").MethodGuard;
+    getConfiguration: import("@endo/patterns").MethodGuard;
+    getInvitationDetails: import("@endo/patterns").MethodGuard;
+    getProposalShapeForInvitation: import("@endo/patterns").MethodGuard;
+}>;
+export const AdminFacetI: import("@endo/patterns").InterfaceGuard<{
+    getVatShutdownPromise: import("@endo/patterns").MethodGuard;
+    restartContract: import("@endo/patterns").MethodGuard;
+    upgradeContract: import("@endo/patterns").MethodGuard;
+    terminateContract: import("@endo/patterns").MethodGuard;
+}>;
+export const SeatDataShape: import("@endo/patterns").Matcher;
+export const HandleOfferI: import("@endo/patterns").InterfaceGuard<{
+    handleOffer: import("@endo/patterns").MethodGuard;
+}>;
+export namespace PriceQuoteShape {
+    export { AmountShape as quoteAmount };
+    export let quotePayment: import("@endo/patterns").Pattern;
+}
+import type { InvitationHandle } from './types-index.js';
+import type { TypedPattern } from '@agoric/internal';
+import type { Invitation } from './types-index.js';
+import type { Installation } from '@agoric/zoe';
+import type { ZoeIssuerRecord } from '@agoric/zoe';
+import type { ExitRule } from './types-index.js';
+import type { WaivedExitRule } from './types-index.js';
+import type { AfterDeadlineExitRule } from '@agoric/zoe';
+import type { InvitationDetails } from './types-index.js';
+import { AmountShape } from '@agoric/ertp';
+//# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAaA;;;;;GAKG;AAGH,4DAAuC;AAEvC,6CAA6C;AAC7C,oCADW,aAAa,gBAAgB,CAAC,CAC4B;AACrE,uCAAuC;AACvC,8BADW,aAAa,UAAU,CAAC,CACsB;AACzD,mEAAiE;AACjE,yCAAyC;AACzC,gCADW,aAAa,YAAY,CAAC,CACwB;AAC7D,yDAA6C;AAE7C,wEAA8E;AAC9E,+EAGE;AACF,0EAGE;AACF,wEAA8E;AAC9E,yEAGE;AACF,uEAA4E;AAE5E,4CAA4C;AAC5C,gCADW,aAAa,eAAe,CAAC,CAQtC;;;;;;;;;;AAeF,kEAAiD;AAE1C,6EAA4D;AACnE,0DAAmD;;;;;;AA4BnD,2BAA2B;AAC3B,6DAAsE;AAEtE,kEAIG;AAEI,uDAGN;AAOM,uCAHI,QAAQ,GACN,IAAI,IAAI,cAAc,CAKlC;AAOM,8CAHI,QAAQ,GACN,IAAI,IAAI,qBAAqB,CAKzC;AAGD,8CAA8C;AAC9C,qCADW,aAAa,iBAAiB,CAAC,CAMvC;AAEH;;GAEG;AAEH,0EAGG;AAEH,4DAAmD;AACnD;;;;GAIG;AAEH,kEAA+D;AAE/D;;GAEG;AAEH,+DAAsD;AACtD,kEAA+D;AAC/D;;;;;;;;;;;;;;;;;GAkCG;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDH,8DAAuD;AACvD,2DAGE;AAEF,0EAQE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DF;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;;GAKG;AAEH,6DASE;AAEF;;GAKG;;;;;sCA/XsE,kBAAkB;kCAF5D,kBAAkB;gCAEwB,kBAAkB;kCADpB,aAAa;qCAAb,aAAa;8BACX,kBAAkB;oCAAlB,kBAAkB;2CADpB,aAAa;uCAEhD,kBAAkB;4BAT/C,cAAc"}

package/src/types.d.ts

@@ -0,0 +1,29 @@
+import type { Brand, Issuer } from '@agoric/ertp';
+import type { RemotableObject } from '@endo/pass-style';
+/**
+ * Alias for RemotableObject
+ */
+export type Handle<H extends string> = RemotableObject<H>;
+/** Must start with a capital letter. */
+export type Keyword = string;
+/**
+ * - an opaque handle for an invitation
+ */
+export type InvitationHandle = Handle<'Invitation'>;
+export type IssuerKeywordRecord = Record<Keyword, Issuer<any>>;
+export type IssuerPKeywordRecord = Record<Keyword, import('@endo/far').ERef<Issuer<any>>>;
+export type BrandKeywordRecord = Record<Keyword, Brand<any>>;
+export type StandardTerms = {
+    /**
+     * - record with
+     * keywords keys, issuer values
+     */
+    issuers: IssuerKeywordRecord;
+    /**
+     * - record with keywords
+     * keys, brand values
+     */
+    brands: BrandKeywordRecord;
+};
+export type AnyTerms = StandardTerms & Record<string, any>;
+//# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,MAAM,IAAI,eAAe,CAAC,CAAC,CAAC,CAAC;AAK1D,wCAAwC;AACxC,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;AACpD,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;AAC/D,MAAM,MAAM,oBAAoB,GAAG,MAAM,CACvC,OAAO,EACP,OAAO,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CACtC,CAAC;AACF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;AAC7D,MAAM,MAAM,aAAa,GAAG;IAC1B;;;OAGG;IACH,OAAO,EAAE,mBAAmB,CAAC;IAC7B;;;OAGG;IACH,MAAM,EAAE,kBAAkB,CAAC;CAC5B,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC"}

package/src/zoeService/createZCFVat.d.ts

@@ -0,0 +1,2 @@
+export function getZcfBundleCap(zcfSpec: any, vatAdminSvc: any): any;
+//# sourceMappingURL=createZCFVat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createZCFVat.d.ts","sourceRoot":"","sources":["createZCFVat.js"],"names":[],"mappings":"AAIO,qEAcN"}

package/src/zoeService/escrowStorage.d.ts

@@ -0,0 +1,12 @@
+export function provideEscrowStorage(baggage: Baggage): {
+    createPurse: CreatePurse;
+    provideLocalPurse: ProvideLocalPurse;
+    withdrawPayments: WithdrawPayments;
+    depositPayments: DepositPayments;
+};
+import type { Baggage } from '@agoric/vat-data';
+import type { CreatePurse } from './internal-types.js';
+import type { ProvideLocalPurse } from './internal-types.js';
+import type { WithdrawPayments } from '../internal-types.js';
+import type { DepositPayments } from './internal-types.js';
+//# sourceMappingURL=escrowStorage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"escrowStorage.d.ts","sourceRoot":"","sources":["escrowStorage.js"],"names":[],"mappings":"AA4BO,8CAFI,OAAO;;;;;EA8GjB;6BA5HyB,kBAAkB;iCACsB,qBAAqB;uCAArB,qBAAqB;sCACpD,sBAAsB;qCADS,qBAAqB"}

package/src/zoeService/feeMint.d.ts

@@ -0,0 +1,27 @@
+export namespace defaultFeeIssuerConfig {
+    let name: "ZDEFAULT";
+    let assetKind: "nat";
+    namespace displayInfo {
+        export let decimalPlaces: number;
+        let assetKind_1: "nat";
+        export { assetKind_1 as assetKind };
+    }
+}
+/**
+ * @param {Baggage} zoeBaggage
+ * @param {FeeIssuerConfig} feeIssuerConfig
+ * @param {ShutdownWithFailure} shutdownZoeVat
+ */
+export function prepareFeeMint(zoeBaggage: Baggage, feeIssuerConfig: FeeIssuerConfig, shutdownZoeVat: ShutdownWithFailure): import("@endo/exo").GuardedKit<{
+    feeMint: {
+        getFeeIssuerKit(allegedFeeMintAccess: any): IssuerKit<"nat">;
+        getFeeIssuer(): import("@agoric/ertp").Issuer<"nat", import("@endo/patterns").Key>;
+        getFeeBrand(): import("@agoric/ertp").Brand<"nat">;
+    };
+    feeMintAccess: {};
+}>;
+import type { Baggage } from '@agoric/vat-data';
+import type { FeeIssuerConfig } from './types.js';
+import type { ShutdownWithFailure } from '@agoric/swingset-vat';
+import type { IssuerKit } from '@agoric/ertp';
+//# sourceMappingURL=feeMint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feeMint.d.ts","sourceRoot":"","sources":["feeMint.js"],"names":[],"mappings":";;;;;;;;;AAkCA;;;;GAIG;AACH,2CAJW,OAAO,mBACP,eAAe,kBACf,mBAAmB;;;;;;;GA2D7B;6BA/EyB,kBAAkB;qCAEV,YAAY;yCADR,sBAAsB;+BAEhC,cAAc"}

package/src/zoeService/installationStorage.d.ts

@@ -0,0 +1,21 @@
+export function makeInstallationStorage(getBundleCapForID: GetBundleCapForID, zoeBaggage: Baggage): import("@endo/exo").Guarded<{
+    installBundle(allegedBundle: any, bundleLabel: any): Promise<Installation<any>>;
+    installBundleID(bundleID: any, bundleLabel?: any): Promise<Installation<unknown>>;
+    unwrapInstallation(installation: any): {
+        bundleCap: any;
+        bundleID: string;
+        installation: any;
+        bundle?: undefined;
+    } | {
+        bundle: SourceBundle;
+        installation: any;
+        bundleCap?: undefined;
+        bundleID?: undefined;
+    };
+    getBundleIDFromInstallation(allegedInstallation: any): Promise<string | undefined>;
+}>;
+import type { GetBundleCapForID } from './internal-types.js';
+import type { Baggage } from '@agoric/swingset-liveslots';
+import type { Installation } from '@agoric/zoe';
+import type { SourceBundle } from '@agoric/zoe';
+//# sourceMappingURL=installationStorage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"installationStorage.d.ts","sourceRoot":"","sources":["installationStorage.js"],"names":[],"mappings":"AAwBO,2DAHI,iBAAiB,cACjB,OAAO;;;;;;;;;;;;;;;GA0IjB;uCA/ImC,qBAAqB;6BAJ/B,4BAA4B;kCAGM,aAAa;kCAAb,aAAa"}

package/src/zoeService/instanceAdminStorage.d.ts

@@ -0,0 +1,107 @@
+export function makeInstanceAdminStorage(baggage: Baggage): import("@endo/exo").GuardedKit<{
+    accessor: {
+        getPublicFacet(instance: any): any;
+        getBrands(instance: any): any;
+        getIssuers(instance: any): any;
+        getTerms(instance: any): any;
+        getOfferFilter(instance: any): any;
+        getInstallation(instance: any): any;
+        getInstanceAdmin(instance: any): any;
+    };
+    updater: {
+        initInstanceAdmin(instance: any, instanceAdmin: any): Promise<void>;
+        deleteInstanceAdmin(instance: any): void;
+    };
+}>;
+export function makeInstanceAdminMaker(zoeBaggage: Baggage, seatHandleToZoeSeatAdmin: WeakMapStore<SeatHandle, ZoeSeatAdmin>): (instanceHandle: any, zoeInstanceStorageManager: any, adminNode: any) => import("@agoric/swingset-liveslots").KindFacet<{
+    getPublicFacet: ({ state }: {
+        state: any;
+    }) => any;
+    getTerms: ({ state }: {
+        state: any;
+    }) => any;
+    getIssuers: ({ state }: {
+        state: any;
+    }) => any;
+    getBrands: ({ state }: {
+        state: any;
+    }) => any;
+    initDelayedState: ({ state }: {
+        state: any;
+    }, handleOfferObj: any, publicFacet: any) => void;
+    getInstallation: ({ state }: {
+        state: any;
+    }) => any;
+    getInstance: ({ state }: {
+        state: any;
+    }) => any;
+    assertAcceptingOffers: ({ state }: {
+        state: any;
+    }) => void;
+    exitAllSeats: ({ state }: {
+        state: any;
+    }, completion: any) => void;
+    failAllSeats: ({ state }: {
+        state: any;
+    }, reason: any) => void;
+    stopAcceptingOffers: ({ state }: {
+        state: any;
+    }) => void;
+    makeUserSeat: ({ state, facets: { helper } }: {
+        state: any;
+        facets: {
+            helper: any;
+        };
+    }, invitationHandle: any, initialAllocation: any, proposal: any, offerArgs?: undefined) => 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;
+    }>;
+    makeNoEscrowSeat: ({ state, facets: { helper } }: {
+        state: any;
+        facets: {
+            helper: any;
+        };
+    }, initialAllocation: any, proposal: any, exitObj: any, seatHandle: any) => 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;
+    }>;
+    getOfferFilter: ({ state }: {
+        state: any;
+    }) => any;
+    setOfferFilter: ({ state }: {
+        state: any;
+    }, strings: any) => void;
+    isBlocked: ({ state }: {
+        state: any;
+    }, string: any) => any;
+}>;
+export type ImmutableState = Readonly<{
+    publicFacet: unknown;
+    handlerOfferObj: unknown;
+}>;
+export type MutableState = {
+    offerFilterStrings: string[];
+};
+export type State = MutableState & ImmutableState;
+export type MethodContext = {
+    state: State;
+};
+import type { Baggage } from '@agoric/vat-data';
+import type { SeatHandle } from '../internal-types.js';
+import type { ZoeSeatAdmin } from '../internal-types.js';
+import type { WeakMapStore } from '@agoric/store';
+//# sourceMappingURL=instanceAdminStorage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instanceAdminStorage.d.ts","sourceRoot":"","sources":["instanceAdminStorage.js"],"names":[],"mappings":"AA0DO,kDADK,OAAO;;;;;;;;;;;;;;GA2DlB;AA0JM,mDAHI,OAAO,4BACP,aAAa,UAAU,EAAE,YAAY,CAAC,IAgCvC,mBAAc,EAAE,8BAAyB,EAAE,cAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQ7D;6BAvDY,QAAQ,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;2BACQ;IACR,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;oBACS,YAAY,GAAG,cAAc;4BAC7B;IACR,KAAK,EAAE,KAAK,CAAC;CACd;6BAjPsB,kBAAkB;gCAEf,sBAAsB;kCACpB,sBAAsB;kCAJtB,eAAe"}

package/src/zoeService/internal-types.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Create a purse for a new issuer
+ */
+export type CreatePurse = (issuer: Issuer, brand: Brand) => ERef<void>;
+/**
+ * Create a purse for a new, local issuer. Used only for ZCFMint issuers.
+ *
+ * Note: in the case of the feeMint, it may have been registered
+ * before with `feeMintAccess`. In that case, we do not create a new
+ * purse, but reuse the existing purse.
+ */
+export type ProvideLocalPurse = (issuer: Issuer, brand: Brand) => Purse;
+/**
+ * Deposits payments or promises for payments according to the
+ * `give` property of the proposal. Using the proposal, creates an
+ * initial allocation including the amount deposited for `give`
+ * keywords and an empty amount for `want` keywords.
+ */
+export type DepositPayments = (proposal: ProposalRecord, payments: PaymentPKeywordRecord) => Promise<Allocation>;
+export type InitInstanceAdmin = (instance: Instance, InstanceAdmin: InstanceAdmin) => void;
+export type GetInstanceAdmin = (instance: Instance) => InstanceAdmin;
+export type DeleteInstanceAdmin = (instance: Instance) => void;
+/**
+ * Assert the installation is known, and return the bundle/bundlecap and
+ * installation
+ */
+export type UnwrapInstallation = (installationP: ERef<Installation>) => ERef<{
+    bundle?: SourceBundle;
+    bundleCap?: BundleCap;
+    bundleID?: BundleID;
+    installation: Installation;
+}>;
+export type GetIssuerRecords = () => IssuerRecords;
+export type ZoeInstanceStorageManager = {
+    getTerms: () => AnyTerms;
+    getIssuers: () => IssuerKeywordRecord;
+    getBrands: () => BrandKeywordRecord;
+    saveIssuer: ZCF["saveIssuer"];
+    makeZoeMint: MakeZoeMint;
+    registerFeeMint: RegisterFeeMint;
+    getInstanceRecord: () => InstanceRecord;
+    getIssuerRecords: GetIssuerRecords;
+    initInstanceAdmin: InitInstanceAdmin;
+    deleteInstanceAdmin: DeleteInstanceAdmin;
+    makeInvitation: ZoeInstanceAdminMakeInvitation;
+    getInvitationIssuer: () => Issuer;
+    /**
+     * of CreateVatResults
+     */
+    getRoot: () => object;
+    /**
+     * of CreateVatResults
+     */
+    getAdminNode: () => VatAdminFacet;
+};
+/**
+ * Create a storage manager for a particular contract instance. The
+ * ZoeInstanceStorageManager encapsulates access to the
+ * issuerStorage and escrowStorage from Zoe, and stores the
+ * instance-specific terms
+ */
+export type MakeZoeInstanceStorageManager = (installation: Installation, customTerms: object, uncleanIssuerKeywordRecord: IssuerKeywordRecord, instance: Instance, contractBundleCap: BundleCap, instanceLabel: string) => Promise<ZoeInstanceStorageManager>;
+export type GetBundleCapForID = (id: BundleID) => Promise<BundleCap>;
+export type ZoeStorageManager = {
+    makeZoeInstanceStorageManager: MakeZoeInstanceStorageManager;
+    getAssetKindByBrand: GetAssetKindByBrand;
+    depositPayments: DepositPayments;
+    invitationIssuer: Issuer<"set">;
+    installBundle: InstallBundle;
+    installBundleID: InstallBundleID;
+    getBundleIDFromInstallation: GetBundleIDFromInstallation;
+    getPublicFacet: GetPublicFacet;
+    getBrands: GetBrands;
+    getIssuers: GetIssuers;
+    getTerms: GetTerms;
+    getOfferFilter: (instance: Instance<any>) => string[];
+    setOfferFilter: (instance: Instance<any>, strings: string[]) => any;
+    getInstallationForInstance: (instance: Instance<any>) => Promise<Installation>;
+    getInstanceAdmin: GetInstanceAdmin;
+    unwrapInstallation: UnwrapInstallation;
+    getProposalShapeForInvitation: (invitationHandle: InvitationHandle) => Pattern | undefined;
+};
+/**
+ * Use VatAdminSvc to create a new vat, but only with the code of the
+ * ZCF bundle
+ */
+export type CreateZCFVat = (contractBundleCap: BundleCap, contractLabel: string) => Promise<CreateVatResults>;
+export type GetFeeIssuerKit = (feeMintAccess: FeeMintAccess) => IssuerKit<"nat">;
+import type { Issuer } from '@agoric/ertp';
+import type { Brand } from '@agoric/ertp';
+import type { ERef } from '@agoric/vow';
+import type { Purse } from '@agoric/ertp';
+import type { ProposalRecord } from '@agoric/zoe';
+import type { PaymentPKeywordRecord } from './types.js';
+import type { Allocation } from '../types-index.js';
+import type { Instance } from '@agoric/zoe';
+import type { InstanceAdmin } from '../internal-types.js';
+import type { Installation } from '@agoric/zoe';
+import type { SourceBundle } from './types.js';
+import type { BundleCap } from '@agoric/swingset-vat';
+import type { BundleID } from '@agoric/swingset-vat/src/controller/bundle-handler.js';
+import type { IssuerRecords } from '../internal-types.js';
+import type { AnyTerms } from '../types.js';
+import type { IssuerKeywordRecord } from '@agoric/zoe';
+import type { BrandKeywordRecord } from '../types.js';
+import type { ZCF } from '@agoric/zoe';
+import type { MakeZoeMint } from '../internal-types.js';
+import type { RegisterFeeMint } from '../internal-types.js';
+import type { InstanceRecord } from './utils.js';
+import type { ZoeInstanceAdminMakeInvitation } from '../internal-types.js';
+import type { VatAdminFacet } from '@agoric/swingset-vat';
+import type { GetAssetKindByBrand } from '../internal-types.js';
+import type { InstallBundle } from './types.js';
+import type { InstallBundleID } from './types.js';
+import type { GetBundleIDFromInstallation } from './types.js';
+import type { GetPublicFacet } from './utils.js';
+import type { GetBrands } from './types.js';
+import type { GetIssuers } from './types.js';
+import type { GetTerms } from './utils.js';
+import type { InvitationHandle } from '../types.js';
+import type { Pattern } from '@agoric/swingset-liveslots';
+import type { CreateVatResults } from '@agoric/swingset-vat';
+import type { FeeMintAccess } from './types.js';
+import type { IssuerKit } from '@agoric/ertp';
+//# sourceMappingURL=internal-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"internal-types.d.ts","sourceRoot":"","sources":["internal-types.js"],"names":[],"mappings":";;;mCA2BW,MAAM,SACN,KAAK,KACH,KAAK,IAAI,CAAC;;;;;;;;yCAWZ,MAAM,SACN,KAAK,KACH,KAAK;;;;;;;yCAUP,cAAc,YACd,qBAAqB,KACnB,OAAO,CAAC,UAAU,CAAC;2CAKrB,QAAQ,iBACR,aAAa,KACX,IAAI;0CAKN,QAAQ,KACN,aAAa;6CAKf,QAAQ,KACN,IAAI;;;;;iDASN,KAAK,YAAY,CAAC,KAChB,KAAK;IACb,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAC,YAAY,CAAA;CAC1B,CAAC;qCAMQ,aAAa;;cAKZ,MAAM,QAAQ;gBACd,MAAM,mBAAmB;eACzB,MAAM,kBAAkB;gBACxB,GAAG,CAAC,YAAY,CAAC;iBACjB,WAAW;qBACX,eAAe;uBACf,MAAM,cAAc;sBACpB,gBAAgB;uBAChB,iBAAiB;yBACjB,mBAAmB;oBACnB,8BAA8B;yBAC9B,MAAM,MAAM;;;;aACZ,MAAM,MAAM;;;;kBACZ,MAAM,aAAa;;;;;;;;2DAUtB,YAAY,eACZ,MAAM,8BACN,mBAAmB,YACnB,QAAQ,qBACR,SAAS,iBACT,MAAM,KACJ,OAAO,CAAC,yBAAyB,CAAC;qCAKpC,QAAQ,KACN,OAAO,CAAC,SAAS,CAAC;;mCAKjB,6BAA6B;yBAC7B,mBAAmB;qBACnB,eAAe;sBACf,OAAO,KAAK,CAAC;mBACb,aAAa;qBACb,eAAe;iCACf,2BAA2B;oBAC3B,cAAc;eACd,SAAS;gBACT,UAAU;cACV,QAAQ;oBACR,CAAC,QAAQ,EAAE,SAAS,GAAG,CAAC,KAAK,MAAM,EAAE;oBACrC,CAAC,QAAQ,EAAE,SAAS,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,GAAG;gCACnD,CAAC,QAAQ,EAAE,SAAS,GAAG,CAAC,KAAK,OAAO,CAAC,YAAY,CAAC;sBAClD,gBAAgB;wBAChB,kBAAkB;mCAClB,CAAC,gBAAgB,EAAE,gBAAgB,KAAK,OAAO,GAAG,SAAS;;;;;;+CAQ9D,SAAS,iBACT,MAAM,KACJ,OAAO,CAAC,gBAAgB,CAAC;8CAK3B,aAAa,KACX,UAAU,KAAK,CAAC;4BA/JqB,cAAc;2BAAd,cAAc;0BAQzC,aAAa;2BARc,cAAc;oCAFmB,aAAa;2CANyD,YAAY;gCAexI,mBAAmB;8BATmC,aAAa;mCAKjB,sBAAsB;kCALlB,aAAa;kCANyD,YAAY;+BAE1H,sBAAsB;8BAYtC,uDAAuD;mCAHH,sBAAsB;8BAJpC,aAAa;yCADK,aAAa;wCAC/B,aAAa;yBADK,aAAa;iCAGlE,sBAAsB;qCAClB,sBAAsB;oCATvB,YAAY;oDAUkC,sBAAsB;mCAT1D,sBAAsB;yCAU3B,sBAAsB;mCAZ6F,YAAY;qCAAZ,YAAY;iDAAZ,YAAY;oCAGpI,YAAY;+BAH4G,YAAY;gCAAZ,YAAY;8BAI1I,YAAY;sCAG0B,aAAa;6BAMpD,4BAA4B;sCARnB,sBAAsB;mCALgG,YAAY;+BAQnH,cAAc"}

package/src/zoeService/invitationQueries.d.ts

@@ -0,0 +1,9 @@
+export function makeInvitationQueryFns(invitationIssuer: any): {
+    getInstance: GetInstance;
+    getInstallation: GetInstallation;
+    getInvitationDetails: GetInvitationDetails;
+};
+import type { GetInstance } from './types.js';
+import type { GetInstallation } from './types.js';
+import type { GetInvitationDetails } from './types.js';
+//# sourceMappingURL=invitationQueries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"invitationQueries.d.ts","sourceRoot":"","sources":["invitationQueries.js"],"names":[],"mappings":"AASO;;;;EA+BN;iCAnC6B,YAAY;qCACR,YAAY;0CAFP,YAAY"}

package/src/zoeService/makeInvitation.d.ts

@@ -0,0 +1,9 @@
+export function prepareInvitationKit(baggage: Baggage, shutdownZoeVat?: ShutdownWithFailure | undefined): {
+    invitationIssuer: import("@agoric/ertp").Issuer<"set", InvitationDetails>;
+    invitationKit: IssuerKit<"set", InvitationDetails>;
+};
+import type { Baggage } from '@agoric/vat-data';
+import type { ShutdownWithFailure } from '@agoric/swingset-vat';
+import type { InvitationDetails } from '../types-index.js';
+import type { IssuerKit } from '@agoric/ertp';
+//# sourceMappingURL=makeInvitation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makeInvitation.d.ts","sourceRoot":"","sources":["makeInvitation.js"],"names":[],"mappings":"AAqBO,8CAHI,OAAO,mBACP,mBAAmB,GAAG,SAAS;;;EA+BzC;6BA5CyB,kBAAkB;yCACN,sBAAsB;uCACxB,mBAAmB;+BAC3B,cAAc"}

package/src/zoeService/offer/burnInvitation.d.ts

@@ -0,0 +1,11 @@
+export function burnInvitation<K extends AssetKind>(invitationIssuer: Issuer<K>, invitation: ERef<Payment<K>>): Promise<{
+    instanceHandle: Instance;
+    invitationHandle: InvitationHandle;
+}>;
+import type { AssetKind } from '@agoric/ertp';
+import type { Issuer } from '@agoric/ertp';
+import type { Payment } from '@agoric/ertp';
+import type { ERef } from '@agoric/vow';
+import type { Instance } from '@agoric/zoe';
+import type { InvitationHandle } from '../zoe.js';
+//# sourceMappingURL=burnInvitation.d.ts.map

package/src/zoeService/offer/burnInvitation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"burnInvitation.d.ts","sourceRoot":"","sources":["burnInvitation.js"],"names":[],"mappings":"AAwBO,+BARkB,CAAC,SAAb,SAAW,oBACb,OAAO,CAAC,CAAC,cACT,KAAK,QAAQ,CAAC,CAAC,CAAC,GACd,OAAO,CAAC;IAChB,cAAc,EAAE,QAAQ,CAAC;IACzB,gBAAgB,EAAE,gBAAgB,CAAC;CACpC,CAAC,CA0BJ;+BA5C2B,cAAc;4BAGjB,cAAc;6BACb,cAAc;0BACjB,aAAa;8BAHT,aAAa;sCADL,WAAW"}

package/src/zoeService/offer/offer.d.ts

@@ -0,0 +1,3 @@
+export function makeOfferMethod(offerDataAccess: any): Offer;
+import type { Offer } from '@agoric/zoe';
+//# sourceMappingURL=offer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"offer.d.ts","sourceRoot":"","sources":["offer.js"],"names":[],"mappings":"AAaO,6DA0DN;2BA7DuB,aAAa"}

package/src/zoeService/originalZoeSeat.d.ts

@@ -0,0 +1,36 @@
+export namespace coreUserSeatMethods {
+    let getProposal: import("@endo/patterns").MethodGuard;
+    let getPayouts: import("@endo/patterns").MethodGuard;
+    let getPayout: import("@endo/patterns").MethodGuard;
+    let getOfferResult: import("@endo/patterns").MethodGuard;
+    let hasExited: import("@endo/patterns").MethodGuard;
+    let numWantsSatisfied: import("@endo/patterns").MethodGuard;
+    let getFinalAllocation: import("@endo/patterns").MethodGuard;
+    let getExitSubscriber: import("@endo/patterns").MethodGuard;
+}
+export const ZoeUserSeatShape: import("@endo/patterns").InterfaceGuard<{
+    tryExit: import("@endo/patterns").MethodGuard;
+    getProposal: import("@endo/patterns").MethodGuard;
+    getPayouts: import("@endo/patterns").MethodGuard;
+    getPayout: import("@endo/patterns").MethodGuard;
+    getOfferResult: import("@endo/patterns").MethodGuard;
+    hasExited: import("@endo/patterns").MethodGuard;
+    numWantsSatisfied: import("@endo/patterns").MethodGuard;
+    getFinalAllocation: import("@endo/patterns").MethodGuard;
+    getExitSubscriber: import("@endo/patterns").MethodGuard;
+}>;
+export namespace OriginalZoeSeatIKit {
+    export let zoeSeatAdmin: import("@endo/patterns").InterfaceGuard<{
+        replaceAllocation: import("@endo/patterns").MethodGuard;
+        exit: import("@endo/patterns").MethodGuard;
+        fail: import("@endo/patterns").MethodGuard;
+        resolveExitAndResult: import("@endo/patterns").MethodGuard;
+        getExitSubscriber: import("@endo/patterns").MethodGuard;
+        finalPayouts: import("@endo/patterns").MethodGuard;
+    }>;
+    export { ZoeUserSeatShape as userSeat };
+}
+export function declareOldZoeSeatAdminKind(baggage: Baggage, makeDurablePublishKit: () => PublishKit<any>): void;
+import type { Baggage } from '@agoric/vat-data';
+import type { PublishKit } from '@agoric/notifier';
+//# sourceMappingURL=originalZoeSeat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"originalZoeSeat.d.ts","sourceRoot":"","sources":["originalZoeSeat.js"],"names":[],"mappings":";;;;;;;;;;AAwCA;;;;;;;;;;GAGG;;;;;;;;;;;;AA+CI,oDAHI,OAAO,yBACP,MAAM,WAAW,GAAG,CAAC,QAoR/B;6BA3VyB,kBAAkB;gCACf,kBAAkB"}