@agoric/vats 0.16.0-u18.3 → 0.16.0-u18.5

package/src/proposals/testUpgradedBoard.d.ts

@@ -0,0 +1,26 @@
+export function testUpgradedBoard({ consume: { board }, brand: { consume: { [Stable.symbol]: stableBrandP }, }, }: {
+    consume: {
+        board: any;
+    };
+    brand: {
+        consume: {
+            IST: any;
+        };
+    };
+}): Promise<void>;
+export function getManifestForTestUpgradedBoard(): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                board: boolean;
+            };
+            brand: {
+                consume: {
+                    IST: boolean;
+                };
+            };
+        };
+    };
+};
+import { Stable } from '@agoric/internal/src/tokens.js';
+//# sourceMappingURL=testUpgradedBoard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"testUpgradedBoard.d.ts","sourceRoot":"","sources":["testUpgradedBoard.js"],"names":[],"mappings":"AAGO;;;;;;;;;kBAoBN;AAEM;;;;;;;;;;;;;EASL;uBAjCqB,gCAAgC"}

package/src/proposals/testUpgradedBoard.js

@@ -0,0 +1,35 @@
+import { E, Far } from '@endo/far';
+import { Stable } from '@agoric/internal/src/tokens.js';
+
+export const testUpgradedBoard = async ({
+  consume: { board },
+  brand: {
+    consume: { [Stable.symbol]: stableBrandP },
+  },
+}) => {
+  // /////// can we store something and get it back?  ////////
+  const thing1 = Far('thing1', {});
+  const thing1Id = await E(board).getId(thing1);
+  assert(thing1Id.match(/^board0[0-9]+$/));
+
+  const marshaller = await E(board).getReadonlyMarshaller();
+  assert(marshaller, 'expected a marshaller');
+
+  const stableBrand = await stableBrandP;
+  // /////// can we retrieve a well-known object via its ID?  ////////
+  const stableID = await E(board).getId(stableBrand);
+  // /////// can we retrieve something stored long ago?  ////////
+  const stableBrandRetrieved = await E(board).getValue(stableID);
+  assert(stableBrandRetrieved === stableBrand, 'retrieved matching brand');
+};
+
+export const getManifestForTestUpgradedBoard = () => ({
+  manifest: {
+    [testUpgradedBoard.name]: {
+      consume: { board: true },
+      brand: {
+        consume: { [Stable.symbol]: true },
+      },
+    },
+  },
+});

package/src/proposals/upgrade-agoricNames-proposal.d.ts

@@ -0,0 +1,27 @@
+export function upgradeAgoricNames({ consume: { vatAdminSvc, vatStore } }: BootstrapPowers & {
+    consume: {
+        vatAdminSvc: VatAdminSvc;
+        vatStore: MapStore<string, import("@agoric/swingset-vat").CreateVatResults>;
+    };
+}, options: {
+    options: {
+        agoricNamesRef: VatSourceRef;
+    };
+}): Promise<void>;
+export function getManifestForUpgradingAgoricNames(_powers: any, { agoricNamesRef }: {
+    agoricNamesRef: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                vatAdminSvc: string;
+                vatStore: string;
+            };
+            produce: {};
+        };
+    };
+    options: {
+        agoricNamesRef: any;
+    };
+};
+//# sourceMappingURL=upgrade-agoricNames-proposal.d.ts.map

package/src/proposals/upgrade-agoricNames-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-agoricNames-proposal.d.ts","sourceRoot":"","sources":["upgrade-agoricNames-proposal.js"],"names":[],"mappings":"AAeO,2EAZI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,WAAW,EAAE,WAAW,CAAC;QACzB,QAAQ,EAAE,QAAQ,CACxB,MAAc,EACd,OAAe,sBAAsB,EAAE,gBAAgB,CAChD,CAAC;KACH,CAAC;CACH,WAED;IAAkD,OAAO,EAAjD;QAAE,cAAc,EAAE,YAAY,CAAA;KAAE;CAC1C,iBAgBA;AAEM;;;;;;;;;;;;;;;EAcL"}

