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

package/src/typeGuards.d.ts

@@ -0,0 +1,169 @@
+export const KeywordShape: import("@endo/patterns").Matcher;
+export const InvitationHandleShape: import("@endo/patterns").Matcher;
+export const InvitationShape: import("@endo/patterns").Matcher;
+export const InstanceHandleShape: import("@endo/patterns").Matcher;
+export const InstallationShape: import("@endo/patterns").Matcher;
+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;
+export const IssuerRecordShape: import("@endo/patterns").Matcher;
+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;
+export const InvitationElementShape: import("@endo/patterns").Matcher;
+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 ZcfMintI: import("@endo/patterns").InterfaceGuard<{
+    getIssuerRecord: import("@endo/patterns").MethodGuard;
+    mintGains: import("@endo/patterns").MethodGuard;
+    burnLosses: 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;
+}>;
+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: any;
+}
+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":"AAgBA,4DAAuC;AAEvC,qEAAqE;AACrE,+DAAyD;AACzD,mEAAiE;AACjE,iEAA6D;AAC7D,yDAA6C;AAE7C,wEAA8E;AAC9E,+EAGE;AACF,0EAGE;AACF,wEAA8E;AAC9E,yEAGE;AACF,uEAA4E;AAE5E,iEAOE;;;;;;;;;;AAaF,kEAAiD;AAE1C,6EAA4D;AACnE,0DAAmD;;;;;;AA0BnD,2BAA2B;AAC3B,6DAAsE;AAEtE,kEAIG;AAEI,uDAGN;AAMM,uCAHI,QAAQ,0BAMlB;AAMM,8CAHI,QAAQ,iCAMlB;AAED,sEAKG;AAEH;;GAEG;AAEH,0EAKE;AAEF,4DAAmD;AACnD;;;;GAIG;AAEH;;;;GASG;AAEH,kEAA+D;AAE/D;;GAEG;AAEH,+DAAsD;AACtD,kEAA+D;AAC/D;;;;;;;;;;;;;;;;;GAkCG;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDH,8DAAuD;AACvD,2DAGE;AAEF,0EAUE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DF;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;;;GAIG;AAEH,6DASE;AAEF;;GAKG;;;;;4BAjYI,cAAc"}

package/src/types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * A type constructor for an opaque type
+ * identified by the H string. This uses an intersection type
+ * ('MyHandle' & {}) to tag the handle's type even though the actual
+ * value is just an empty object.
+ */
+type Handle<H extends string> = H & typeof import("@endo/marshal").Remotable;
+type Keyword = string;
+/**
+ * - an opaque handle for an invitation
+ */
+type InvitationHandle = Handle<'Invitation'>;
+type IssuerKeywordRecord = Record<Keyword, Issuer<any>>;
+type IssuerPKeywordRecord = {
+    [x: string]: ERef<globalThis.Issuer<any>>;
+};
+type BrandKeywordRecord = Record<Keyword, Brand<any>>;
+type StandardTerms = {
+    /**
+     * - record with
+     * keywords keys, issuer values
+     */
+    issuers: IssuerKeywordRecord;
+    /**
+     * - record with keywords
+     * keys, brand values
+     */
+    brands: BrandKeywordRecord;
+};
+type AnyTerms = StandardTerms & Record<string, any>;
+type InstanceRecord = {
+    installation: Installation;
+    instance: import("./zoeService/utils.js").Instance<any>;
+    /**
+     * - contract parameters
+     */
+    terms: AnyTerms;
+};
+type IssuerRecord<K extends globalThis.AssetKind = globalThis.AssetKind> = {
+    brand: Brand<K>;
+    issuer: Issuer<K>;
+    assetKind: K;
+    displayInfo?: globalThis.DisplayInfo<K> | undefined;
+};
+type Allocation<K extends globalThis.AssetKind = globalThis.AssetKind> = AmountKeywordRecord;
+//# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";;;;;;gCAMa,CAAC,2CAAoC;eAOrC,MAAM;;;;wBACN,OAAO,YAAY,CAAC;2BACpB,OAAO,OAAO,EAAE,OAAO,GAAG,CAAC,CAAC;;;;0BAE5B,OAAO,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC;;;;;;aAK1B,mBAAmB;;;;;YAEnB,kBAAkB;;gBAGnB,aAAa,GAAG,OAAO,MAAM,EAAE,GAAG,CAAC;;kBAGlC,YAAY;cACZ,OAAO,uBAAuB,EAAE,QAAQ,CAAC,GAAG,CAAC;;;;WAC7C,QAAQ;;;WAMR,MAAM,CAAC,CAAC;YACR,OAAO,CAAC,CAAC;eACT,CAAC;;;yEAGF,mBAAmB"}

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":"AAMO,qEAcN"}

