@agoric/builders 0.1.1-calypso-dev-84eb287.0

package/scripts/inter-protocol/init-core.js

@@ -0,0 +1,204 @@
+/* global process */
+/**
+ * @file can be run with `agoric deploy` after a chain is running (depends on
+ *   chain state) Only works with "local" chain and not sim-chain b/c it needs
+ *   governance votes (n/a on sim-chain).
+ */
+import { makeHelpers } from '@agoric/deploy-script-support';
+import { objectMap } from '@agoric/internal';
+
+import {
+  getManifestForInterProtocol,
+  getManifestForEconCommittee,
+  getManifestForMain,
+} from '@agoric/inter-protocol/src/proposals/core-proposal.js';
+import { makeInstallCache } from '@agoric/inter-protocol/src/proposals/utils.js';
+
+// TODO end inter-package filesystem references https://github.com/Agoric/agoric-sdk/issues/8178
+
+/** @type {Record<string, Record<string, [string, string]>>} */
+const installKeyGroups = {
+  econCommittee: {
+    contractGovernor: [
+      '@agoric/governance/src/contractGovernor.js',
+      '../../governance/bundles/bundle-contractGovernor.js',
+    ],
+    committee: [
+      '@agoric/governance/src/committee.js',
+      '../../governance/bundles/bundle-committee.js',
+    ],
+    binaryVoteCounter: [
+      '@agoric/governance/src/binaryVoteCounter.js',
+      '../../governance/bundles/bundle-binaryVoteCounter.js',
+    ],
+  },
+  main: {
+    auctioneer: [
+      '@agoric/inter-protocol/src/auction/auctioneer.js',
+      '../../inter-protocol/bundles/bundle-auctioneer.js',
+    ],
+    vaultFactory: [
+      '@agoric/inter-protocol/src/vaultFactory/vaultFactory.js',
+      '../../inter-protocol/bundles/bundle-vaultFactory.js',
+    ],
+    feeDistributor: [
+      '@agoric/inter-protocol/src/feeDistributor.js',
+      '../../inter-protocol/bundles/bundle-feeDistributor.js',
+    ],
+    reserve: [
+      '@agoric/inter-protocol/src/reserve/assetReserve.js',
+      '../../inter-protocol/bundles/bundle-reserve.js',
+    ],
+  },
+};
+
+/**
+ * @template I
+ * @template R
+ * @param {object} opts
+ * @param {(i: I) => R} opts.publishRef
+ * @param {(m: string, b: string, opts?: any) => I} opts.install
+ * @param {<T>(f: T) => T} [opts.wrapInstall]
+ * @param {object} [options]
+ * @param {{ committeeName?: string; committeeSize?: number }} [options.econCommitteeOptions]
+ */
+export const committeeProposalBuilder = async (
+  { publishRef, install: install0, wrapInstall },
+  { econCommitteeOptions } = {},
+) => {
+  const install = wrapInstall ? wrapInstall(install0) : install0;
+
+  /** @param {Record<string, [string, string]>} group */
+  const publishGroup = group =>
+    objectMap(group, ([mod, bundle]) =>
+      publishRef(install(mod, bundle, { persist: true })),
+    );
+  return harden({
+    sourceSpec: '@agoric/inter-protocol/src/proposals/core-proposal.js',
+    getManifestCall: [
+      getManifestForEconCommittee.name,
+      {
+        econCommitteeOptions,
+        installKeys: {
+          ...publishGroup(installKeyGroups.econCommittee),
+        },
+      },
+    ],
+  });
+};
+
+/**
+ * @template I
+ * @template R
+ * @param {object} opts
+ * @param {(i: I) => R} opts.publishRef
+ * @param {(m: string, b: string, opts?: any) => I} opts.install
+ * @param {<T>(f: T) => T} [opts.wrapInstall]
+ */
+export const mainProposalBuilder = async ({
+  publishRef,
+  install: install0,
+  wrapInstall,
+}) => {
+  const { VAULT_FACTORY_CONTROLLER_ADDR } = process.env;
+
+  const install = wrapInstall ? wrapInstall(install0) : install0;
+
+  const persist = true;
+  /** @param {Record<string, [string, string]>} group */
+  const publishGroup = group =>
+    objectMap(group, ([mod, bundle]) =>
+      publishRef(install(mod, bundle, { persist })),
+    );
+  return harden({
+    sourceSpec: '@agoric/inter-protocol/src/proposals/core-proposal.js',
+    getManifestCall: [
+      getManifestForMain.name,
+      {
+        vaultFactoryControllerAddress: VAULT_FACTORY_CONTROLLER_ADDR,
+        installKeys: {
+          ...publishGroup(installKeyGroups.main),
+        },
+      },
+    ],
+  });
+};
+
+// Build proposal for sim-chain etc.
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async (
+  { publishRef, install },
+  options = {},
+  { env = process.env } = {},
+) => {
+  /** @param {string | undefined} s */
+  const optBigInt = s => s && BigInt(s);
+  const {
+    vaultFactoryControllerAddress = env.VAULT_FACTORY_CONTROLLER_ADDR,
+    minInitialPoolLiquidity = env.MIN_INITIAL_POOL_LIQUIDITY,
+    referencedUi,
+    anchorOptions: {
+      anchorDenom = env.ANCHOR_DENOM,
+      anchorDecimalPlaces = '6',
+      anchorKeyword = 'AUSD',
+      anchorProposedName = anchorKeyword,
+      initialPrice = undefined,
+    } = {},
+    econCommitteeOptions: {
+      committeeSize: econCommitteeSize = env.ECON_COMMITTEE_SIZE || '3',
+    } = {},
+  } = options;
+
+  /** @param {Record<string, [string, string]>} group */
+  const publishGroup = group =>
+    objectMap(group, ([mod, bundle]) => publishRef(install(mod, bundle)));
+
+  const anchorOptions = anchorDenom && {
+    denom: anchorDenom,
+    decimalPlaces: parseInt(anchorDecimalPlaces, 10),
+    initialPrice,
+    keyword: anchorKeyword,
+    proposedName: anchorProposedName,
+  };
+
+  const econCommitteeOptions = {
+    committeeSize: parseInt(econCommitteeSize, 10),
+  };
+
+  return harden({
+    sourceSpec: '@agoric/inter-protocol/src/proposals/core-proposal.js',
+    getManifestCall: [
+      getManifestForInterProtocol.name,
+      {
+        vaultFactoryControllerAddress,
+        minInitialPoolLiquidity: optBigInt(minInitialPoolLiquidity),
+        referencedUi,
+        anchorOptions,
+        econCommitteeOptions,
+        installKeys: {
+          ...publishGroup(installKeyGroups.econCommittee),
+          ...publishGroup(installKeyGroups.main),
+        },
+      },
+    ],
+  });
+};
+
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+
+  const tool = await makeInstallCache(homeP, {
+    loadBundle: spec => import(spec),
+  });
+  await Promise.all([
+    writeCoreEval('gov-econ-committee', opts =>
+      // @ts-expect-error XXX makeInstallCache types
+      committeeProposalBuilder({ ...opts, wrapInstall: tool.wrapInstall }),
+    ),
+    writeCoreEval('gov-amm-vaults-etc', opts =>
+      // @ts-expect-error XXX makeInstallCache types
+      mainProposalBuilder({ ...opts, wrapInstall: tool.wrapInstall }),
+    ),
+  ]);
+  await tool.saveCache();
+};