package/src/proposals/upgrade-agoricNames-proposal.js

@@ -0,0 +1,47 @@
+import { E } from '@endo/far';
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     vatAdminSvc: VatAdminSvc;
+ *     vatStore: MapStore<
+ *       string,
+ *       import('@agoric/swingset-vat').CreateVatResults
+ *     >;
+ *   };
+ * }} powers
+ * @param {object} options
+ * @param {{ agoricNamesRef: VatSourceRef }} options.options
+ */
+export const upgradeAgoricNames = async (
+  { consume: { vatAdminSvc, vatStore } },
+  options,
+) => {
+  const { agoricNamesRef } = options.options;
+
+  assert(agoricNamesRef.bundleID);
+  const agoricNamesBundleCap = await E(vatAdminSvc).getBundleCap(
+    agoricNamesRef.bundleID,
+  );
+  console.log(`BANK BUNDLE ID: `, agoricNamesRef.bundleID);
+
+  const { adminNode } = await E(vatStore).get('agoricNames');
+
+  await E(adminNode).upgrade(agoricNamesBundleCap, {});
+};
+
+export const getManifestForUpgradingAgoricNames = (
+  _powers,
+  { agoricNamesRef },
+) => ({
+  manifest: {
+    [upgradeAgoricNames.name]: {
+      consume: {
+        vatAdminSvc: 'vatAdminSvc',
+        vatStore: 'vatStore',
+      },
+      produce: {},
+    },
+  },
+  options: { agoricNamesRef },
+});

package/src/proposals/upgrade-asset-reserve-proposal.d.ts

@@ -0,0 +1,33 @@
+export function upgradeAssetReserve({ consume: { economicCommitteeCreatorFacet: electorateCreatorFacet, reserveKit: reserveKitP, instancePrivateArgs: instancePrivateArgsP, }, produce: { reserveKit: reserveKitWriter }, }: BootstrapPowers & {
+    consume: {
+        economicCommitteeCreatorFacet: any;
+        reserveKit: any;
+    };
+    produce: {
+        reserveKit: any;
+    };
+}, options: {
+    options: {
+        assetReserveRef: VatSourceRef;
+    };
+}): Promise<void>;
+export function getManifestForUpgradingAssetReserve(_powers: any, { assetReserveRef }: {
+    assetReserveRef: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                economicCommitteeCreatorFacet: boolean;
+                instancePrivateArgs: boolean;
+                reserveKit: boolean;
+            };
+            produce: {
+                reserveKit: boolean;
+            };
+        };
+    };
+    options: {
+        assetReserveRef: any;
+    };
+};
+//# sourceMappingURL=upgrade-asset-reserve-proposal.d.ts.map

package/src/proposals/upgrade-asset-reserve-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-asset-reserve-proposal.d.ts","sourceRoot":"","sources":["upgrade-asset-reserve-proposal.js"],"names":[],"mappings":"AAmBO,6NAZI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,6BAA6B,EAAE,GAAG,CAAC;QACnC,UAAU,EAAE,GAAG,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACP,UAAU,EAAE,GAAG,CAAC;KACjB,CAAC;CACH,WAED;IAAmD,OAAO,EAAlD;QAAE,eAAe,EAAE,YAAY,CAAA;KAAE;CAC3C,iBAuDA;AAEM;;;;;;;;;;;;;;;;;;EAiBL"}

package/src/proposals/upgrade-asset-reserve-proposal.js

