@agoric/inter-protocol 0.17.0-u18.5 → 0.17.0-u18a.0

package/src/proposals/replace-fee-distributor.js

@@ -0,0 +1,195 @@
+import { deeplyFulfilledObject, makeTracer } from '@agoric/internal';
+import { Stable } from '@agoric/internal/src/tokens.js';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
+import { getInterfaceOf, E } from '@endo/far';
+
+const trace = makeTracer('ReplaceFeeDistributer', true);
+
+/**
+ * Start the reward distributor.
+ *
+ * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
+ * @param {{
+ *   options: {
+ *     keywordShares: Record<string, bigint>;
+ *     collectionInterval: bigint;
+ *   };
+ * }} options
+ */
+export const replaceFeeDistributor = async (
+  {
+    consume: {
+      chainTimerService,
+      bankManager,
+      vaultFactoryKit,
+      periodicFeeCollectors,
+      reserveKit,
+      zoe,
+      contractKits: contractKitsP,
+    },
+    produce: {
+      feeDistributorKit,
+      periodicFeeCollectors: periodicFeeCollectorsP,
+    },
+    instance: {
+      produce: { feeDistributor: feeDistributorP },
+    },
+    installation: {
+      consume: { feeDistributor },
+    },
+    issuer: {
+      consume: { [Stable.symbol]: centralIssuerP },
+    },
+    brand: {
+      consume: { [Stable.symbol]: centralBrandP },
+    },
+  },
+  { options },
+) => {
+  trace('replaceFeeDistributer', options);
+
+  const { keywordShares, collectionInterval } = options;
+
+  const feeDistributorTerms = await deeplyFulfilledObject(
+    harden({
+      timerService: chainTimerService,
+      collectionInterval,
+      keywordShares,
+    }),
+  );
+  trace('feeDistributorTerms', feeDistributorTerms);
+
+  const [centralIssuer, centralBrand, contractKits] = await Promise.all([
+    centralIssuerP,
+    centralBrandP,
+    contractKitsP,
+  ]);
+
+  const rewardDistributorDepositFacet = await E(bankManager)
+    .getRewardDistributorDepositFacet(Stable.denom, {
+      issuer: centralIssuer,
+      brand: centralBrand,
+    })
+    .catch(e => {
+      console.error('Cannot create fee collector deposit facet', e);
+      return undefined;
+    });
+
+  /**
+   * @type {StartedInstanceKit<
+   *   typeof import('@agoric/inter-protocol/src/feeDistributor.js').start
+   * >}
+   */
+  const instanceKit = await E(zoe).startInstance(
+    feeDistributor,
+    { Fee: centralIssuer },
+    feeDistributorTerms,
+    undefined,
+    'feeDistributor',
+  );
+  await E(instanceKit.creatorFacet).setDestinations({
+    ...(rewardDistributorDepositFacet && {
+      RewardDistributor: E(
+        instanceKit.creatorFacet,
+      ).makeDepositFacetDestination(rewardDistributorDepositFacet),
+    }),
+    Reserve: E(instanceKit.creatorFacet).makeOfferDestination(
+      zoe,
+      'Collateral',
+      E.get(reserveKit).publicFacet,
+      'makeAddCollateralInvitation',
+    ),
+  });
+
+  trace('Clearing the old instance from bootstrap powers...');
+  feeDistributorKit.reset();
+  feeDistributorP.reset();
+
+  trace('Now introduce the new instance');
+  feeDistributorKit.resolve(
+    harden({ ...instanceKit, label: 'feeDistributor' }),
+  );
+  feeDistributorP.resolve(instanceKit.instance);
+
+  const periodicCollectors = await periodicFeeCollectors;
+  trace(
+    `Stop periodicCollectors of the old instance. Number of collectors: ${periodicCollectors.getSize()}`,
+  );
+  for await (const [key, collector] of periodicCollectors.entries()) {
+    trace('Getting debugName', key);
+    // @ts-expect-error incomplete PeriodicFeeCollector type
+    const debugName = await E(collector).getDebugName();
+    trace(`Stopping ${debugName}...`);
+    await E(collector).stop();
+  }
+  periodicFeeCollectorsP.reset();
+
+  trace('Old collectors cleared. Start creating and setting new ones.');
+
+  const collectorKit = {
+    vaultFactory: E.get(vaultFactoryKit).creatorFacet,
+  };
+  const newCollectorStore = makeScalarBigMapStore('periodicCollectors', {
+    durable: true,
+  });
+  await Promise.all(
+    Object.entries(collectorKit).map(async ([debugName, collectorFacet]) => {
+      const collector = E(instanceKit.creatorFacet).makeContractFeeCollector(
+        zoe,
+        collectorFacet,
+      );
+      const periodicCollector = await E(
+        instanceKit.creatorFacet,
+      ).startPeriodicCollection(debugName, collector);
+      newCollectorStore.init(periodicCollectors.getSize(), periodicCollector);
+    }),
+  );
+
+  trace('Write newCollectorStore in periodicFeeCollectors');
+  periodicFeeCollectorsP.resolve(newCollectorStore);
+
+  trace('Write to contractKits');
+  const label = getInterfaceOf(instanceKit.instance);
+  const kit = harden({ ...instanceKit, label });
+  contractKits.init(kit.instance, kit);
+
+  trace('Done.');
+};
+harden(replaceFeeDistributor);
+
+const t = 'replaceFeeDistributor';
+export const getManifestForReplaceFeeDistributor = async (
+  _,
+  feeDistributorOptions,
+) => ({
+  manifest: {
+    [replaceFeeDistributor.name]: {
+      consume: {
+        chainTimerService: t,
+        bankManager: t,
+        vaultFactoryKit: t,
+        periodicFeeCollectors: t,
+        reserveKit: t,
+        zoe: t,
+        contractKits: t,
+      },
+      produce: {
+        feeDistributorKit: t,
+        periodicFeeCollectors: t,
+      },
+      instance: {
+        produce: { feeDistributor: t },
+      },
+      installation: {
+        consume: { feeDistributor: t },
+      },
+      issuer: {
+        consume: { [Stable.symbol]: t },
+      },
+      brand: {
+        consume: { [Stable.symbol]: t },
+      },
+    },
+  },
+  options: { ...feeDistributorOptions },
+});

