@agoric/builders 0.2.0-u18.5 → 0.2.0-u18.6

package/scripts/testing/publish-test-info.js

@@ -0,0 +1,79 @@
+import { makeTracer } from '@agoric/internal';
+import { E, Far } from '@endo/far';
+import { makeMarshal } from '@endo/marshal';
+
+const trace = makeTracer('PublishTestInfo');
+const { Fail } = assert;
+
+/**
+ * @param {BootstrapPowers} powers
+ */
+export const publishTestInfo = async powers => {
+  const {
+    consume: { agoricNamesAdmin, chainStorage: chainStorageP },
+  } = powers;
+
+  const chainStorage = await chainStorageP;
+  if (!chainStorage) {
+    trace('no chain storage, not registering chain info');
+    return;
+  }
+
+  trace('publishing testInfo');
+  const agoricNamesNode = E(chainStorage).makeChildNode('agoricNames');
+  const testInfoNode = E(agoricNamesNode).makeChildNode('testInfo');
+  const { nameAdmin } = await E(agoricNamesAdmin).provideChild('testInfo');
+
+  trace('registering onUpdate...');
+  await E(nameAdmin).onUpdate(
+    Far('chain info writer', {
+      write(entries) {
+        const marshalData = makeMarshal(_val => Fail`data only`);
+        const value = JSON.stringify(marshalData.toCapData(entries));
+        void E(testInfoNode)
+          .setValue(value)
+          .catch(() =>
+            console.log('cannot update vstorage after write to testInfo'),
+          );
+      },
+    }),
+  );
+
+  trace('writing to testInfo...');
+  await E(nameAdmin).update('agoric', {
+    isAwesome: 'yes',
+    tech: ['HardenedJs', 'Orchestration', 'Async_Execution'],
+  });
+
+  trace('Done.');
+};
+
+export const getManifestForPublishTestInfo = () => {
+  return {
+    manifest: {
+      [publishTestInfo.name]: {
+        consume: {
+          agoricNamesAdmin: true,
+          chainStorage: true,
+        },
+      },
+    },
+  };
+};
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async () =>
+  harden({
+    // Somewhat unorthodox, source the exports from this builder module
+    sourceSpec: '@agoric/builders/scripts/testing/publish-test-info.js',
+    getManifestCall: ['getManifestForPublishTestInfo'],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  // import dynamically so the module can work in CoreEval environment
+  const dspModule = await import('@agoric/deploy-script-support');
+  const { makeHelpers } = dspModule;
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('publish-test-info', defaultProposalBuilder);
+};

package/scripts/testing/recorded-retired-instances.js

@@ -33,9 +33,18 @@ export const testRecordedRetiredInstances = async ({
   );
   assert(committeeIDs);
   assert(committeeIDs.length === 1);
+  trace('found committeeIDs', committeeIDs);
+
   const committeeInstance = retiredContractInstances.get(committeeIDs[0]);
   assert(await E(contractKits).get(committeeInstance));
 
+  const charterIDs = [...retiredContractInstances.keys()].filter(k =>
+    k.startsWith('econCommitteeCharter'),
+  );
+  assert(charterIDs);
+  assert(charterIDs.length === 1);
+  trace('found charterID', charterIDs);
+
   trace('done');
 };
 harden(testRecordedRetiredInstances);

package/scripts/testing/register-interchain-bank-assets.js

@@ -0,0 +1,199 @@
+/**
+ * @file register-interchain-bank-assets.js Core Eval
+ *
+ * Used to populate vbank in testing environments.
+ */
+import { AssetKind } from '@agoric/ertp';
+import { makeTracer } from '@agoric/internal';
+import { E } from '@endo/far';
+import { makeMarshal } from '@endo/marshal';
+
+const { Fail } = assert;
+
+const trace = makeTracer('RegisterInterchainBankAssets', true);
+
+/** @import {Board} from '@agoric/vats'; */
+
+/**
+ * @typedef {object} InterchainAssetOptions
+ * @property {string} denom
+ * @property {number} decimalPlaces
+ * @property {string} issuerName
+ * @property {string} keyword - defaults to `issuerName` if not provided
+ * @property {string} [proposedName] - defaults to `issuerName` if not provided
+ */
+
+// vstorage paths under published.*
+const BOARD_AUX = 'boardAux';
+
+const marshalData = makeMarshal(_val => Fail`data only`);
+
+/**
+ * Make a storage node for auxiliary data for a value on the board.
+ *
+ * @param {ERef<StorageNode>} chainStorage
+ * @param {string} boardId
+ */
+const makeBoardAuxNode = async (chainStorage, boardId) => {
+  const boardAux = E(chainStorage).makeChildNode(BOARD_AUX);
+  return E(boardAux).makeChildNode(boardId);
+};
+
+/**
+ * see `publishAgoricBrandsDisplayInfo` {@link @agoric/smart-wallet/proposals/upgrade-walletFactory-proposal.js}
+ *
+ * @param {ERef<StorageNode>} chainStorage
+ * @param {ERef<Board>} board
+ * @param {Brand<'nat'>} brand
+ */
+const publishBrandInfo = async (chainStorage, board, brand) => {
+  const [boardId, displayInfo, allegedName] = await Promise.all([
+    E(board).getId(brand),
+    E(brand).getDisplayInfo(),
+    E(brand).getAllegedName(),
+  ]);
+  const node = makeBoardAuxNode(chainStorage, boardId);
+  const aux = marshalData.toCapData(harden({ allegedName, displayInfo }));
+  await E(node).setValue(JSON.stringify(aux));
+};
+
+/**
+ * @param {BootstrapPowers} powers
+ * @param {object} config
+ * @param {object} config.options
+ * @param {InterchainAssetOptions[]} config.options.assets
+ */
+export const publishInterchainAssets = async (
+  {
+    consume: {
+      agoricNamesAdmin,
+      bankManager,
+      board,
+      chainStorage,
+      startUpgradable,
+    },
+    brand: { produce: produceBrands },
+    issuer: { produce: produceIssuers },
+    installation: {
+      consume: { mintHolder },
+    },
+  },
+  { options: { assets } },
+) => {
+  trace(`${publishInterchainAssets.name} starting...`);
+  trace(assets);
+  await null;
+  for (const interchainAssetOptions of assets) {
+    const {
+      denom,
+      decimalPlaces,
+      issuerName,
+      keyword = issuerName,
+      proposedName = issuerName,
+    } = interchainAssetOptions;
+
+    trace('interchainAssetOptions', {
+      denom,
+      decimalPlaces,
+      issuerName,
+      keyword,
+      proposedName,
+    });
+
+    assert.typeof(denom, 'string');
+    assert.typeof(decimalPlaces, 'number');
+    assert.typeof(keyword, 'string');
+    assert.typeof(issuerName, 'string');
+    assert.typeof(proposedName, 'string');
+
+    const terms = {
+      keyword: issuerName, // "keyword" is a misnomer in mintHolder terms
+      assetKind: AssetKind.NAT,
+      displayInfo: {
+        decimalPlaces,
+        assetKind: AssetKind.NAT,
+      },
+    };
+    const { creatorFacet: mint, publicFacet: issuer } = await E(
+      startUpgradable,
+    )({
+      installation: mintHolder,
+      label: issuerName,
+      privateArgs: undefined,
+      terms,
+    });
+
+    const brand = await E(issuer).getBrand();
+    const kit = /** @type {IssuerKit<'nat'>} */ ({ mint, issuer, brand });
+
+    /**
+     * `addAssetToVault.js` will register the issuer with the `reserveKit`,
+     * but we don't need to do that here.
+     */
+
+    await Promise.all([
+      E(E(agoricNamesAdmin).lookupAdmin('issuer')).update(issuerName, issuer),
+      E(E(agoricNamesAdmin).lookupAdmin('brand')).update(issuerName, brand),
+      // triggers benign UnhandledPromiseRejection 'Error: keyword "ATOM" must
+      // be unique' in provisionPool in testing environments
+      E(bankManager).addAsset(denom, issuerName, proposedName, kit),
+    ]);
+
+    // publish brands and issuers to Bootstrap space for use in proposals
+    produceBrands[keyword].reset();
+    produceIssuers[keyword].reset();
+    produceBrands[keyword].resolve(brand);
+    produceIssuers[keyword].resolve(issuer);
+
+    // publish brand info / boardAux for offer legibility
+    await publishBrandInfo(
+      // @ts-expect-error 'Promise<StorageNode | null>' is not assignable to
+      // parameter of type 'ERef<StorageNode>'
+      chainStorage,
+      board,
+      brand,
+    );
+  }
+  trace(`${publishInterchainAssets.name} complete`);
+};
+
+/**
+ * @param {unknown} _powers
+ * @param {{ assets: InterchainAssetOptions[] }} options
+ */
+export const getManifestCall = (_powers, options) => {
+  /** @type {Record<string, true>} */
+  const IssuerKws = options.assets.reduce(
+    /**
+     * @param {Record<string, true>} acc
+     * @param {InterchainAssetOptions} assetOptions
+     */
+    (acc, { issuerName }) => Object.assign(acc, { [issuerName]: true }),
+    {},
+  );
+  harden(IssuerKws);
+
+  return {
+    manifest: {
+      [publishInterchainAssets.name]: {
+        consume: {
+          agoricNamesAdmin: true,
+          bankManager: true,
+          board: true,
+          chainStorage: true,
+          startUpgradable: true,
+        },
+        brand: {
+          produce: IssuerKws,
+        },
+        issuer: {
+          produce: IssuerKws,
+        },
+        installation: {
+          consume: { mintHolder: true },
+        },
+      },
+    },
+    options,
+  };
+};

package/scripts/testing/replace-feeDistributor-short.js

@@ -0,0 +1,33 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+import { getManifestForReplaceFeeDistributor } from '@agoric/inter-protocol/src/proposals/replace-fee-distributor.js';
+
+/**
+ * @file
+ * a Variant of ../inter-protocol/replace-feeDistributor.js that shortens the
+ * collectionInterval for testing
+ */
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async (_, opts) => {
+  console.log('feeDist  OPTS', opts);
+  return harden({
+    sourceSpec:
+      '@agoric/inter-protocol/src/proposals/replace-fee-distributor.js',
+    getManifestCall: [getManifestForReplaceFeeDistributor.name, { ...opts }],
+  });
+};
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+
+  await writeCoreEval('replace-feeDistributor-testing', utils =>
+    defaultProposalBuilder(utils, {
+      collectionInterval: 30n,
+      keywordShares: {
+        RewardDistributor: 0n,
+        Reserve: 1n,
+      },
+    }),
+  );
+};