@@ -0,0 +1,93 @@
+import { E } from '@endo/far';
+import { deeplyFulfilled } from '@endo/marshal';
+import { makeTracer } from '@agoric/internal';
+
+const tracer = makeTracer('UpgradeAssetReserve');
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     economicCommitteeCreatorFacet: any;
+ *     reserveKit: any;
+ *   };
+ *   produce: {
+ *     reserveKit: any;
+ *   };
+ * }} powers
+ * @param {object} options
+ * @param {{ assetReserveRef: VatSourceRef }} options.options
+ */
+export const upgradeAssetReserve = async (
+  {
+    consume: {
+      economicCommitteeCreatorFacet: electorateCreatorFacet,
+      reserveKit: reserveKitP,
+      instancePrivateArgs: instancePrivateArgsP,
+    },
+    produce: { reserveKit: reserveKitWriter },
+  },
+  options,
+) => {
+  const { assetReserveRef } = options.options;
+
+  assert(assetReserveRef.bundleID);
+  tracer(`ASSET RESERVE BUNDLE ID: `, assetReserveRef);
+
+  const [reserveKit, instancePrivateArgs] = await Promise.all([
+    reserveKitP,
+    instancePrivateArgsP,
+  ]);
+  const { governorCreatorFacet, instance } = reserveKit;
+
+  const [originalPrivateArgs, poserInvitation] = await Promise.all([
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore Local tsc sees this as an error but typedoc does not
+    deeplyFulfilled(instancePrivateArgs.get(instance)),
+    E(electorateCreatorFacet).getPoserInvitation(),
+  ]);
+
+  const newPrivateArgs = harden({
+    ...originalPrivateArgs,
+    initialPoserInvitation: poserInvitation,
+  });
+
+  const adminFacet = await E(governorCreatorFacet).getAdminFacet();
+
+  // We need to reset the kit and produce a new adminFacet because the
+  // original contract is producing an admin facet that is for the
+  // governor, not the reserve.
+  reserveKitWriter.reset();
+  reserveKitWriter.resolve(
+    harden({
+      ...reserveKit,
+      adminFacet,
+    }),
+  );
+
+  const upgradeResult = await E(adminFacet).upgradeContract(
+    assetReserveRef.bundleID,
+    newPrivateArgs,
+  );
+
+  tracer('AssetReserve upgraded: ', upgradeResult);
+  tracer('Done.');
+};
+
+export const getManifestForUpgradingAssetReserve = (
+  _powers,
+  { assetReserveRef },
+) => ({
+  manifest: {
+    [upgradeAssetReserve.name]: {
+      consume: {
+        economicCommitteeCreatorFacet: true,
+        instancePrivateArgs: true,
+        reserveKit: true,
+      },
+      produce: {
+        reserveKit: true,
+      },
+    },
+  },
+  options: { assetReserveRef },
+});

package/src/proposals/upgrade-board-proposal.d.ts

@@ -0,0 +1,27 @@
+export function upgradeBoard({ consume: { board, vatAdminSvc, vatStore } }: BootstrapPowers & {
+    consume: {
+        vatAdminSvc: VatAdminSvc;
+        vatStore: MapStore<string, import("@agoric/swingset-vat").CreateVatResults>;
+    };
+}, options: {
+    options: {
+        boardRef: VatSourceRef;
+    };
+}): Promise<void>;
+export function getManifestForUpgradingBoard(_powers: any, { boardRef }: {
+    boardRef: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                board: string;
+                vatAdminSvc: string;
+                vatStore: string;
+            };
+        };
+    };
+    options: {
+        boardRef: any;
+    };
+};
+//# sourceMappingURL=upgrade-board-proposal.d.ts.map

package/src/proposals/upgrade-board-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-board-proposal.d.ts","sourceRoot":"","sources":["upgrade-board-proposal.js"],"names":[],"mappings":"AAeO,4EAZI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,WAAW,EAAE,WAAW,CAAC;QACzB,QAAQ,EAAE,QAAQ,CACxB,MAAc,EACd,OAAe,sBAAsB,EAAE,gBAAgB,CAChD,CAAC;KACH,CAAC;CACH,WAED;IAA4C,OAAO,EAA3C;QAAE,QAAQ,EAAE,YAAY,CAAA;KAAE;CACpC,iBAsBA;AAEM;;;;;;;;;;;;;;;EAWL"}