package/src/proposals/replaceElectorate.d.ts

@@ -18,6 +18,8 @@ export function getManifestForReplaceAllElectorates({ economicCommitteeRef: _eco
                 auctionUpgradeNewGovCreator: boolean;
                 auctionUpgradeNewInstance: boolean;
                 psmKit: boolean;
+                contractKits: boolean;
+                econCharterKit: boolean;
                 governedContractKits: boolean;
                 chainStorage: boolean;
                 highPrioritySendersManager: boolean;
@@ -47,6 +49,7 @@ export function getManifestForReplaceAllElectorates({ economicCommitteeRef: _eco
                 };
                 consume: {
                     economicCommittee: boolean;
+                    econCommitteeCharter: boolean;
                 };
             };
         };

package/src/proposals/replaceElectorate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replaceElectorate.d.ts","sourceRoot":"","sources":["replaceElectorate.js"],"names":[],"mappings":"AAkbO,uDAlBI,sBAAsB,GAAG,eAAe,UAGxC;IACN,OAAO,EAAE;QACP,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACvC,yBAAyB,EAAE;YACzB,cAAc,EAAE,MAAM,EAAE,CAAC;YACzB,iBAAiB,EAAE,MAAM,EAAE,CAAC;SAC7B,CAAC;KACH,CAAC;CACH,GAGS,OAAO,CAAC,IAAI,CAAC,CAuEzB;AAIM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CL;8BAzNW,cAAc,CAAC;IACvB,yBAAyB,EAAE,QAAQ,CAAC;IACpC,2BAA2B,EAAE,GAAG,CAAC;IACjC,wBAAwB,EAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACtD,CAAC;4CA9TqC,qBAAqB"}
+{"version":3,"file":"replaceElectorate.d.ts","sourceRoot":"","sources":["replaceElectorate.js"],"names":[],"mappings":"AAweO,uDAlBI,sBAAsB,GAAG,eAAe,UAGxC;IACN,OAAO,EAAE;QACP,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACvC,yBAAyB,EAAE;YACzB,cAAc,EAAE,MAAM,EAAE,CAAC;YACzB,iBAAiB,EAAE,MAAM,EAAE,CAAC;SAC7B,CAAC;KACH,CAAC;CACH,GAGS,OAAO,CAAC,IAAI,CAAC,CAuEzB;AAIM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDL;8BA9NW,cAAc,CAAC;IACvB,yBAAyB,EAAE,QAAQ,CAAC;IACpC,2BAA2B,EAAE,GAAG,CAAC;IACjC,wBAAwB,EAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACtD,CAAC;4CApXqC,qBAAqB"}

package/src/proposals/replaceElectorate.js

@@ -289,33 +289,87 @@ const startNewEconomicCommittee = async (
  * Starts a new Economic Committee Charter by creating an instance with the
  * provided committee specifications.
  *
- * @param {EconomyBootstrapPowers} powers - The resources and capabilities
- *   required to start the committee.
+ * @param {EconomyBootstrapPowers &
+ *   PromiseSpaceOf<{ retiredContractInstances: MapStore<string, Instance> }>} powers
+ *   - The resources and capabilities required to start the committee.
+ *
  * @returns {Promise<EconCharterStartResult>} A promise that resolves to the
  *   charter kit result.
  */
 const startNewEconCharter = async ({
-  consume: { startUpgradable },
-  produce: { econCharterKit },
+  consume: {
+    board,
+    startUpgradable,
+    contractKits: contractKitsP,
+    econCharterKit: econCharterKitP,
+    retiredContractInstances: retiredContractInstancesP,
+  },
+  produce: {
+    econCharterKit: produceEconCharterKit,
+    retiredContractInstances: produceRetiredInstances,
+  },
   installation: {
     consume: { binaryVoteCounter: counterP, econCommitteeCharter: installP },
   },
   instance: {
     produce: { econCommitteeCharter },
+    consume: { econCommitteeCharter: previousInstanceP },
   },
 }) => {
-  const [charterInstall, counterInstall] = await Promise.all([
+  const [
+    charterInstall,
+    counterInstall,
+    previousInstance,
+    contractKits,
+    econCharterKit,
+    retiredInstances,
+  ] = await Promise.all([
     installP,
     counterP,
+    previousInstanceP,
+    contractKitsP,
+    econCharterKitP,
+    provideRetiredInstances(retiredContractInstancesP, produceRetiredInstances),
   ]);
-  const terms = await harden({
-    binaryVoteCounterInstallation: counterInstall,
-  });
+
+  const label = 'econCommitteeCharter';
+  const previousCharterKit = { ...econCharterKit, label };
+
+  const boardID = await E(board).getId(previousCharterKit.instance);
+  const identifier = `${label}-${boardID}`;
+  trace('Saving previous EC Charter Instance', label);
+
+  // save the old charter instance kit so we can manage it later
+  if (retiredInstances.has(identifier)) {
+    // bootstrap tests start having already run this upgrade. Actual upgrades on
+    // mainNet or testnets should start with the promiseSpace post upgrade-17,
+    // which doesn't have this entry in the map.
+    trace(
+      '⚠️ WARNING: collision on storing Charter in retireInstances not' +
+        ' expected during chain upgrade.   It IS normal during bootstrap tests',
+    );
+  } else {
+    retiredInstances.init(identifier, previousCharterKit.instance);
+  }
+  if (contractKits.has(previousInstance)) {
+    // bootstrap tests start having already run this upgrade. Actual upgrades on
+    // mainNet or testnets should start with the promiseSpace post upgrade-17,
+    // which doesn't have this entry in the map.
+    trace(
+      '⚠️ WARNING: collision on storing Charter in contractKits not' +
+        ' expected during chain upgrade.   It IS normal during bootstrap tests',
+    );
+  } else {
+    contractKits.init(previousInstance, previousCharterKit);
+  }
 
   trace('Starting new EC Charter Instance');
 
+  const terms = harden({
+    binaryVoteCounterInstallation: counterInstall,
+  });
   const startResult = await E(startUpgradable)({
-    label: 'econCommitteeCharter',
+    label,
     installation: charterInstall,
     terms,
   });
@@ -325,8 +379,8 @@ const startNewEconCharter = async ({
   econCommitteeCharter.reset();
   econCommitteeCharter.resolve(E.get(startResult).instance);
 
-  econCharterKit.reset();
-  econCharterKit.resolve(startResult);
+  produceEconCharterKit.reset();
+  produceEconCharterKit.resolve(startResult);
   return startResult;
 };
 
@@ -515,6 +569,8 @@ export const getManifestForReplaceAllElectorates = async (
         auctionUpgradeNewGovCreator: true,
         auctionUpgradeNewInstance: true,
         psmKit: true,
+        contractKits: true,
+        econCharterKit: true,
         governedContractKits: true,
         chainStorage: true,
         highPrioritySendersManager: true,
@@ -543,7 +599,10 @@ export const getManifestForReplaceAllElectorates = async (
           economicCommittee: true,
           econCommitteeCharter: true,
         },
-        consume: { economicCommittee: true },
+        consume: {
+          economicCommittee: true,
+          econCommitteeCharter: true,
+        },
       },
     },
   },

package/src/proposals/startPSM.d.ts

@@ -5,7 +5,7 @@ export function startPSM({ vatParameters: { chainStorageEntries }, consume: { ag
     options?: {
         anchorOptions?: AnchorOptions;
     } | undefined;
-} | undefined): Promise<void>;
+}): Promise<void>;
 export function makeAnchorAsset({ vatParameters: { chainStorageEntries }, consume: { agoricNamesAdmin, bankManager, startUpgradable, anchorBalancePayments, }, installation: { consume: { mintHolder }, }, produce: { testFirstAnchorKit, anchorBalancePayments: produceAnchorBalancePayments, }, }: EconomyBootstrapPowers & WellKnownSpaces & ChainStorageVatParams, { options: { anchorOptions } }: {
     options: {
         anchorOptions?: AnchorOptions;

package/src/proposals/startPSM.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"startPSM.d.ts","sourceRoot":"","sources":["startPSM.js"],"names":[],"mappings":"AAuFO,ydAPI,sBAAsB,GAAG,eAAe,GAAG,qBAAqB;;;;;wBAK9C,aAAa;;8BAsMzC;AAuBM,qSAHI,sBAAsB,GAAG,eAAe,GAAG,qBAAqB,kCAChE;IAAE,OAAO,EAAE;QAAE,aAAa,CAAC,EAAE,aAAa,CAAA;KAAE,CAAA;CAAE,iBAwGxD;AAGD,iEAAiE;AAEjE,8DAiBE;AAEF,gCAAgC;AAChC,2BADW,iBAAiB,CA6C1B;AAGK;;;;;;;;;;;;EAaN;AAEM;;;;;;;;;;;;;;EAcN;;;;;;;uCAreM,yBAAyB;iCAAzB,yBAAyB;oCAAzB,yBAAyB;4CAIU,qBAAqB;uBAZxC,gCAAgC;uCAUlB,mCAAmC"}
+{"version":3,"file":"startPSM.d.ts","sourceRoot":"","sources":["startPSM.js"],"names":[],"mappings":"AAuFO,ydAPI,sBAAsB,GAAG,eAAe,GAAG,qBAAqB,kFAExE;IAAwB,eAAe;IACf,eAAe;IACf,UAAU;IACiB,OAAO;wBAAhC,aAAa;;CAAoB,iBAsM7D;AAuBM,qSAHI,sBAAsB,GAAG,eAAe,GAAG,qBAAqB,kCAChE;IAAE,OAAO,EAAE;QAAE,aAAa,CAAC,EAAE,aAAa,CAAA;KAAE,CAAA;CAAE,iBAwGxD;AAGD,iEAAiE;AAEjE,8DAiBE;AAEF,gCAAgC;AAChC,2BADW,iBAAiB,CA6C1B;AAGK;;;;;;;;;;;;EAaN;AAEM;;;;;;;;;;;;;;EAcN;;;;;;;uCAreM,yBAAyB;iCAAzB,yBAAyB;oCAAzB,yBAAyB;4CAIU,qBAAqB;uBAZxC,gCAAgC;uCAUlB,mCAAmC"}

package/src/proposals/upgrade-vaults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upgrade-vaults.d.ts","sourceRoot":"","sources":["upgrade-vaults.js"],"names":[],"mappings":"AAyBO,+XARI,OAAO,oCAAoC,EAAE,sBAAsB,GACvE,eAAe,uDACX;IACN,OAAO,EAAE;QACP,kBAAkB,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;KAC1C,CAAC;CACH,iBA8IH;AAUM,4DAHJ;IAAmB,UAAU,EAArB,GAAG;CACX,uBAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;GA4Bb;8BAhMY,cAAc,CAAC;IACvB,kBAAkB,EAAE,QAAQ,CAAC;IAC7B,yBAAyB,EAAE,QAAQ,CAAC;IACpC,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC"}
+{"version":3,"file":"upgrade-vaults.d.ts","sourceRoot":"","sources":["upgrade-vaults.js"],"names":[],"mappings":"AA+BO,+XARI,OAAO,oCAAoC,EAAE,sBAAsB,GACvE,eAAe,uDACX;IACN,OAAO,EAAE;QACP,kBAAkB,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;KAC1C,CAAC;CACH,iBA8IH;AAUM,4DAHJ;IAAmB,UAAU,EAArB,GAAG;CACX,uBAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;GA4Bb;8BAhMY,cAAc,CAAC;IACvB,kBAAkB,EAAE,QAAQ,CAAC;IAC7B,yBAAyB,EAAE,QAAQ,CAAC;IACpC,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC"}

package/src/proposals/upgrade-vaults.js

@@ -1,3 +1,9 @@
+/**
+ * @file this core-eval proposal is specific to the upgrade-18 scenario,
+ *   handling tasks beyond generic Vault Factory null upgrade. For a reusable
+ *   proposal, see upgrade-vaultFactory-proposal.js.
+ */
+
 import { E } from '@endo/far';
 import { makeNotifierFromAsyncIterable } from '@agoric/notifier';
 import { makeTracer } from '@agoric/internal/src/index.js';

package/src/provisionPool.d.ts

@@ -7,6 +7,7 @@ export function start(zcf: ZCF<ProvisionTerms>, privateArgs: {
     storageNode: StorageNode;
     marshaller: Marshal<any>;
     metricsOverride?: import("./provisionPoolKit.js").MetricsNotification;
+    governedParamOverrides?: Record<string, Amount | undefined>;
 }, baggage: import("@agoric/vat-data").Baggage): Promise<{
     creatorFacet: import("@endo/exo").Guarded<{
         getParamMgrRetriever: () => {
@@ -23,112 +24,7 @@ export function start(zcf: ZCF<ProvisionTerms>, privateArgs: {
             }>;
         }>;
         getInvitation: (name: any) => Promise<Invitation<unknown, undefined>>;
-        getLimitedCreatorFacet: () => import("@endo/exo").Guarded<{
-            addRevivableAddresses(oldAddresses: string[]): void;
-            getWalletReviver(): import("@endo/exo").Guarded<{
-                reviveWallet(address: string): Promise<{
-                    handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string | null>, canSpend?: boolean | undefined): Promise<void>;
-                    getDepositFacet(): import("@endo/exo").Guarded<{
-                        receive(payment: Payment): Promise<Amount>;
-                    }>;
-                    getOffersFacet(): import("@endo/exo").Guarded<{
-                        executeOffer(offerSpec: OfferSpec): Promise<void>;
-                        tryExitOffer(offerId: import("@agoric/smart-wallet/src/offers.js").OfferId): Promise<void>;
-                    }>;
-                    getCurrentSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
-                    getUpdatesSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
-                    getPublicTopics(): {
-                        current: {
-                            description: string;
-                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
-                            storagePath: Promise<string>;
-                        };
-                        updates: {
-                            description: string;
-                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
-                            storagePath: Promise<string>;
-                        };
-                    };
-                } & import("../../../node_modules/@endo/exo/src/get-interface.js").GetInterfaceGuard<{
-                    handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string | null>, canSpend?: boolean | undefined): Promise<void>;
-                    getDepositFacet(): import("@endo/exo").Guarded<{
-                        receive(payment: Payment): Promise<Amount>;
-                    }>;
-                    getOffersFacet(): import("@endo/exo").Guarded<{
-                        executeOffer(offerSpec: OfferSpec): Promise<void>;
-                        tryExitOffer(offerId: import("@agoric/smart-wallet/src/offers.js").OfferId): Promise<void>;
-                    }>;
-                    getCurrentSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
-                    getUpdatesSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
-                    getPublicTopics(): {
-                        current: {
-                            description: string;
-                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
-                            storagePath: Promise<string>;
-                        };
-                        updates: {
-                            description: string;
-                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
-                            storagePath: Promise<string>;
-                        };
-                    };
-                }> & import("@endo/eventual-send").RemotableBrand<{}, {
-                    handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string | null>, canSpend?: boolean | undefined): Promise<void>;
-                    getDepositFacet(): import("@endo/exo").Guarded<{
-                        receive(payment: Payment): Promise<Amount>;
-                    }>;
-                    getOffersFacet(): import("@endo/exo").Guarded<{
-                        executeOffer(offerSpec: OfferSpec): Promise<void>;
-                        tryExitOffer(offerId: import("@agoric/smart-wallet/src/offers.js").OfferId): Promise<void>;
-                    }>;
-                    getCurrentSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
-                    getUpdatesSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
-                    getPublicTopics(): {
-                        current: {
-                            description: string;
-                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
-                            storagePath: Promise<string>;
-                        };
-                        updates: {
-                            description: string;
-                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
-                            storagePath: Promise<string>;
-                        };
-                    };
-                } & import("../../../node_modules/@endo/exo/src/get-interface.js").GetInterfaceGuard<{
-                    handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string | null>, canSpend?: boolean | undefined): Promise<void>;
-                    getDepositFacet(): import("@endo/exo").Guarded<{
-                        receive(payment: Payment): Promise<Amount>;
-                    }>;
-                    getOffersFacet(): import("@endo/exo").Guarded<{
-                        executeOffer(offerSpec: OfferSpec): Promise<void>;
-                        tryExitOffer(offerId: import("@agoric/smart-wallet/src/offers.js").OfferId): Promise<void>;
-                    }>;
-                    getCurrentSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
-                    getUpdatesSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
-                    getPublicTopics(): {
-                        current: {
-                            description: string;
-                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
-                            storagePath: Promise<string>;
-                        };
-                        updates: {
-                            description: string;
-                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
-                            storagePath: Promise<string>;
-                        };
-                    };
-                }>> & import("@endo/pass-style").RemotableObject>;
-                ackWallet(address: string): boolean;
-            }>;
-            setReferences(erefs: ProvisionPoolKitReferences): Promise<void>;
-            makeHandler(): {
-                fromBridge: (obj: any) => Promise<void>;
-            } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
-                fromBridge: (obj: any) => Promise<void>;
-            }>;
-            initPSM(brand: Brand, instance: PsmInstance): void;
-        }>;
+        getLimitedCreatorFacet: () => any;
         getGovernedApis: () => GovernedApis;
         getGovernedApiNames: () => string[];
         setOfferFilter: (strings: any) => Promise<void>;
@@ -147,10 +43,8 @@ export function start(zcf: ZCF<ProvisionTerms>, privateArgs: {
         getUnknown: (name: string) => any;
         getSubscription: () => globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
         getGovernedParams: () => globalThis.ERef<globalThis.ParamStateRecord>;
-        getMetrics(): globalThis.Subscriber<import("./provisionPoolKit.js").MetricsNotification>;
-        getPublicTopics(): {
-            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./provisionPoolKit.js").MetricsNotification>;
-        };
+        getMetrics(): any;
+        getPublicTopics(): any;
     }>;
 }>;
 /**

package/src/provisionPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provisionPool.d.ts","sourceRoot":"","sources":["provisionPool.js"],"names":[],"mappings":"AAgBA,8CAA8C;AAE9C,2BAA2B;AAC3B,mBADW,YAAY,CAerB;AAqBK,2BAZI,GAAG,CAAC,cAAc,CAAC,eACnB;IACN,QAAQ,EAAE,OAAO,WAAW,EAAE,IAAI,CACtC,OAAa,8BAA8B,EAAE,IAAI,CAC5C,CAAC;IACF,sBAAsB,EAAE,UAAU,CAAC;IACnC,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,QAAQ,GAAG,CAAC,CAAC;IACzB,eAAe,CAAC,EAAE,OAAO,uBAAuB,EAAE,mBAAmB,CAAC;CACvE,WACO,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;6DAsE0o8B,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+CAAvnoB,cAAc;kDAAuE,cAAc;;;;;;;;;GAHjrU;;;;6BAlFY,aAAa,GACrB,eAAe,CAAC;IACd,uBAAuB,EAAE,QAAQ,CAAC;CACnC,CAAC;6BAxBoB,eAAe"}
+{"version":3,"file":"provisionPool.d.ts","sourceRoot":"","sources":["provisionPool.js"],"names":[],"mappings":"AAoBA,8CAA8C;AAE9C,2BAA2B;AAC3B,mBADW,YAAY,CAerB;AAsBK,2BAbI,GAAG,CAAC,cAAc,CAAC,eACnB;IACN,QAAQ,EAAE,OAAO,WAAW,EAAE,IAAI,CACtC,OAAa,8BAA8B,EAAE,IAAI,CAC5C,CAAC;IACF,sBAAsB,EAAE,UAAU,CAAC;IACnC,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,QAAQ,GAAG,CAAC,CAAC;IACzB,eAAe,CAAC,EAAE,OAAO,uBAAuB,EAAE,mBAAmB,CAAC;IACtE,sBAAsB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC7D,WACO,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+CA2EktT,cAAc;kDAAuE,cAAc;;;;;;;GAHj2T;;;;6BAxFY,aAAa,GACrB,eAAe,CAAC;IACd,uBAAuB,EAAE,QAAQ,CAAC;CACnC,CAAC;6BAxBoB,eAAe"}

package/src/provisionPool.js

@@ -12,7 +12,11 @@ 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';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+import {
+  prepareBridgeProvisionTool,
+  prepareProvisionPoolKit,
+} from './provisionPoolKit.js';
 
 /** @import {Marshal} from '@endo/marshal'; */
 
@@ -49,6 +53,7 @@ harden(meta);
  *   storageNode: StorageNode;
  *   marshaller: Marshal<any>;
  *   metricsOverride?: import('./provisionPoolKit.js').MetricsNotification;
+ *   governedParamOverrides?: Record<string, Amount | undefined>;
  * }} privateArgs
  * @param {import('@agoric/vat-data').Baggage} baggage
  */
@@ -70,13 +75,18 @@ export const start = async (zcf, privateArgs, baggage) => {
       },
       privateArgs.storageNode,
       privateArgs.marshaller,
+      privateArgs.governedParamOverrides,
     );
 
-  const makeProvisionPoolKit = prepareProvisionPoolKit(baggage, {
+  const zone = makeDurableZone(baggage);
+
+  const makeBridgeProvisionTool = prepareBridgeProvisionTool(zone);
+  const makeProvisionPoolKit = prepareProvisionPoolKit(zone, {
     makeRecorderKit,
     params,
     poolBank,
     zcf,
+    makeBridgeProvisionTool,
   });
 
   const provisionPoolKit = await provideSingleton(