package/scripts/inter-protocol/invite-committee-core.js

@@ -0,0 +1,42 @@
+/* global process */
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+import { getManifestForInviteCommittee } from '@agoric/inter-protocol/src/proposals/committee-proposal.js';
+
+// Build proposal for sim-chain etc.
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async (
+  { publishRef, install },
+  options = {},
+) => {
+  const {
+    ECON_COMMITTEE_ADDRESSES = process.env.ECON_COMMITTEE_ADDRESSES,
+    voterAddresses = JSON.parse(ECON_COMMITTEE_ADDRESSES),
+  } = options;
+
+  assert(voterAddresses, 'ECON_COMMITTEE_ADDRESSES is required');
+
+  return harden({
+    sourceSpec: '@agoric/inter-protocol/src/proposals/committee-proposal.js',
+    getManifestCall: [
+      getManifestForInviteCommittee.name,
+      {
+        voterAddresses,
+        econCommitteeCharterRef: publishRef(
+          install(
+            '@agoric/inter-protocol/src/econCommitteeCharter.js',
+            '../bundles/bundle-econCommitteeCharter.js',
+            {
+              persist: true,
+            },
+          ),
+        ),
+      },
+    ],
+  });
+};
+
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('gov-invite-committee', defaultProposalBuilder);
+};