package/src/proposals/upgrade-board-proposal.js

@@ -0,0 +1,50 @@
+import { E } from '@endo/far';
+
+/**
+ * @param {BootstrapPowers & {
+ *   consume: {
+ *     vatAdminSvc: VatAdminSvc;
+ *     vatStore: MapStore<
+ *       string,
+ *       import('@agoric/swingset-vat').CreateVatResults
+ *     >;
+ *   };
+ * }} powers
+ * @param {object} options
+ * @param {{ boardRef: VatSourceRef }} options.options
+ */
+export const upgradeBoard = async (
+  { consume: { board, vatAdminSvc, vatStore } },
+  options,
+) => {
+  const { boardRef } = options.options;
+
+  assert(boardRef.bundleID);
+  const boardBundleCap = await E(vatAdminSvc).getBundleCap(boardRef.bundleID);
+  console.log(`Board BUNDLE ID: `, boardRef.bundleID);
+  const idsBefore = await E(board).ids();
+
+  const { adminNode } = await E(vatStore).get('board');
+  await E(adminNode).upgrade(boardBundleCap, {});
+
+  const idsAfter = await E(board).ids();
+  const same =
+    idsBefore.length === idsAfter.length &&
+    idsBefore.every((element, index) => element === idsAfter[index]);
+  assert(same, 'keys must stay the same');
+
+  console.log('Board upgrade complete');
+};
+
+export const getManifestForUpgradingBoard = (_powers, { boardRef }) => ({
+  manifest: {
+    [upgradeBoard.name]: {
+      consume: {
+        board: 'board',
+        vatAdminSvc: 'vatAdminSvc',
+        vatStore: 'vatStore',
+      },
+    },
+  },
+  options: { boardRef },
+});

package/src/proposals/upgrade-mintHolder-proposal.d.ts

@@ -0,0 +1,24 @@
+export function upgradeMintHolder({ consume: { contractKits: contractKitsP, instancePrivateArgs: instancePrivateArgsP, }, }: {
+    consume: {
+        contractKits: any;
+        instancePrivateArgs: any;
+    };
+}, options: any): Promise<void>;
+export function getManifestForUpgradingMintHolder(_powers: any, { contractRef, labelList }: {
+    contractRef: any;
+    labelList: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                contractKits: boolean;
+                instancePrivateArgs: boolean;
+            };
+        };
+    };
+    options: {
+        contractRef: any;
+        labelList: any;
+    };
+};
+//# sourceMappingURL=upgrade-mintHolder-proposal.d.ts.map

package/src/proposals/upgrade-mintHolder-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-mintHolder-proposal.d.ts","sourceRoot":"","sources":["upgrade-mintHolder-proposal.js"],"names":[],"mappings":"AAKO;;;;;gCAqDN;AAEM;;;;;;;;;;;;;;;;EAaL"}

package/src/proposals/upgrade-mintHolder-proposal.js