package/scripts/testing/test-upgraded-board.js

@@ -0,0 +1,15 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+import { getManifestForTestUpgradedBoard } from '@agoric/vats/src/proposals/testUpgradedBoard.js';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async () =>
+  harden({
+    sourceSpec: '@agoric/vats/src/proposals/testUpgradedBoard.js',
+    getManifestCall: [getManifestForTestUpgradedBoard.name],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('testUpgradedBoard', defaultProposalBuilder);
+};

package/scripts/testing/{fix-buggy-sendAnywhere.js → upgrade-send-anywhere.js}

@@ -7,14 +7,14 @@ import {
   makeTracer,
   NonNullish,
 } from '@agoric/internal';
-import { E, Far } from '@endo/far';
+import { E } from '@endo/far';
 
 /// <reference types="@agoric/vats/src/core/types-ambient"/>
 /**
  * @import {Installation, Instance} from '@agoric/zoe/src/zoeService/utils.js';
  */
 
-const trace = makeTracer('FixBuggySA', true);
+const trace = makeTracer('UpgradeSA', true);
 
 /**
  * @import {start as StartFn} from '@agoric/orchestration/src/examples/send-anywhere.contract.js';
@@ -30,7 +30,7 @@ const trace = makeTracer('FixBuggySA', true);
  * }} powers
  * @param {...any} rest
  */
-export const fixSendAnywhere = async (
+export const upgradeSendAnywhere = async (
   {
     consume: {
       agoricNames,
@@ -45,7 +45,7 @@ export const fixSendAnywhere = async (
   },
   { options: { sendAnywhereRef } },
 ) => {
-  trace(fixSendAnywhere.name);
+  trace(upgradeSendAnywhere.name);
 
   const saInstance = await instances.consume.sendAnywhere;
   trace('saInstance', saInstance);
@@ -53,28 +53,24 @@ export const fixSendAnywhere = async (
 
   const marshaller = await E(board).getReadonlyMarshaller();
 
-  // This apparently pointless wrapper is to maintain structural parity
-  // with the buggy core-eval's wrapper to make lookup() hang.
-  const agoricNamesResolves = Far('agoricNames that resolves', {
-    lookup: async (...args) => {
-      return E(agoricNames).lookup(...args);
-    },
-  });
-
   const privateArgs = await deeplyFulfilledObject(
     harden({
-      agoricNames: agoricNamesResolves,
+      agoricNames,
       localchain,
       marshaller,
       orchestrationService: cosmosInterchainService,
       storageNode: E(NonNullish(await chainStorage)).makeChildNode(
-        'sendAnywhere',
+        'send-anywhere',
       ),
       timerService: chainTimerService,
+      // undefined so `registerKnownChainsAndAssets` does not run again
+      chainInfo: undefined,
+      assetInfo: undefined,
     }),
   );
 
   trace('upgrading...');
+  trace('ref', sendAnywhereRef);
   await E(saKit.adminFacet).upgradeContract(
     sendAnywhereRef.bundleID,
     privateArgs,
@@ -82,13 +78,13 @@ export const fixSendAnywhere = async (
 
   trace('done');
 };
-harden(fixSendAnywhere);
+harden(upgradeSendAnywhere);
 
 export const getManifestForValueVow = ({ restoreRef }, { sendAnywhereRef }) => {
   console.log('sendAnywhereRef', sendAnywhereRef);
   return {
     manifest: {
-      [fixSendAnywhere.name]: {
+      [upgradeSendAnywhere.name]: {
         consume: {
           agoricNames: true,
           board: true,
@@ -120,7 +116,7 @@ export const getManifestForValueVow = ({ restoreRef }, { sendAnywhereRef }) => {
 export const defaultProposalBuilder = async ({ publishRef, install }) =>
   harden({
     // Somewhat unorthodox, source the exports from this builder module
-    sourceSpec: '@agoric/builders/scripts/testing/fix-buggy-sendAnywhere.js',
+    sourceSpec: '@agoric/builders/scripts/testing/upgrade-send-anywhere.js',
     getManifestCall: [
       'getManifestForValueVow',
       {
@@ -139,5 +135,5 @@ export default async (homeP, endowments) => {
   const dspModule = await import('@agoric/deploy-script-support');
   const { makeHelpers } = dspModule;
   const { writeCoreEval } = await makeHelpers(homeP, endowments);
-  await writeCoreEval(fixSendAnywhere.name, defaultProposalBuilder);
+  await writeCoreEval(upgradeSendAnywhere.name, defaultProposalBuilder);
 };

package/scripts/testing/upgrade-vaultFactory.js

@@ -0,0 +1,21 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }) =>
+  harden({
+    sourceSpec: '@agoric/vats/src/proposals/upgrade-vaultFactory-proposal.js',
+    getManifestCall: [
+      'getManifestForVaultFactoryUpgrade',
+      {
+        contractRef: publishRef(
+          install('@agoric/inter-protocol/src/vaultFactory/vaultFactory.js'),
+        ),
+      },
+    ],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('upgrade-vaults', defaultProposalBuilder);
+};

package/scripts/vats/terminate-governor-instance.js

@@ -0,0 +1,134 @@
+/**
+ * @file Terminate price-feed governor instances such as mainnet v110.
+ * Functions as both an off-chain builder and an on-chain core-eval.
+ */
+
+/// <reference types="@agoric/vats/src/core/types-ambient"/>
+
+import { E } from '@endo/far';
+
+const SELF = '@agoric/builders/scripts/vats/terminate-governor-instance.js';
+const USAGE = `Usage: agoric run /path/to/terminate-governor-instance.js \\
+  <$governorInstanceHandleBoardID:$instanceKitLabel>...`;
+
+const repr = val =>
+  typeof val === 'string' || (typeof val === 'object' && val !== null)
+    ? JSON.stringify(val)
+    : String(val);
+const defaultMakeError = (strings, ...subs) =>
+  Error(
+    strings.map((s, i) => `${i === 0 ? '' : repr(subs[i - 1])}${s}`).join(''),
+  );
+const makeUsageError = (strings, ...subs) => {
+  const err = defaultMakeError(strings, ...subs);
+  console.error(err.message);
+  console.error(USAGE);
+  return err;
+};
+
+const rtarget = /^(?<boardID>board[0-9]+):(?<instanceKitLabel>.+)$/;
+/**
+ * @param {string[]} args
+ * @param {(strings: TemplateStringsArray | string[], ...subs: unknown[]) => Error} [makeError]
+ * @returns {Array<{boardID: string, instanceKitLabel: string}>}
+ */
+const parseTargets = (args = [], makeError = defaultMakeError) => {
+  if (!Array.isArray(args)) throw makeError`invalid targets: ${args}`;
+  /** @type {Array<{boardID: string, instanceKitLabel: string}>} */
+  const targets = [];
+  const badTargets = [];
+  for (const arg of args) {
+    const m = typeof arg === 'string' && arg.match(rtarget);
+    if (!m) {
+      badTargets.push(arg);
+    } else {
+      // @ts-expect-error cast
+      targets.push(m.groups);
+    }
+  }
+  if (badTargets.length !== 0) {
+    throw makeError`malformed target(s): ${badTargets}`;
+  } else if (targets.length === 0) {
+    throw makeError`no target(s)`;
+  }
+  return targets;
+};
+
+/**
+ * @param {BootstrapPowers} powers
+ * @param {{ options: { targetSpecifiers: string[] } }} config
+ */
+export const terminateGovernors = async (
+  { consume: { board, governedContractKits } },
+  { options: { targetSpecifiers } },
+) => {
+  const { Fail, quote: q } = assert;
+  const targets = parseTargets(targetSpecifiers, Fail);
+  const doneP = Promise.allSettled(
+    targets.map(async ({ boardID, instanceKitLabel }) => {
+      const logLabel = [boardID, instanceKitLabel];
+      const contractInstanceHandle = await E(board).getValue(boardID);
+      const instanceKit = await E(governedContractKits).get(
+        // @ts-expect-error TS2345 Property '[tag]' is missing
+        contractInstanceHandle,
+      );
+      console.log(
+        `${q(logLabel)} alleged governor contract instance kit`,
+        instanceKit,
+      );
+      const { label, governorAdminFacet, adminFacet } = instanceKit;
+      label === instanceKitLabel ||
+        Fail`${q(logLabel)} unexpected instanceKit label, got ${label} but wanted ${q(instanceKitLabel)}`;
+      (adminFacet && adminFacet !== governorAdminFacet) ||
+        Fail`${q(logLabel)} instanceKit adminFacet should have been present and different from governorAdminFacet but was ${adminFacet}`;
+      const reason = harden(Error(`core-eval terminating ${label} governor`));
+      await E(governorAdminFacet).terminateContract(reason);
+      console.log(`${q(logLabel)} terminated governor`);
+    }),
+  );
+  const results = await doneP;
+  const problems = targets.flatMap(({ boardID, instanceKitLabel }, i) => {
+    if (results[i].status === 'fulfilled') return [];
+    return [[boardID, instanceKitLabel, results[i].reason]];
+  });
+  if (problems.length !== 0) {
+    console.error('governor termination(s) failed', problems);
+    Fail`governor termination(s) failed: ${problems}`;
+  }
+};
+harden(terminateGovernors);
+
+export const getManifest = (_powers, targetSpecifiers) => {
+  parseTargets(targetSpecifiers);
+  return {
+    manifest: {
+      [terminateGovernors.name]: {
+        consume: { board: true, governedContractKits: true },
+      },
+    },
+    // Provide `terminateGovernors` a second argument like
+    // `{ options: { targetSpecifiers } }`.
+    options: { targetSpecifiers },
+  };
+};
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async (_utils, targetSpecifiers) => {
+  parseTargets(targetSpecifiers);
+  return harden({
+    sourceSpec: SELF,
+    getManifestCall: ['getManifest', targetSpecifiers],
+  });
+};
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { scriptArgs } = endowments;
+  parseTargets(scriptArgs, makeUsageError);
+  const dspModule = await import('@agoric/deploy-script-support');
+  const { makeHelpers } = dspModule;
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval(terminateGovernors.name, utils =>
+    defaultProposalBuilder(utils, scriptArgs),
+  );
+};

package/scripts/vats/upgrade-agoricNames.js

@@ -0,0 +1,21 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }) =>
+  harden({
+    sourceSpec: '@agoric/vats/src/proposals/upgrade-agoricNames-proposal.js',
+    getManifestCall: [
+      'getManifestForUpgradingAgoricNames',
+      {
+        agoricNamesRef: publishRef(
+          install('@agoric/vats/src/vat-agoricNames.js'),
+        ),
+      },
+    ],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { writeCoreProposal } = await makeHelpers(homeP, endowments);
+  await writeCoreProposal('upgrade-agoricNames', defaultProposalBuilder);
+};

package/scripts/vats/upgrade-asset-reserve.js

@@ -0,0 +1,21 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }) =>
+  harden({
+    sourceSpec: '@agoric/vats/src/proposals/upgrade-asset-reserve-proposal.js',
+    getManifestCall: [
+      'getManifestForUpgradingAssetReserve',
+      {
+        assetReserveRef: publishRef(
+          install('@agoric/inter-protocol/src/reserve/assetReserve.js'),
+        ),
+      },
+    ],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { writeCoreProposal } = await makeHelpers(homeP, endowments);
+  await writeCoreProposal('upgrade-asset-reserve', defaultProposalBuilder);
+};

package/scripts/vats/upgrade-board.js

@@ -0,0 +1,20 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+import { getManifestForUpgradingBoard } from '@agoric/vats/src/proposals/upgrade-board-proposal.js';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }) =>
+  harden({
+    sourceSpec: '@agoric/vats/src/proposals/upgrade-board-proposal.js',
+    getManifestCall: [
+      getManifestForUpgradingBoard.name,
+      {
+        boardRef: publishRef(install('@agoric/vats/src/vat-board.js')),
+      },
+    ],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('upgrade-board', defaultProposalBuilder);
+};