package/scripts/inter-protocol/manual-price-feed.js

@@ -0,0 +1,123 @@
+import { E } from '@endo/far';
+import { deeplyFulfilled } from '@endo/marshal';
+import { makeNotifierFromAsyncIterable } from '@agoric/notifier';
+
+import process from 'process';
+
+/**
+ * After extracting the oracleAdmins to entries in home.scratch, you can use one
+ * from the REPL like:
+ *
+ *     lookup('agoricNames', 'oracleBrand', 'ATOM').then(brand => atom = brand)
+ *     -> [Object Alleged: ATOM brand]{}
+ *     lookup('agoricNames', 'oracleBrand', 'USD').then(brand => usd = brand)
+ *     -> [Object Alleged: USD brand]{}
+ *     pa = home.priceAuthority
+ *      -> [Object Alleged: PriceAuthority]{}
+ *     qn = E(pa).makeQuoteNotifier({ value: 1n * 10n ** 6n, brand: atom }, usd)
+ *     -> [Object Alleged: QuoteNotifier]{}
+ *     oa = E(home.scratch).get("offerResult unknown#1652669688625")
+ *     -> [Object Alleged: OracleAdmin]{}
+ *     E(oa).pushResult('19.37')
+ *     E(qn).getUpdateSince()
+ *
+ * @typedef {{
+ *   board: import('@agoric/vats').Board;
+ *   chainTimerService;
+ *   scratch;
+ *   zoe;
+ * }} Home
+ * @param {Promise<Home>} homePromise
+ * @param {object} root0
+ * @param {(...path: string[]) => Promise<any>} root0.lookup A promise for the
+ *   references available from REPL home
+ */
+export default async function priceAuthorityFromNotifier(
+  homePromise,
+  { lookup },
+) {
+  const { AGGREGATOR_INSTANCE_LOOKUP } = process.env;
+
+  // Let's wait for the promise to resolve.
+  const home = await deeplyFulfilled(homePromise);
+
+  let aggregatorInstance;
+  if (AGGREGATOR_INSTANCE_LOOKUP) {
+    aggregatorInstance = await lookup(JSON.parse(AGGREGATOR_INSTANCE_LOOKUP));
+  }
+
+  if (!aggregatorInstance) {
+    console.log('Autodetecting aggregator instance...');
+    const purse = E(home.wallet).getPurse('Default Zoe invite purse');
+    const { value } = await E(purse).getCurrentAmount();
+    const invitations = value.filter(
+      ({ description }) => description === 'oracle invitation',
+    );
+    if (invitations.length > 1) {
+      console.error('Multiple oracle invitations found', invitations);
+      throw Error('You need an AGGREGATOR_INSTANCE_LOOKUP to disambiguate');
+    }
+    if (invitations.length === 0) {
+      console.error(
+        'No oracle invitations found; you may need an AGGREGATOR_INSTANCE_LOOKUP',
+      );
+    } else {
+      console.log('Found oracle invitation', invitations);
+      aggregatorInstance = invitations[0].instance;
+    }
+  }
+
+  if (!aggregatorInstance) {
+    return;
+  }
+
+  const offer = {
+    id: Date.now(),
+    proposalTemplate: {},
+    invitationQuery: {
+      description: 'oracle invitation',
+      instance: aggregatorInstance,
+    },
+  };
+
+  console.log('Getting wallet bridge...');
+  const bridge = await E(home.wallet).getBridge();
+
+  // Consume an aggregator invitation for this instance.
+  await E(bridge)
+    .addOffer(offer)
+    .then(
+      () =>
+        console.log(
+          `Please approve your wallet's proposal to connect the aggregator ${aggregatorInstance}...`,
+        ),
+      () => {},
+    );
+
+  const walletAdmin = E(home.wallet).getAdminFacet();
+
+  console.log('=====================================================');
+  console.log('=== Extracting oracleAdmins from price feed offers...');
+  console.log('=== Control-C to cancel');
+  const offerIt = E(walletAdmin).getOffersNotifier();
+  for await (const offers of makeNotifierFromAsyncIterable(offerIt)) {
+    // console.log(offers);
+    const completed = offers
+      .filter(
+        ({ status, invitationQuery: { instance } }) =>
+          status === 'complete' && instance === aggregatorInstance,
+      )
+      .map(async ({ id }) => {
+        const orKey = `offerResult ${id}`;
+        await E(home.scratch).set(
+          orKey,
+          E(home.wallet).lookup('offerResult', id),
+        );
+        console.log(
+          'Use this oracleAdmin:',
+          `E(home.scratch).get(${JSON.stringify(orKey)})`,
+        );
+      });
+    await Promise.all(completed);
+  }
+}