@@ -0,0 +1,74 @@
+import { makeTracer } from '@agoric/internal';
+import { E } from '@endo/far';
+
+const trace = makeTracer('upgrade mintHolder', true);
+
+export const upgradeMintHolder = async (
+  {
+    consume: {
+      contractKits: contractKitsP,
+      instancePrivateArgs: instancePrivateArgsP,
+    },
+  },
+  options,
+) => {
+  const { contractRef, labelList } = options.options;
+  assert(contractRef.bundleID, 'mintHolder bundleID not found');
+  assert(labelList, 'mintHolder bank asset label list not found');
+
+  trace(`Start mintHolder contract upgrade`);
+  trace(`Assets: `, labelList);
+
+  const [contractKits, instancePrivateArgs] = await Promise.all([
+    contractKitsP,
+    instancePrivateArgsP,
+  ]);
+
+  for (const assetLabel of labelList) {
+    const mintHolderKit = Array.from(contractKits.values()).find(
+      kit => kit.label && kit.label === assetLabel,
+    );
+    if (!mintHolderKit) {
+      console.error(
+        `ERROR: failed to upgrade ${assetLabel} mintHolder, contractKit not found`,
+      );
+      continue;
+    }
+
+    trace(`${assetLabel} mintHolderKit: `, mintHolderKit);
+
+    const { publicFacet, adminFacet, instance } = mintHolderKit;
+
+    /*
+     * Ensure that publicFacet holds an issuer by verifying that has
+     * the makeEmptyPurse method.
+     */
+    await E(publicFacet).makeEmptyPurse();
+
+    const privateArgs = instancePrivateArgs.get(instance);
+
+    const upgradeResult = await E(adminFacet).upgradeContract(
+      contractRef.bundleID,
+      privateArgs,
+    );
+
+    trace(`${assetLabel} upgrade result: `, upgradeResult);
+  }
+
+  trace(`Finished mintHolder contract upgrade`);
+};
+
+export const getManifestForUpgradingMintHolder = (
+  _powers,
+  { contractRef, labelList },
+) => ({
+  manifest: {
+    [upgradeMintHolder.name]: {
+      consume: {
+        contractKits: true,
+        instancePrivateArgs: true,
+      },
+    },
+  },
+  options: { contractRef, labelList },
+});

package/src/proposals/upgrade-paRegistry-proposal.d.ts

@@ -0,0 +1,29 @@
+export function upgradePriceAuthorityRegistry({ consume: { vatAdminSvc, vatStore, priceAuthority, agoricNames }, brand: { consume: { [Stable.symbol]: stableBrandP }, }, }: BootstrapPowers, options: {
+    options: {
+        registryRef: VatSourceRef;
+    };
+}): Promise<void>;
+export function getManifestForUpgradingRegistry(_powers: any, { registryRef }: {
+    registryRef: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNames: string;
+                vatAdminSvc: string;
+                vatStore: string;
+                priceAuthority: string;
+            };
+            brand: {
+                consume: {
+                    IST: string;
+                };
+            };
+        };
+    };
+    options: {
+        registryRef: any;
+    };
+};
+import { Stable } from '@agoric/internal/src/tokens.js';
+//# sourceMappingURL=upgrade-paRegistry-proposal.d.ts.map

package/src/proposals/upgrade-paRegistry-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade-paRegistry-proposal.d.ts","sourceRoot":"","sources":["upgrade-paRegistry-proposal.js"],"names":[],"mappings":"AAUO,4KAJI,eAAe,WAEvB;IAA+C,OAAO,EAA9C;QAAE,WAAW,EAAE,YAAY,CAAA;KAAE;CACvC,iBA6BA;AAGM;;;;;;;;;;;;;;;;;;;;;EAeL;uBArDqB,gCAAgC"}

package/src/proposals/upgrade-paRegistry-proposal.js