package/src/zoeService/escrowStorage.d.ts

@@ -0,0 +1,7 @@
+export function provideEscrowStorage(baggage: import('@agoric/vat-data').Baggage): {
+    createPurse: CreatePurse;
+    provideLocalPurse: ProvideLocalPurse;
+    withdrawPayments: WithdrawPayments;
+    depositPayments: DepositPayments;
+};
+//# 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":"AAiBO,8CAFI,OAAO,kBAAkB,EAAE,OAAO;;;;;EA8G5C"}

package/src/zoeService/feeMint.d.ts

@@ -0,0 +1,23 @@
+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 {import('@agoric/vat-data').Baggage} zoeBaggage
+ * @param {FeeIssuerConfig} feeIssuerConfig
+ * @param {import('@agoric/swingset-vat').ShutdownWithFailure} shutdownZoeVat
+ */
+export function prepareFeeMint(zoeBaggage: import('@agoric/vat-data').Baggage, feeIssuerConfig: FeeIssuerConfig, shutdownZoeVat: import('@agoric/swingset-vat').ShutdownWithFailure): import("@endo/exo").GuardedKit<{
+    feeMint: {
+        getFeeIssuerKit(allegedFeeMintAccess: any): globalThis.IssuerKit<"nat">;
+        getFeeIssuer(): globalThis.Issuer<"nat">;
+        getFeeBrand(): globalThis.Brand<"nat">;
+    };
+    feeMintAccess: {};
+}>;
+//# 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":";;;;;;;;;AA4BA;;;;GAIG;AACH,2CAJW,OAAO,kBAAkB,EAAE,OAAO,mBAClC,eAAe,kBACf,OAAO,sBAAsB,EAAE,mBAAmB;;;;;;;GA2D5D"}

package/src/zoeService/installationStorage.d.ts

@@ -0,0 +1,20 @@
+export function makeInstallationStorage(getBundleCapForID: GetBundleCapForID, zoeBaggage: Baggage): import("@endo/exo").Guarded<{
+    installBundle(allegedBundle: any, bundleLabel: any): 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): any;
+}>;
+export type BundleCap = import('@agoric/swingset-vat').BundleCap;
+export type BundleID = import('@agoric/swingset-vat').BundleID;
+import type { Baggage } from '@agoric/vat-data';
+//# 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":"AAuBO,2DAHI,iBAAiB;;;;;;;;;;;;;;;GAgJ3B;wBArJc,OAAO,sBAAsB,EAAE,SAAS;uBACxC,OAAO,sBAAsB,EAAE,QAAQ;6BAC3B,kBAAkB"}

package/src/zoeService/instanceAdminStorage.d.ts

@@ -0,0 +1,103 @@
+export function makeInstanceAdminStorage(baggage: import('@agoric/vat-data').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<any>;
+        deleteInstanceAdmin(instance: any): any;
+    };
+}>;
+export function makeInstanceAdminMaker(zoeBaggage: import('@agoric/vat-data').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;
+};
+//# 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":"AAoDO,kDADK,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;;;;GA2D7C;AA0JM,mDAHI,OAAO,kBAAkB,EAAE,OAAO,4BAClC,aAAa,UAAU,EAAE,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwChD;6BAvDY,SAAS;IACrB,WAAe,EAAE,OAAO,CAAC;IACzB,eAAmB,EAAE,OAAO,CAAC;CAC1B,CAAC;2BACQ;IACZ,kBAAsB,EAAE,MAAM,EAAE,CAAC;CAC9B;oBACS,YAAY,GAAG,cAAc;4BAC7B;IACZ,KAAS,EAAE,KAAK,CAAC;CACd"}

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