package/scripts/inter-protocol/price-feed-core.js

@@ -0,0 +1,104 @@
+/* global process */
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+export const DEFAULT_CONTRACT_TERMS = {
+  POLL_INTERVAL: 30n,
+  maxSubmissionCount: 1000,
+  minSubmissionCount: 2,
+  restartDelay: 1, // the number of rounds an Oracle has to wait before they can initiate another round
+  timeout: 10, // in seconds according to chainTimerService
+  minSubmissionValue: 1n,
+  maxSubmissionValue: 2n ** 256n,
+};
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async (
+  { publishRef, install },
+  options = {},
+) => {
+  const {
+    brandIn,
+    brandOut,
+    contractTerms = DEFAULT_CONTRACT_TERMS,
+    AGORIC_INSTANCE_NAME,
+    IN_BRAND_LOOKUP,
+    OUT_BRAND_LOOKUP,
+    IN_BRAND_NAME = IN_BRAND_LOOKUP[IN_BRAND_LOOKUP.length - 1],
+    OUT_BRAND_NAME = OUT_BRAND_LOOKUP[OUT_BRAND_LOOKUP.length - 1],
+    oracleAddresses,
+    ...optionsRest
+  } = options;
+
+  assert(AGORIC_INSTANCE_NAME, 'AGORIC_INSTANCE_NAME is required');
+  assert(Array.isArray(oracleAddresses), 'oracleAddresses array is required');
+
+  if (!brandIn) {
+    assert.equal(IN_BRAND_LOOKUP[0], 'agoricNames');
+    assert(IN_BRAND_NAME);
+  }
+  if (!brandOut) {
+    assert.equal(OUT_BRAND_LOOKUP[0], 'agoricNames');
+    assert(OUT_BRAND_NAME);
+  }
+
+  return harden({
+    sourceSpec: '@agoric/inter-protocol/src/proposals/price-feed-proposal.js',
+    getManifestCall: [
+      'getManifestForPriceFeed',
+      {
+        ...optionsRest,
+        AGORIC_INSTANCE_NAME,
+        contractTerms,
+        oracleAddresses,
+        IN_BRAND_LOOKUP,
+        OUT_BRAND_LOOKUP,
+        IN_BRAND_NAME,
+        OUT_BRAND_NAME,
+        brandInRef: brandIn && publishRef(brandIn),
+        brandOutRef: brandOut && publishRef(brandOut),
+        priceAggregatorRef: publishRef(
+          install(
+            '@agoric/inter-protocol/src/price/fluxAggregatorContract.js',
+            '../bundles/bundle-fluxAggregatorKit.js',
+          ),
+        ),
+      },
+    ],
+  });
+};
+
+export const createGov = async (homeP, endowments) => {
+  const { lookup } = endowments;
+
+  const {
+    AGORIC_INSTANCE_NAME,
+    IN_BRAND_DECIMALS = '6',
+    IN_BRAND_LOOKUP = JSON.stringify(['wallet', 'brand', 'BLD']),
+    OUT_BRAND_DECIMALS = '6',
+    OUT_BRAND_LOOKUP = JSON.stringify(['agoricNames', 'oracleBrand', 'USD']),
+    ORACLE_ADDRESSES,
+  } = process.env;
+
+  assert(AGORIC_INSTANCE_NAME, 'AGORIC_INSTANCE_NAME is required');
+  assert(ORACLE_ADDRESSES, 'ORACLE_ADDRESSES is required');
+
+  const oracleAddresses = ORACLE_ADDRESSES.split(',');
+
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+
+  const inLookup = JSON.parse(IN_BRAND_LOOKUP);
+  const outLookup = JSON.parse(OUT_BRAND_LOOKUP);
+
+  const proposalBuilder = powers =>
+    defaultProposalBuilder(powers, {
+      AGORIC_INSTANCE_NAME,
+      IN_BRAND_DECIMALS: parseInt(IN_BRAND_DECIMALS, 10),
+      OUT_BRAND_DECIMALS: parseInt(OUT_BRAND_DECIMALS, 10),
+      oracleAddresses,
+      brandIn: lookup(inLookup).catch(() => undefined),
+      brandOut: lookup(outLookup).catch(() => undefined),
+    });
+  await writeCoreEval('gov-price-feed', proposalBuilder); // gov-price-feed.js gov-price-feed-permit.json
+};
+
+export default createGov;