@@ -0,0 +1,57 @@
+// @ts-check
+import { E } from '@endo/far';
+import { AmountMath } from '@agoric/ertp';
+import { Stable } from '@agoric/internal/src/tokens.js';
+
+/**
+ * @param {BootstrapPowers} powers
+ * @param {object} options
+ * @param {{ registryRef: VatSourceRef }} options.options
+ */
+export const upgradePriceAuthorityRegistry = async (
+  {
+    consume: { vatAdminSvc, vatStore, priceAuthority, agoricNames },
+    brand: {
+      consume: { [Stable.symbol]: stableBrandP },
+    },
+  },
+  options,
+) => {
+  const { registryRef } = options.options;
+
+  assert(registryRef.bundleID);
+  console.log(`PriceAuthorityRegistry BUNDLE ID: `, registryRef.bundleID);
+
+  const [{ adminNode }, stableBrand, atomBrand, bundleCap] = await Promise.all([
+    E(vatStore).get('priceAuthority'),
+    stableBrandP,
+    E(agoricNames).lookup('brand', 'ATOM'),
+    E(vatAdminSvc).getBundleCap(registryRef.bundleID),
+  ]);
+
+  await E(adminNode).upgrade(bundleCap, {});
+
+  const oneATOM = AmountMath.make(atomBrand, 1_000_000n);
+  const quoteAtom = await E(priceAuthority).quoteGiven(oneATOM, stableBrand);
+  console.log('paRegistry quote', quoteAtom);
+
+  assert(quoteAtom.quoteAmount.value, 'insist on getting a quote');
+};
+
+const par = 'paRegistry';
+export const getManifestForUpgradingRegistry = (_powers, { registryRef }) => ({
+  manifest: {
+    [upgradePriceAuthorityRegistry.name]: {
+      consume: {
+        agoricNames: par,
+        vatAdminSvc: par,
+        vatStore: par,
+        priceAuthority: par,
+      },
+      brand: { consume: { [Stable.symbol]: par } },
+    },
+  },
+  options: {
+    registryRef,
+  },
+});

package/src/proposals/upgrade-provisionPool-proposal.d.ts