@@ -0,0 +1,90 @@
+/**
+ * Create a purse for a new issuer
+ */
+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.
+ */
+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.
+ */
+type DepositPayments = (proposal: ProposalRecord, payments: PaymentPKeywordRecord) => Promise<Allocation>;
+type InitInstanceAdmin = (instance: Instance, InstanceAdmin: InstanceAdmin) => void;
+type GetInstanceAdmin = (instance: Instance) => InstanceAdmin;
+type DeleteInstanceAdmin = (instance: Instance) => void;
+/**
+ * Assert the installation is known, and return the bundle/bundlecap and
+ * installation
+ */
+type UnwrapInstallation = (installationP: ERef<Installation<any>>) => ERef<{
+    bundle?: SourceBundle | undefined;
+    bundleCap?: any;
+    bundleID?: string | undefined;
+    installation: Installation;
+}>;
+type GetIssuerRecords = () => IssuerRecords;
+type ZoeInstanceStorageManager = {
+    getTerms: InstanceStateGetTerms;
+    getIssuers: InstanceRecordGetIssuers;
+    getBrands: InstanceRecordGetBrands;
+    saveIssuer: ZCF['saveIssuer'];
+    makeZoeMint: MakeZoeMint;
+    registerFeeMint: RegisterFeeMint;
+    getInstanceRecord: GetInstanceRecord;
+    getIssuerRecords: GetIssuerRecords;
+    initInstanceAdmin: InitInstanceAdmin;
+    deleteInstanceAdmin: DeleteInstanceAdmin;
+    makeInvitation: ZoeInstanceAdminMakeInvitation;
+    getInvitationIssuer: () => Issuer;
+    /**
+     * of CreateVatResults
+     */
+    getRoot: () => object;
+    /**
+     * of CreateVatResults
+     */
+    getAdminNode: () => import('@agoric/swingset-vat').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
+ */
+type MakeZoeInstanceStorageManager = (instanceBaggage: import('@agoric/vat-data').Baggage, installation: Installation, customTerms: object, uncleanIssuerKeywordRecord: IssuerKeywordRecord, instance: Instance, contractBundleCap: any, instanceLabel: string) => Promise<ZoeInstanceStorageManager>;
+type GetBundleCapForID = (id: string) => Promise<any>;
+type GetProposalShapeForInvitation = (invitationHandle: InvitationHandle) => Pattern | undefined;
+type ZoeStorageManager = {
+    makeZoeInstanceStorageManager: MakeZoeInstanceStorageManager;
+    getAssetKindByBrand: GetAssetKindByBrand;
+    depositPayments: DepositPayments;
+    invitationIssuer: Issuer<'set'>;
+    installBundle: InstallBundle;
+    installBundleID: InstallBundleID;
+    getBundleIDFromInstallation: GetBundleIDFromInstallation;
+    getPublicFacet: import('./utils.js').GetPublicFacet;
+    getBrands: GetBrands;
+    getIssuers: GetIssuers;
+    getTerms: import('./utils.js').GetTerms;
+    getOfferFilter: GetOfferFilter;
+    setOfferFilter: SetOfferFilter;
+    getInstallationForInstance: GetInstallationForInstance;
+    getInstanceAdmin: GetInstanceAdmin;
+    unwrapInstallation: UnwrapInstallation;
+    getProposalShapeForInvitation: GetProposalShapeForInvitation;
+};
+/**
+ * Use VatAdminSvc to create a new vat, but only with the code of the
+ * ZCF bundle
+ */
+type CreateZCFVat = (contractBundleCap: any, contractLabel: string) => Promise<import('@agoric/swingset-vat').CreateVatResults>;
+type GetFeeIssuerKit = (feeMintAccess: FeeMintAccess) => IssuerKit<'nat'>;
+//# 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":";;;4BAMW,MAAM,SACN,KAAK;;;;;;;;kCAYL,MAAM,SACN,KAAK,KACH,KAAK;;;;;;;kCAUP,cAAc,YACd,qBAAqB,KACnB,QAAQ,UAAU,CAAC;oCAKrB,QAAQ,iBACR,aAAa,KACX,IAAI;mCAKN,QAAQ,KACN,aAAa;sCAKf,QAAQ,KACN,IAAI;;;;;;;;;kBAcC,YAAY;;;;cAYhB,qBAAqB;gBACrB,wBAAwB;eACxB,uBAAuB;gBACvB,GAAG,CAAC,YAAY,CAAC;iBACjB,WAAW;qBACX,eAAe;uBACf,iBAAiB;sBACjB,gBAAgB;uBAChB,iBAAiB;yBACjB,mBAAmB;oBACnB,8BAA8B;yBAC9B,MAAM,MAAM;;;;aACZ,MAAM,MAAM;;;;kBACZ,MAAM,OAAO,sBAAsB,EAAE,aAAa;;;;;;;;uDAUrD,OAAO,kBAAkB,EAAE,OAAO,gBAClC,YAAY,eACZ,MAAM,8BACN,mBAAmB,YACnB,QAAQ,yCAER,MAAM,KACJ,QAAQ,yBAAyB,CAAC;;wDAWpC,gBAAgB,KACd,OAAO,GAAG,SAAS;;mCAKlB,6BAA6B;yBAC7B,mBAAmB;qBACnB,eAAe;sBACf,OAAO,KAAK,CAAC;mBACb,aAAa;qBACb,eAAe;iCACf,2BAA2B;oBAC3B,OAAO,YAAY,EAAE,cAAc;eACnC,SAAS;gBACT,UAAU;cACV,OAAO,YAAY,EAAE,QAAQ;oBAC7B,cAAc;oBACd,cAAc;gCACd,0BAA0B;sBAC1B,gBAAgB;wBAChB,kBAAkB;mCAClB,6BAA6B;;;;;;4DAShC,MAAM,KACJ,QAAQ,OAAO,sBAAsB,EAAE,gBAAgB,CAAC;uCAK1D,aAAa,KACX,UAAU,KAAK,CAAC"}

package/src/zoeService/invitationQueries.d.ts

@@ -0,0 +1,6 @@
+export function makeInvitationQueryFns(invitationIssuer: any): {
+    getInstance: GetInstance;
+    getInstallation: GetInstallation;
+    getInvitationDetails: GetInvitationDetails;
+};
+//# 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":"AAKO;;;;EA+BN"}

package/src/zoeService/makeInvitation.d.ts

@@ -0,0 +1,5 @@
+export function prepareInvitationKit(baggage: import('@agoric/vat-data').Baggage, shutdownZoeVat?: import('@agoric/swingset-vat').ShutdownWithFailure | undefined): {
+    invitationIssuer: globalThis.Issuer<"set">;
+    invitationKit: globalThis.IssuerKit<"set">;
+};
+//# 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":"AAgBO,8CAHI,OAAO,kBAAkB,EAAE,OAAO,mBAClC,OAAO,sBAAsB,EAAE,mBAAmB,GAAG,SAAS;;;EA6BxE"}

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

@@ -0,0 +1,5 @@
+export function burnInvitation(invitationIssuer: Issuer, invitation: ERef<globalThis.Payment>): Promise<{
+    instanceHandle: Instance;
+    invitationHandle: InvitationHandle;
+}>;
+//# 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":"AAgBO,iDAPI,MAAM,yCAEJ,QAAQ;IACpB,cAAkB,EAAE,QAAQ,CAAC;IAC7B,gBAAoB,EAAE,gBAAgB,CAAC;CACpC,CAAC,CA4BJ"}

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

@@ -0,0 +1,2 @@
+export function makeOfferMethod(offerDataAccess: any): Offer;
+//# 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":"AAgBO,6DA0DN"}

package/src/zoeService/originalZoeSeat.d.ts

@@ -0,0 +1,34 @@
+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: import('@agoric/vat-data').Baggage, makeDurablePublishKit: () => PublishKit<any>): void;
+//# 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":";;;;;;;;;;AA8BA;;;;;;;;;;GAGG;;;;;;;;;;;;AA+CI,oDAHI,OAAO,kBAAkB,EAAE,OAAO,yBAClC,MAAM,WAAW,GAAG,CAAC,QAiR/B"}

package/src/zoeService/startInstance.d.ts

@@ -0,0 +1,4 @@
+export function makeStartInstance(startInstanceAccess: Pick<ZoeStorageManager, 'makeZoeInstanceStorageManager' | 'unwrapInstallation'>, getZcfBundleCapP: () => any, getBundleCapByIdNow: (id: string) => BundleCap, zoeBaggage: Baggage): import('./utils.js').StartInstance;
+export type BundleCap = import('@agoric/swingset-vat').BundleCap;
+import type { Baggage } from '@agoric/vat-data';
+//# sourceMappingURL=startInstance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"startInstance.d.ts","sourceRoot":"","sources":["startInstance.js"],"names":[],"mappings":"AAoCO,uDANI,KAAK,iBAAiB,EAAE,+BAA+B,GAAG,oBAAoB,CAAC,oDAE/E,CAAC,EAAE,EAAE,MAAM,KAAK,SAAS,wBAEvB,OAAO,YAAY,EAAE,aAAa,CAiW9C;wBA1Wc,OAAO,sBAAsB,EAAE,SAAS;6BAD5B,kBAAkB"}