package/scripts/orchestration/init-stakeAtom.js

@@ -0,0 +1,23 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }) => {
+  return harden({
+    sourceSpec: '@agoric/orchestration/src/proposals/start-stakeAtom.js',
+    getManifestCall: [
+      'getManifestForStakeAtom',
+      {
+        installKeys: {
+          stakeIca: publishRef(
+            install('@agoric/orchestration/src/examples/stakeIca.contract.js'),
+          ),
+        },
+      },
+    ],
+  });
+};
+
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('start-stakeAtom', defaultProposalBuilder);
+};

package/scripts/orchestration/init-stakeBld.js

@@ -0,0 +1,23 @@
+// @ts-check
+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/orchestration/src/proposals/start-stakeBld.js',
+    getManifestCall: [
+      'getManifestForStakeBld',
+      {
+        installKeys: {
+          stakeBld: publishRef(
+            install('@agoric/orchestration/src/examples/stakeBld.contract.js'),
+          ),
+        },
+      },
+    ],
+  });
+
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('start-stakeBld', defaultProposalBuilder);
+};

package/scripts/orchestration/init-stakeOsmo.js

@@ -0,0 +1,23 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }) => {
+  return harden({
+    sourceSpec: '@agoric/orchestration/src/proposals/start-stakeOsmo.js',
+    getManifestCall: [
+      'getManifestForStakeOsmo',
+      {
+        installKeys: {
+          stakeIca: publishRef(
+            install('@agoric/orchestration/src/examples/stakeIca.contract.js'),
+          ),
+        },
+      },
+    ],
+  });
+};
+
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('start-stakeOsmo', defaultProposalBuilder);
+};

package/scripts/pegasus/init-core.js