@@ -1,4 +1,4 @@
-export function upgradeProvisionPool({ consume: { economicCommitteeCreatorFacet: electorateCreatorFacet, instancePrivateArgs: instancePrivateArgsP, provisionPoolStartResult: provisionPoolStartResultP, }, }: BootstrapPowers & {
+export function upgradeProvisionPool({ consume: { economicCommitteeCreatorFacet: electorateCreatorFacet, instancePrivateArgs: instancePrivateArgsP, provisionPoolStartResult: provisionPoolStartResultP, bankManager, namesByAddressAdmin: namesByAddressAdminP, walletFactoryStartResult: walletFactoryStartResultP, provisionWalletBridgeManager: provisionWalletBridgeManagerP, }, }: BootstrapPowers & {
     consume: {
         economicCommitteeCreatorFacet: any;
     };
@@ -16,6 +16,10 @@ export function getManifestForUpgradingProvisionPool(_powers: any, { provisionPo
                 economicCommitteeCreatorFacet: boolean;
                 instancePrivateArgs: boolean;
                 provisionPoolStartResult: boolean;
+                bankManager: boolean;
+                namesByAddressAdmin: boolean;
+                walletFactoryStartResult: boolean;
+                provisionWalletBridgeManager: boolean;
             };
             produce: {};
         };

package/src/proposals/upgrade-provisionPool-proposal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upgrade-provisionPool-proposal.d.ts","sourceRoot":"","sources":["upgrade-provisionPool-proposal.js"],"names":[],"mappings":"AAYO,+MARI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,6BAA6B,EAAE,GAAG,CAAC;KACpC,CAAC;CACH,WAED;IAAoD,OAAO,EAAnD;QAAE,gBAAgB,EAAE,YAAY,CAAA;KAAE;CAC5C,iBAwCA;AAEM;;;;;;;;;;;;;;;;EAeL"}
+{"version":3,"file":"upgrade-provisionPool-proposal.d.ts","sourceRoot":"","sources":["upgrade-provisionPool-proposal.js"],"names":[],"mappings":"AAeO,yXARI,eAAe,GAAG;IACxB,OAAO,EAAE;QACP,6BAA6B,EAAE,GAAG,CAAC;KACpC,CAAC;CACH,WAED;IAAoD,OAAO,EAAnD;QAAE,gBAAgB,EAAE,YAAY,CAAA;KAAE;CAC5C,iBAoFA;AAEM;;;;;;;;;;;;;;;;;;;;EAmBL"}

package/src/proposals/upgrade-provisionPool-proposal.js

@@ -1,5 +1,8 @@
 import { E } from '@endo/far';
 import { deeplyFulfilled } from '@endo/marshal';
+import { makeTracer } from '@agoric/internal';
+
+const trace = makeTracer('UpgradeProvisionPool');
 
 /**
  * @param {BootstrapPowers & {
@@ -16,6 +19,10 @@ export const upgradeProvisionPool = async (
       economicCommitteeCreatorFacet: electorateCreatorFacet,
       instancePrivateArgs: instancePrivateArgsP,
       provisionPoolStartResult: provisionPoolStartResultP,
+      bankManager,
+      namesByAddressAdmin: namesByAddressAdminP,
+      walletFactoryStartResult: walletFactoryStartResultP,
+      provisionWalletBridgeManager: provisionWalletBridgeManagerP,
     },
   },
   options,
@@ -23,13 +30,28 @@ export const upgradeProvisionPool = async (
   const { provisionPoolRef } = options.options;
 
   assert(provisionPoolRef.bundleID);
-  console.log(`PROVISION POOL BUNDLE ID: `, provisionPoolRef.bundleID);
+  trace(`PROVISION POOL BUNDLE ID: `, provisionPoolRef);
 
-  const [provisionPoolStartResult, instancePrivateArgs] = await Promise.all([
+  const [
+    provisionPoolStartResult,
+    instancePrivateArgs,
+    namesByAddressAdmin,
+    walletFactoryStartResult,
+    provisionWalletBridgeManager,
+  ] = await Promise.all([
     provisionPoolStartResultP,
     instancePrivateArgsP,
+    namesByAddressAdminP,
+    walletFactoryStartResultP,
+    provisionWalletBridgeManagerP,
   ]);
-  const { adminFacet, instance } = provisionPoolStartResult;
+  const {
+    adminFacet,
+    instance,
+    creatorFacet: ppCreatorFacet,
+    publicFacet: ppPublicFacet,
+  } = provisionPoolStartResult;
+  const { creatorFacet: wfCreatorFacet } = walletFactoryStartResult;
 
   const [originalPrivateArgs, poserInvitation] = await Promise.all([
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -38,9 +60,16 @@ export const upgradeProvisionPool = async (
     E(electorateCreatorFacet).getPoserInvitation(),
   ]);
 
+  const params = await E(ppPublicFacet).getGovernedParams();
+  const governedParamOverrides = harden({
+    PerAccountInitialAmount: params.PerAccountInitialAmount.value,
+  });
+  trace('governedParamOverrides: ', { governedParamOverrides });
+
   const newPrivateArgs = harden({
     ...originalPrivateArgs,
     initialPoserInvitation: poserInvitation,
+    governedParamOverrides,
   });
 
   const upgradeResult = await E(adminFacet).upgradeContract(
@@ -48,7 +77,25 @@ export const upgradeProvisionPool = async (
     newPrivateArgs,
   );
 
-  console.log('ProvisionPool upgraded: ', upgradeResult);
+  trace('ProvisionPool upgraded: ', upgradeResult);
+
+  const references = {
+    bankManager,
+    namesByAddressAdmin,
+    walletFactory: wfCreatorFacet,
+  };
+
+  trace('Calling setReferences with: ', references);
+  await E(ppCreatorFacet).setReferences(references);
+
+  trace('Creating bridgeHandler...');
+  const bridgeHandler = await E(ppCreatorFacet).makeHandler();
+
+  trace('Setting new bridgeHandler...');
+  // @ts-expect-error casting
+  await E(provisionWalletBridgeManager).setHandler(bridgeHandler);
+
+  trace('Done.');
 };
 
 export const getManifestForUpgradingProvisionPool = (
@@ -61,6 +108,10 @@ export const getManifestForUpgradingProvisionPool = (
         economicCommitteeCreatorFacet: true,
         instancePrivateArgs: true,
         provisionPoolStartResult: true,
+        bankManager: true,
+        namesByAddressAdmin: true,
+        walletFactoryStartResult: true,
+        provisionWalletBridgeManager: true,
       },
       produce: {},
     },