@agoric/vats 0.15.2-dev-ecf2d8e.0 → 0.15.2-other-dev-70beeb7.0

package/src/mintHolder.js

@@ -12,9 +12,9 @@ import {
 /**
  * @template {AssetKind} K
  * @typedef {{
- *   keyword: string;
- *   assetKind: K;
- *   displayInfo: DisplayInfo;
+ *   keyword: string,
+ *   assetKind: K,
+ *   displayInfo: DisplayInfo,
  * }} IssuerInfo<K>
  */
 
@@ -32,22 +32,17 @@ function provideIssuerKit(zcf, baggage) {
   }
 }
 
-/** @type {ContractMeta} */
-export const meta = {
-  upgradability: 'canUpgrade',
-};
-harden(meta);
-
 /**
- * This contract holds one mint; it basically wraps makeIssuerKit in its own
- * contract, and hence in its own vat.
+ * This contract holds one mint; it basically wraps
+ * makeIssuerKit in its own contract, and hence in
+ * its own vat.
  *
  * @template {AssetKind} K
  * @param {ZCF<IssuerInfo<K>>} zcf
  * @param {undefined} _privateArgs
  * @param {Baggage} instanceBaggage
  */
-export const start = (zcf, _privateArgs, instanceBaggage) => {
+export const prepare = (zcf, _privateArgs, instanceBaggage) => {
   const { mint, issuer } = provideIssuerKit(zcf, instanceBaggage);
 
   return {
@@ -55,4 +50,4 @@ export const start = (zcf, _privateArgs, instanceBaggage) => {
     creatorFacet: mint,
   };
 };
-harden(start);
+harden(prepare);

package/src/nameHub.d.ts

@@ -1,22 +1,6 @@
 export namespace NameHubIKit {
-    let nameHub: import("@endo/patterns").InterfaceGuard<{
-        has: import("@endo/patterns").MethodGuard;
-        lookup: import("@endo/patterns").MethodGuard;
-        entries: import("@endo/patterns").MethodGuard;
-        values: import("@endo/patterns").MethodGuard;
-        keys: import("@endo/patterns").MethodGuard;
-    }>;
-    let nameAdmin: import("@endo/patterns").InterfaceGuard<{
-        provideChild: import("@endo/patterns").MethodGuard;
-        reserve: import("@endo/patterns").MethodGuard;
-        default: import("@endo/patterns").MethodGuard;
-        set: import("@endo/patterns").MethodGuard;
-        onUpdate: import("@endo/patterns").MethodGuard;
-        update: import("@endo/patterns").MethodGuard;
-        lookupAdmin: import("@endo/patterns").MethodGuard;
-        delete: import("@endo/patterns").MethodGuard;
-        readonly: import("@endo/patterns").MethodGuard;
-    }>;
+    const nameHub: import("@endo/patterns").InterfaceGuard;
+    const nameAdmin: import("@endo/patterns").InterfaceGuard;
 }
 export function prepareMixinMyAddress(zone: import('@agoric/zone').Zone): (nameAdmin: import('./types.js').NameAdmin, address: string) => import("@agoric/internal/src/callback.js").Farable<import("./types.js").MyAddressNameAdmin>;
 export function prepareNameHubKit(zone: import('@agoric/zone').Zone): () => import('./types').NameHubKit;

package/src/nameHub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nameHub.d.ts","sourceRoot":"","sources":["nameHub.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAgDO,4CADK,OAAO,cAAc,EAAE,IAAI,eA4B1B,OAAO,YAAY,EAAE,SAAS,WAC9B,MAAM,iGAalB;AA4CM,wCAFI,OAAO,cAAc,EAAE,IAAI,SAcnB,OAAO,SAAS,EAAE,UAAU,CA0N9C;AA1NY,kCAAM,OAAO,SAAS,EAAE,UAAU,CAAA"}
+{"version":3,"file":"nameHub.d.ts","sourceRoot":"","sources":["nameHub.js"],"names":[],"mappings":";;;;AAgDO,4CADK,OAAO,cAAc,EAAE,IAAI,eAwB1B,OAAO,YAAY,EAAE,SAAS,WAC9B,MAAM,iGAalB;AA4CM,wCAFI,OAAO,cAAc,EAAE,IAAI,SAcnB,OAAO,SAAS,EAAE,UAAU,CAqN9C;AArNY,kCAAM,OAAO,SAAS,EAAE,UAAU,CAAA"}

package/src/nameHub.js

@@ -3,14 +3,14 @@
 import { assert, NonNullish } from '@agoric/assert';
 import { E } from '@endo/far';
 import { makePromiseKit } from '@endo/promise-kit';
-import { M, getInterfaceGuardPayload } from '@endo/patterns';
+import { M } from '@agoric/store';
 
 import './types.js';
 import {
   makeSyncMethodCallback,
   prepareGuardedAttenuator,
 } from '@agoric/internal/src/callback.js';
-import { makeHeapZone } from '@agoric/zone';
+import { heapZone } from '@agoric/zone';
 import { deeplyFulfilled } from '@endo/marshal';
 
 const { Fail, quote: q } = assert;
@@ -48,14 +48,10 @@ export const NameHubIKit = harden({
 /** @param {import('@agoric/zone').Zone} zone */
 export const prepareMixinMyAddress = zone => {
   const MixinI = M.interface('MyAddressNameAdmin', {
-    ...getInterfaceGuardPayload(NameHubIKit.nameAdmin).methodGuards,
+    ...NameHubIKit.nameAdmin.methodGuards,
     getMyAddress: M.call().returns(M.string()),
   });
-  /**
-   * @type {import('@agoric/internal/src/callback.js').MakeAttenuator<
-   *   import('./types.js').MyAddressNameAdmin
-   * >}
-   */
+  /** @type {import('@agoric/internal/src/callback.js').MakeAttenuator<import('./types.js').MyAddressNameAdmin>} */
   const mixin = prepareGuardedAttenuator(zone, MixinI, {
     tag: 'MyAddressNameAdmin',
   });
@@ -111,7 +107,7 @@ const provideWeak = (store, key, make) => {
 
 /**
  * @param {import('./types.js').NameHubUpdateHandler | undefined} updateCallback
- * @param {import('./types.js').NameHub} hub
+ * @param {NameHub} hub
  * @param {unknown} [_newValue]
  */
 const updated = (updateCallback, hub, _newValue = undefined) => {
@@ -126,8 +122,8 @@ const updated = (updateCallback, hub, _newValue = undefined) => {
 };
 
 /**
- * Make two facets of a node in a name hierarchy: the nameHub is read access and
- * the nameAdmin is write access.
+ * Make two facets of a node in a name hierarchy: the nameHub
+ * is read access and the nameAdmin is write access.
  *
  * @param {import('@agoric/zone').Zone} zone
  */
@@ -143,7 +139,7 @@ export const prepareNameHubKit = zone => {
   /** @param {{}} me */
   const my = me => provideWeak(ephemera, me, init1);
 
-  /** @type {() => import('./types').NameHubKit} */
+  /** @type {() => import('./types').NameHubKit } */
   const makeNameHubKit = zone.exoClassKit(
     'NameHubKit',
     NameHubIKit,
@@ -216,7 +212,8 @@ export const prepareNameHubKit = zone => {
           const { keyToAdmin, keyToValue } = this.state;
           if (keyToAdmin.has(key)) {
             const childAdmin = keyToAdmin.get(key);
-            /** @type {import('./types.js').NameHub} */
+            // XXX ts-ignore because @agoric/web-components lint fails
+            /** @type {NameHub} */
             // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
             // @ts-ignore if an admin is present, it should be a namehub
             const childHub = keyToValue.get(key);
@@ -224,7 +221,7 @@ export const prepareNameHubKit = zone => {
           }
           const child = makeNameHubKit();
           await Promise.all(reserved.map(k => child.nameAdmin.reserve(k)));
-          void nameAdmin.update(key, child.nameHub, child.nameAdmin);
+          nameAdmin.update(key, child.nameHub, child.nameAdmin);
           return child;
         },
         async reserve(key) {
@@ -266,7 +263,7 @@ export const prepareNameHubKit = zone => {
               return /** @type {any} */ (keyToValue.get(key));
             }
           }
-          void nameAdmin.update(key, newValue, adminValue);
+          nameAdmin.update(key, newValue, adminValue);
           return newValue;
         },
         set(key, newValue, adminValue) {
@@ -274,7 +271,7 @@ export const prepareNameHubKit = zone => {
           keyToValue.has(key) || Fail`key ${key} is not already initialized`;
 
           const { nameAdmin } = this.facets;
-          void nameAdmin.update(key, newValue, adminValue);
+          nameAdmin.update(key, newValue, adminValue);
         },
         onUpdate(fn) {
           const { state } = this;
@@ -287,13 +284,7 @@ export const prepareNameHubKit = zone => {
           const { keyToPK, keyToAdminPK } = my(this.facets.nameHub);
           const { keyToValue, keyToAdmin, updateCallback } = this.state;
 
-          /**
-           * @type {[
-           *   Map<string, PromiseKit<unknown>>,
-           *   MapStore<string, unknown>,
-           *   unknown,
-           * ][]}
-           */
+          /** @type {[Map<string, PromiseKit<unknown>>, MapStore<string, unknown>, unknown][]} */
           const valueMapEntries = [
             [keyToAdminPK, keyToAdmin, adminValue],
             [keyToPK, keyToValue, newValue],
@@ -364,9 +355,9 @@ export const prepareNameHubKit = zone => {
 };
 
 /**
- * Make two facets of a node in a name hierarchy: the nameHub is read access and
- * the nameAdmin is write access.
+ * Make two facets of a node in a name hierarchy: the nameHub
+ * is read access and the nameAdmin is write access.
  *
  * @returns {import('./types.js').NameHubKit}
  */
-export const makeNameHubKit = prepareNameHubKit(makeHeapZone());
+export const makeNameHubKit = prepareNameHubKit(heapZone);

package/src/proposals/network-proposal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-proposal.d.ts","sourceRoot":"","sources":["network-proposal.js"],"names":[],"mappings":"AAgBO,+CAHI,QAAQ,GAAG,OAAO,kGA2D5B;AAmBM,wJAhBI,eAAe,GAAG;IAC5B,OAAW,EAAE;QAAE,eAAe,EAAE,UAAU,GAAG,CAAC,CAAA;KAAE,CAAC;IACjD,OAAW,EAAE;QAAE,UAAU,EAAE,SAAS,GAAG,CAAC,CAAA;KAAE,CAAC;CACxC;;oBAEqB,YAAY;gBAAU,YAAY;;kBA+D1D;AAEM;;;;;;;;;;;;;;;;;;;;;;EAmBL;iCAjFmB,SAAS,KAAK,UAAU,YAAY,KAAK,KAAK,MAAM;sBAE5D;IACZ,OAAW,EAAE,KAAK,UAAU,CAAC,CAAC;IAC9B,GAAO,EAAE,KAAK,MAAM,CAAC,CAAC;IACtB,YAAgB,EAAE,KAAK,eAAe,GAAG,SAAS,CAAC,CAAC;CACjD"}
+{"version":3,"file":"network-proposal.d.ts","sourceRoot":"","sources":["network-proposal.js"],"names":[],"mappings":"AAgBO,+CAHI,QAAQ,GAAG,OAAO,kGA2D5B;AAgBM,wJAbK,eAAe,GAAG;IAC7B,OAAW,EAAE;QAAE,eAAe,EAAE,UAAU,GAAG,CAAC,CAAA;KAAE,CAAA;IAChD,OAAW,EAAE;QAAE,UAAU,EAAE,SAAS,GAAG,CAAC,CAAA;KAAE,CAAA;CACvC;;oBAGoB,YAAY;gBAAU,YAAY;;kBA2DzD;AAEM;;;;;;;;;;;;;;;;;;;;;;EAmBL;iCA9EoB,SAAS,KAAK,UAAU,YACxB,KAAK,KAAK,MAAM;sBAEzB;IAAE,OAAO,EAAE,KAAK,UAAU,CAAC,CAAC;IAAC,GAAG,EAAE,KAAK,MAAM,CAAC,CAAC;IAAC,YAAY,EAAE,KAAK,eAAe,GAAG,SAAS,CAAC,CAAA;CAAC"}

package/src/proposals/network-proposal.js

@@ -1,11 +1,11 @@
 // @ts-check
 import { E, Far } from '@endo/far';
-import { BridgeId as BRIDGE_ID } from '@agoric/internal';
 import {
   makeLoopbackProtocolHandler,
   makeEchoConnectionHandler,
   makeNonceMaker,
-} from '@agoric/network';
+} from '@agoric/swingset-vat/src/vats/network/index.js';
+import { BridgeId as BRIDGE_ID } from '@agoric/internal';
 
 const NUM_IBC_PORTS_PER_CLIENT = 3;
 const INTERCHAIN_ACCOUNT_CONTROLLER_PORT_PREFIX = 'icacontroller-';
@@ -73,21 +73,18 @@ export const registerNetworkProtocols = async (vats, dibcBridgeManager) => {
 };
 
 /**
- * @param {BootstrapPowers & {
- *   consume: { loadCriticalVat: VatLoader<any> };
- *   produce: { networkVat: Producer<any> };
+ * @param { BootstrapPowers & {
+ *   consume: { loadCriticalVat: VatLoader<any> }
+ *   produce: { networkVat: Producer<any> }
  * }} powers
- * @param {object} options
- * @param {{ networkRef: VatSourceRef; ibcRef: VatSourceRef }} options.options
- *   // TODO: why doesn't overloading VatLoader work???
  *
- * @typedef {((name: 'network') => NetworkVat) & ((name: 'ibc') => IBCVat)} VatLoader2
+ * @param {object} options
+ * @param {{networkRef: VatSourceRef, ibcRef: VatSourceRef}} options.options
+ * // TODO: why doesn't overloading VatLoader work???
+ * @typedef { ((name: 'network') => NetworkVat) &
+ *            ((name: 'ibc') => IBCVat) } VatLoader2
  *
- * @typedef {{
- *   network: ERef<NetworkVat>;
- *   ibc: ERef<IBCVat>;
- *   provisioning: ERef<ProvisioningVat | undefined>;
- * }} NetVats
+ * @typedef {{ network: ERef<NetworkVat>, ibc: ERef<IBCVat>, provisioning: ERef<ProvisioningVat | undefined>}} NetVats
  */
 export const setupNetworkProtocols = async (
   {
@@ -102,7 +99,7 @@ export const setupNetworkProtocols = async (
   options,
 ) => {
   const { networkRef, ibcRef } = options.options;
-  /** @type {NetVats} */
+  /** @type { NetVats } */
   const vats = {
     network: E(loadCriticalVat)('network', networkRef),
     ibc: E(loadCriticalVat)('ibc', ibcRef),

package/src/proposals/restart-vats-proposal.d.ts

@@ -1,6 +1,6 @@
 export function restartVats({ consume }: BootstrapPowers & import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapSpace, { options }: {
     options: {
-        skip: string[];
+        skip: Array<string>;
     };
 }): Promise<void>;
 export function getManifestForRestart(_powers: any, options: any): {

package/src/proposals/restart-vats-proposal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restart-vats-proposal.d.ts","sourceRoot":"","sources":["restart-vats-proposal.js"],"names":[],"mappings":"AA+BO,yCALI,eAAe,GACzB,OAAW,wDAAwD,EAAE,qBAAqB;IAErD,OAAO,EAAlC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE;kBA0G5B;AAGM;;;;;;;;;;;;;;;;;;EAkBL"}
+{"version":3,"file":"restart-vats-proposal.d.ts","sourceRoot":"","sources":["restart-vats-proposal.js"],"names":[],"mappings":"AA+BO,yCAJI,eAAe,GAAG,OAAO,wDAAwD,EAAE,qBAAqB;IAEzE,OAAO,EAAtC;QAAE,IAAI,EAAE,MAAM,MAAM,CAAC,CAAA;KAAC;kBA4GhC;AAGM;;;;;;;;;;;;;;;;;;EAkBL"}

package/src/proposals/restart-vats-proposal.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-await-in-loop */
 // @ts-check
 
 import { Fail } from '@agoric/assert';
@@ -24,10 +25,9 @@ const vatUpgradeStatus = {
 };
 
 /**
- * @param {BootstrapPowers &
- *   import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapSpace} space
+ * @param {BootstrapPowers & import('@agoric/inter-protocol/src/proposals/econ-behaviors.js').EconomyBootstrapSpace} space
  * @param {object} config
- * @param {{ skip: string[] }} config.options
+ * @param {{ skip: Array<string>}} config.options
  */
 export const restartVats = async ({ consume }, { options }) => {
   console.log(HR);
@@ -53,6 +53,7 @@ export const restartVats = async ({ consume }, { options }) => {
 
   const failures = [];
   /**
+   *
    * @param {string} debugName
    * @param {Instance} instance
    * @param {ERef<AdminFacet>} adminFacet
@@ -61,6 +62,7 @@ export const restartVats = async ({ consume }, { options }) => {
     // TODO document that privateArgs cannot contain promises
     // TODO try making all the contract starts take resolved values
     const privateArgs = await deeplyFulfilledObject(
+      // @ts-expect-error cast
       harden(instancePrivateArgs.get(instance) || {}),
     );
 

package/src/provisionPool.d.ts

@@ -0,0 +1,164 @@
+export const privateArgsShape: import("@endo/patterns").Matcher;
+export function prepare(zcf: ZCF<ProvisionTerms>, privateArgs: {
+    poolBank: import('@endo/far').ERef<import('./vat-bank.js').Bank>;
+    initialPoserInvitation: Invitation;
+    storageNode: StorageNode;
+    marshaller: Marshaller;
+    metricsOverride?: import("./provisionPoolKit.js").MetricsNotification | undefined;
+}, baggage: MapStore<string, unknown>): Promise<{
+    creatorFacet: {
+        getParamMgrRetriever: () => {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                PerAccountInitialAmount: "amount";
+            } & {
+                Electorate: "invitation";
+            }>;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                PerAccountInitialAmount: "amount";
+            } & {
+                Electorate: "invitation";
+            }>;
+        }>;
+        getInvitation: (name: any) => Promise<Invitation<unknown, never>>;
+        getLimitedCreatorFacet: () => {
+            addRevivableAddresses(oldAddresses: string[]): void;
+            getWalletReviver(): {
+                reviveWallet(address: string): Promise<{
+                    handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string>, canSpend?: boolean | undefined): Promise<void>;
+                    getDepositFacet(): {
+                        receive(payment: Payment<AssetKind>): Promise<Amount<AssetKind>>;
+                    };
+                    getOffersFacet(): {
+                        executeOffer(offerSpec: import("@agoric/smart-wallet/src/offers.js").OfferSpec): Promise<void>;
+                        tryExitOffer(offerId: import("@agoric/smart-wallet/src/offers.js").OfferId): Promise<void>;
+                    };
+                    getCurrentSubscriber(): Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                    getUpdatesSubscriber(): Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                    getPublicTopics(): {
+                        current: {
+                            description: string;
+                            subscriber: Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                            storagePath: Promise<string>;
+                        };
+                        updates: {
+                            description: string;
+                            subscriber: Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                }>;
+                ackWallet(address: string): boolean;
+            };
+            setReferences(erefs: import("./provisionPoolKit.js").ProvisionPoolKitReferences): Promise<void>;
+            makeHandler(): {
+                fromBridge: (obj: any) => Promise<void>;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                fromBridge: (obj: any) => Promise<void>;
+            }>;
+            initPSM(brand: Brand<AssetKind>, instance: import("./provisionPoolKit.js").PsmInstance): void;
+        };
+        getGovernedApis: () => GovernedApis;
+        getGovernedApiNames: () => string[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getParamMgrRetriever: () => {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                PerAccountInitialAmount: "amount";
+            } & {
+                Electorate: "invitation";
+            }>;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                PerAccountInitialAmount: "amount";
+            } & {
+                Electorate: "invitation";
+            }>;
+        }>;
+        getInvitation: (name: any) => Promise<Invitation<unknown, never>>;
+        getLimitedCreatorFacet: () => {
+            addRevivableAddresses(oldAddresses: string[]): void;
+            getWalletReviver(): {
+                reviveWallet(address: string): Promise<{
+                    handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string>, canSpend?: boolean | undefined): Promise<void>;
+                    getDepositFacet(): {
+                        receive(payment: Payment<AssetKind>): Promise<Amount<AssetKind>>;
+                    };
+                    getOffersFacet(): {
+                        executeOffer(offerSpec: import("@agoric/smart-wallet/src/offers.js").OfferSpec): Promise<void>;
+                        tryExitOffer(offerId: import("@agoric/smart-wallet/src/offers.js").OfferId): Promise<void>;
+                    };
+                    getCurrentSubscriber(): Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                    getUpdatesSubscriber(): Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                    getPublicTopics(): {
+                        current: {
+                            description: string;
+                            subscriber: Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                            storagePath: Promise<string>;
+                        };
+                        updates: {
+                            description: string;
+                            subscriber: Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                }>;
+                ackWallet(address: string): boolean;
+            };
+            setReferences(erefs: import("./provisionPoolKit.js").ProvisionPoolKitReferences): Promise<void>;
+            makeHandler(): {
+                fromBridge: (obj: any) => Promise<void>;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                fromBridge: (obj: any) => Promise<void>;
+            }>;
+            initPSM(brand: Brand<AssetKind>, instance: import("./provisionPoolKit.js").PsmInstance): void;
+        };
+        getGovernedApis: () => GovernedApis;
+        getGovernedApiNames: () => string[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    }>;
+    publicFacet: {
+        getAmount: (name: string) => Amount<AssetKind>;
+        getBrand: (name: string) => Brand<AssetKind>;
+        getInstance: (name: string) => Instance;
+        getInstallation: (name: string) => Installation<any>;
+        getInvitationAmount: (name: string) => Amount<"set">;
+        getNat: (name: string) => bigint;
+        getRatio: (name: string) => Ratio;
+        getString: (name: string) => string;
+        getTimestamp: (name: string) => import("@agoric/time/src/types.js").TimestampRecord;
+        getRelativeTime: (name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord;
+        getUnknown: (name: string) => any;
+        getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams: () => ERef<ParamStateRecord>;
+        getMetrics(): Subscriber<import("./provisionPoolKit.js").MetricsNotification>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./provisionPoolKit.js").MetricsNotification>;
+        };
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getAmount: (name: string) => Amount<AssetKind>;
+        getBrand: (name: string) => Brand<AssetKind>;
+        getInstance: (name: string) => Instance;
+        getInstallation: (name: string) => Installation<any>;
+        getInvitationAmount: (name: string) => Amount<"set">;
+        getNat: (name: string) => bigint;
+        getRatio: (name: string) => Ratio;
+        getString: (name: string) => string;
+        getTimestamp: (name: string) => import("@agoric/time/src/types.js").TimestampRecord;
+        getRelativeTime: (name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord;
+        getUnknown: (name: string) => any;
+        getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams: () => ERef<ParamStateRecord>;
+        getMetrics(): Subscriber<import("./provisionPoolKit.js").MetricsNotification>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./provisionPoolKit.js").MetricsNotification>;
+        };
+    }>;
+}>;
+/**
+ * TODO: ERef<GovernedCreatorFacet<ProvisionCreator>>
+ */
+export type ProvisionTerms = StandardTerms & GovernanceTerms<{
+    PerAccountInitialAmount: 'amount';
+}>;
+//# sourceMappingURL=provisionPool.d.ts.map

package/src/provisionPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provisionPool.d.ts","sourceRoot":"","sources":["provisionPool.js"],"names":[],"mappings":"AAgBA,gEAWE;AAmBK,6BAVI,IAAI,cAAc,CAAC;cAEf,OAAO,WAAW,EAAE,IAAI,CAAC,OAAO,eAAe,EAAE,IAAI,CAAC;4BACxC,UAAU;iBACrB,WAAW;gBACZ,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqE1B;;;;6BAhFY,aAAa,GAAG,gBAAgB;IAC5C,uBAA4B,EAAE,QAAQ,CAAC;CAClC,CAAC"}

package/src/provisionPool.js

@@ -0,0 +1,113 @@
+// @jessie-check
+// @ts-check
+
+import {
+  handleParamGovernance,
+  ParamTypes,
+  publicMixinAPI,
+} from '@agoric/governance';
+import { InvitationShape } from '@agoric/governance/src/typeGuards.js';
+import { M } from '@agoric/store';
+import { prepareExo } from '@agoric/vat-data';
+import { provideSingleton } from '@agoric/zoe/src/contractSupport/durability.js';
+import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
+import { TopicsRecordShape } from '@agoric/zoe/src/contractSupport/topics.js';
+import { prepareProvisionPoolKit } from './provisionPoolKit.js';
+
+export const privateArgsShape = M.splitRecord(
+  harden({
+    poolBank: M.eref(M.remotable('bank')),
+    storageNode: M.eref(M.remotable('storageNode')),
+    marshaller: M.eref(M.remotable('marshaller')),
+  }),
+  harden({
+    // only necessary on first invocation, not subsequent
+    initialPoserInvitation: InvitationShape,
+    metricsOverride: M.recordOf(M.string()),
+  }),
+);
+
+/**
+ * @typedef {StandardTerms & GovernanceTerms<{
+ *    PerAccountInitialAmount: 'amount',
+ *   }>} ProvisionTerms
+ *
+ * TODO: ERef<GovernedCreatorFacet<ProvisionCreator>>
+ *
+ * @param {ZCF<ProvisionTerms>} zcf
+ * @param {{
+ *   poolBank: import('@endo/far').ERef<import('./vat-bank.js').Bank>,
+ *   initialPoserInvitation: Invitation,
+ *   storageNode: StorageNode,
+ *   marshaller: Marshaller,
+ *   metricsOverride?: import('./provisionPoolKit').MetricsNotification,
+ * }} privateArgs
+ * @param {import('@agoric/vat-data').Baggage} baggage
+ */
+export const prepare = async (zcf, privateArgs, baggage) => {
+  const { poolBank, metricsOverride } = privateArgs;
+
+  const { makeRecorderKit } = prepareRecorderKitMakers(
+    baggage,
+    privateArgs.marshaller,
+  );
+
+  // Governance
+  const { publicMixin, makeDurableGovernorFacet, params } =
+    await handleParamGovernance(
+      zcf,
+      privateArgs.initialPoserInvitation,
+      {
+        PerAccountInitialAmount: ParamTypes.AMOUNT,
+      },
+      privateArgs.storageNode,
+      privateArgs.marshaller,
+    );
+
+  const makeProvisionPoolKit = prepareProvisionPoolKit(baggage, {
+    makeRecorderKit,
+    params,
+    poolBank,
+    zcf,
+  });
+
+  const provisionPoolKit = await provideSingleton(
+    baggage,
+    'provisionPoolKit',
+    () =>
+      makeProvisionPoolKit({
+        // XXX governance can change the brand of the amount but should only be able to change the value
+        // NB: changing the brand will break this pool
+        poolBrand: params.getPerAccountInitialAmount().brand,
+        storageNode: privateArgs.storageNode,
+      }),
+    kit => kit.helper.start({ metrics: metricsOverride }),
+  );
+
+  const publicFacet = prepareExo(
+    baggage,
+    'Provisioning Pool public',
+    M.interface('ProvisionPool', {
+      getMetrics: M.call().returns(M.remotable('MetricsSubscriber')),
+      getPublicTopics: M.call().returns(TopicsRecordShape),
+      ...publicMixinAPI,
+    }),
+    {
+      getMetrics() {
+        return provisionPoolKit.public.getPublicTopics().metrics.subscriber;
+      },
+      getPublicTopics() {
+        return provisionPoolKit.public.getPublicTopics();
+      },
+      ...publicMixin,
+    },
+  );
+
+  return harden({
+    creatorFacet: makeDurableGovernorFacet(baggage, provisionPoolKit.machine)
+      .governorFacet,
+    publicFacet,
+  });
+};
+
+harden(prepare);