@@ -0,0 +1,23 @@
+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/pegasus/src/proposals/core-proposal.js',
+    getManifestCall: [
+      'getManifestForPegasus',
+      {
+        pegasusRef: publishRef(
+          install(
+            '@agoric/pegasus/src/contract.js',
+            '../bundles/bundle-pegasus.js',
+          ),
+        ),
+      },
+    ],
+  });
+
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('gov-pegasus', defaultProposalBuilder);
+};

package/scripts/smart-wallet/build-game1-start.js

@@ -0,0 +1,33 @@
+/**
+ * @file Proposal Builder: Start Game with non-vbank Place NFT asset
+ *
+ * Usage:
+ *   agoric run build-game1-start.js
+ */
+
+import { makeHelpers } from '@agoric/deploy-script-support';
+import { getManifestForGame1 } from '@agoric/smart-wallet/test/start-game1-proposal.js';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+const game1ProposalBuilder = async ({ publishRef, install }) => {
+  return harden({
+    sourceSpec: '@agoric/smart-wallet/test/start-game1-proposal.js',
+    getManifestCall: [
+      getManifestForGame1.name,
+      {
+        game1Ref: publishRef(
+          install(
+            '@agoric/smart-wallet/test/gameAssetContract.js',
+            '../bundles/bundle-game1.js',
+            { persist: true },
+          ),
+        ),
+      },
+    ],
+  });
+};
+
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('start-game1', game1ProposalBuilder);
+};

package/scripts/smart-wallet/build-wallet-factory2-upgrade.js

@@ -0,0 +1,28 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+/**
+ * @file
+ *   `agoric run scripts/smart-wallet/build-wallet-factory2-upgrade.js`
+ * produces a proposal and permit file, as well as the necessary bundles. It
+ * also prints helpful instructions for copying the files and installing them.
+ */
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }) =>
+  harden({
+    sourceSpec:
+      '@agoric/smart-wallet/src/proposals/upgrade-wallet-factory2-proposal.js',
+    getManifestCall: [
+      'getManifestForUpgradeWallet',
+      {
+        walletRef: publishRef(
+          install('@agoric/smart-wallet/src/walletFactory.js'),
+        ),
+      },
+    ],
+  });
+
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('upgrade-wallet-factory', defaultProposalBuilder);
+};

package/scripts/smart-wallet/build-walletFactory-upgrade.js

@@ -0,0 +1,34 @@
+/**
+ * @file Proposal Builder: Upgrade walletFactory
+ *
+ * Usage:
+ *   agoric run build-walletFactory-upgrade.js
+ */
+
+import { makeHelpers } from '@agoric/deploy-script-support';
+import { getManifestForUpgrade } from '@agoric/smart-wallet/src/proposals/upgrade-walletFactory-proposal.js';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }) => {
+  return harden({
+    sourceSpec:
+      '@agoric/smart-wallet/src/proposals/upgrade-walletFactory-proposal.js',
+    getManifestCall: [
+      getManifestForUpgrade.name,
+      {
+        walletFactoryRef: publishRef(
+          install(
+            '@agoric/smart-wallet/src/walletFactory.js',
+            '../bundles/bundle-walletFactory.js',
+            { persist: true },
+          ),
+        ),
+      },
+    ],
+  });
+};
+
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('upgrade-walletFactory', defaultProposalBuilder);
+};

package/scripts/testing/add-LEMONS.js

@@ -0,0 +1,23 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+import { defaultProposalBuilder as vaultProposalBuilder } from '../inter-protocol/add-collateral-core.js';
+
+/** @file This is for use in tests in a3p-integration */
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+const starsVaultProposalBuilder = async powers => {
+  return vaultProposalBuilder(powers, {
+    interchainAssetOptions: {
+      denom: 'ibc/000C0FFEECAFE000',
+      decimalPlaces: 6,
+      keyword: 'LEMONS',
+
+      oracleBrand: 'LEMONS',
+      proposedName: 'LEMONS',
+    },
+  });
+};
+
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('add-STARS-collateral', starsVaultProposalBuilder);
+};