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

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);
+};

package/scripts/vats/upgrade-mintHolder.js

@@ -0,0 +1,126 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+import { getManifestForUpgradingMintHolder } from '@agoric/vats/src/proposals/upgrade-mintHolder-proposal.js';
+
+const configurations = {
+  A3P_INTEGRATION: {
+    labelList: [
+      'USDC_axl',
+      'USDT_grv',
+      'DAI_axl',
+      'DAI_grv',
+      'stATOM',
+      'USDC_grv',
+      'ATOM',
+      'USDT_axl',
+      'USDC',
+      'BLD',
+    ],
+  },
+  MAINNET: {
+    labelList: [
+      'USDT',
+      'USDT_axl',
+      'USDT_grv',
+      'USDC',
+      'USDC_axl',
+      'USDC_grv',
+      'DAI_axl',
+      'DAI_grv',
+      'ATOM',
+      'stATOM',
+      'stkATOM',
+      'stTIA',
+      'stOSMO',
+    ],
+  },
+  DEVNET: {
+    labelList: [
+      'stATOM3',
+      'stATOM',
+      'dATOM',
+      'stOSMO',
+      'stkATOM',
+      'stATOM2',
+      'STOSMO',
+      'stTIA',
+      'ATOM',
+      'AUSD',
+      'USDT_grv',
+      'USDC_axl',
+      'USDC_grv',
+      'USDT_axl',
+      'BLD',
+    ],
+  },
+  EMERYNET: {
+    labelList: [
+      'ATOM',
+      'USDT',
+      'DAI_axl',
+      'DAI_grv',
+      'USDC_axl',
+      'stOSMO',
+      'stATOM',
+      'stkATOM',
+      'stOSMO2',
+      'ToyUSD',
+      'BLD',
+    ],
+  },
+};
+
+const { keys } = Object;
+const knownVariants = keys(configurations);
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async ({ publishRef, install }, opts) => {
+  const config = opts.config || configurations[opts.variant];
+  if (!config) {
+    const error = `Unknown variant "${opts.variant}". Expected one of ${knownVariants.join(', ')}`;
+    console.error(error);
+    throw Error(error);
+  }
+  const { labelList } = config;
+
+  return harden({
+    sourceSpec: '@agoric/vats/src/proposals/upgrade-mintHolder-proposal.js',
+    getManifestCall: [
+      getManifestForUpgradingMintHolder.name,
+      {
+        labelList,
+        contractRef: publishRef(install('@agoric/vats/src/mintHolder.js')),
+      },
+    ],
+  });
+};
+
+const Usage = `agoric run upgrade-mintHolder.js ${[...knownVariants, '<json-config>'].join(' | ')}`;
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { scriptArgs } = endowments;
+  const variantOrConfig = scriptArgs?.[0];
+  console.log('upgrade-mintHolder', variantOrConfig);
+
+  const opts = {};
+
+  if (typeof variantOrConfig === 'string') {
+    if (variantOrConfig[0] === '{') {
+      try {
+        opts.config = JSON.parse(variantOrConfig);
+      } catch (err) {
+        throw Error(`Failed to parse config argument ${variantOrConfig}`);
+      }
+    } else {
+      opts.variant = variantOrConfig;
+    }
+  } else {
+    console.error(Usage);
+    throw Error(Usage);
+  }
+
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval(`upgrade-mintHolder`, utils =>
+    defaultProposalBuilder(utils, opts),
+  );
+};

package/scripts/vats/{upgrade-orch-core.js → upgrade-orchestration.js}

@@ -3,15 +3,18 @@ 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-orch-core-proposal.js',
+    sourceSpec: '@agoric/vats/src/proposals/upgrade-vats-generic-proposal.js',
     getManifestCall: [
-      'getManifestForUpgradingOrchCore',
+      'getManifestForUpgradingVats',
       {
         bundleRefs: {
           ibc: publishRef(install('@agoric/vats/src/vat-ibc.js')),
           network: publishRef(install('@agoric/vats/src/vat-network.js')),
           localchain: publishRef(install('@agoric/vats/src/vat-localchain.js')),
           transfer: publishRef(install('@agoric/vats/src/vat-transfer.js')),
+          orchestration: publishRef(
+            install('@agoric/orchestration/src/vat-orchestration.js'),
+          ),
         },
       },
     ],

package/scripts/vats/upgrade-paRegistry.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-paRegistry-proposal.js',
+    getManifestCall: [
+      'getManifestForUpgradingRegistry',
+      {
+        registryRef: publishRef(
+          install('@agoric/vats/src/vat-priceAuthority.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-paRegistry', defaultProposalBuilder);
+};

package/scripts/testing/start-auto-stake-it.js

@@ -1,128 +0,0 @@
-/**
- * @file A proposal to start the auto-stake-it contract.
- *
- *   AutoStakeIt allows users to to create an auto-forwarding address that
- *   transfers and stakes tokens on a remote chain when received.
- */
-import { makeTracer } from '@agoric/internal';
-import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
-import { E } from '@endo/far';
-import { deeplyFulfilled } from '@endo/marshal';
-
-/**
- * @import {AutoStakeItSF} from '@agoric/orchestration/src/examples/auto-stake-it.contract.js';
- */
-
-const contractName = 'autoAutoStakeIt';
-const trace = makeTracer(contractName, true);
-
-/**
- * @param {BootstrapPowers} powers
- */
-export const startAutoStakeIt = async ({
-  consume: {
-    agoricNames,
-    board,
-    chainStorage,
-    chainTimerService,
-    cosmosInterchainService,
-    localchain,
-    startUpgradable,
-  },
-  installation: {
-    // @ts-expect-error not a WellKnownName
-    consume: { [contractName]: installation },
-  },
-  instance: {
-    // @ts-expect-error not a WellKnownName
-    produce: { [contractName]: produceInstance },
-  },
-}) => {
-  trace(`start ${contractName}`);
-  await null;
-
-  const storageNode = await makeStorageNodeChild(chainStorage, contractName);
-  const marshaller = await E(board).getPublishingMarshaller();
-
-  /** @type {StartUpgradableOpts<AutoStakeItSF>} */
-  const startOpts = {
-    label: 'autoAutoStakeIt',
-    installation,
-    terms: undefined,
-    privateArgs: await deeplyFulfilled(
-      // @ts-expect-error
-      harden({
-        agoricNames,
-        orchestrationService: cosmosInterchainService,
-        localchain,
-        storageNode,
-        marshaller,
-        timerService: chainTimerService,
-      }),
-    ),
-  };
-
-  const { instance } = await E(startUpgradable)(startOpts);
-  produceInstance.resolve(instance);
-};
-harden(startAutoStakeIt);
-
-export const getManifestForContract = (
-  { restoreRef },
-  { installKeys, ...options },
-) => {
-  return {
-    manifest: {
-      [startAutoStakeIt.name]: {
-        consume: {
-          agoricNames: true,
-          board: true,
-          chainStorage: true,
-          chainTimerService: true,
-          cosmosInterchainService: true,
-          localchain: true,
-          startUpgradable: true,
-        },
-        installation: {
-          consume: { [contractName]: true },
-        },
-        instance: {
-          produce: { [contractName]: true },
-        },
-      },
-    },
-    installations: {
-      [contractName]: restoreRef(installKeys[contractName]),
-    },
-    options,
-  };
-};
-
-/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
-export const defaultProposalBuilder = async ({ publishRef, install }) => {
-  return harden({
-    // Somewhat unorthodox, source the exports from this builder module
-    sourceSpec: '@agoric/builders/scripts/testing/start-auto-stake-it.js',
-    getManifestCall: [
-      'getManifestForContract',
-      {
-        installKeys: {
-          autoAutoStakeIt: publishRef(
-            install(
-              '@agoric/orchestration/src/examples/auto-stake-it.contract.js',
-            ),
-          ),
-        },
-      },
-    ],
-  });
-};
-
-/** @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(startAutoStakeIt.name, defaultProposalBuilder);
-};

package/scripts/testing/start-buggy-sendAnywhere.js

@@ -1,143 +0,0 @@
-/**
- * @file This is for use in tests in a3p-integration
- * Unlike most builder scripts, this one includes the proposal exports as well.
- */
-import {
-  deeplyFulfilledObject,
-  makeTracer,
-  NonNullish,
-} from '@agoric/internal';
-import { E, Far } from '@endo/far';
-
-/// <reference types="@agoric/vats/src/core/types-ambient"/>
-/**
- * @import {Installation} from '@agoric/zoe/src/zoeService/utils.js';
- */
-
-const trace = makeTracer('StartBuggySA', true);
-
-/**
- * @import {start as StartFn} from '@agoric/orchestration/src/examples/send-anywhere.contract.js';
- */
-
-/**
- * @param {BootstrapPowers & {
- *   installation: {
- *     consume: {
- *       sendAnywhere: Installation<StartFn>;
- *     };
- *   };
- * }} powers
- */
-export const startSendAnywhere = async ({
-  consume: {
-    agoricNames,
-    board,
-    chainStorage,
-    chainTimerService,
-    cosmosInterchainService,
-    localchain,
-    startUpgradable,
-  },
-  installation: {
-    consume: { sendAnywhere },
-  },
-  instance: {
-    // @ts-expect-error unknown instance
-    produce: { sendAnywhere: produceInstance },
-  },
-}) => {
-  trace(startSendAnywhere.name);
-
-  const marshaller = await E(board).getReadonlyMarshaller();
-
-  const privateArgs = await deeplyFulfilledObject(
-    harden({
-      agoricNames,
-      localchain,
-      marshaller,
-      orchestrationService: cosmosInterchainService,
-      storageNode: E(NonNullish(await chainStorage)).makeChildNode(
-        'sendAnywhere',
-      ),
-      timerService: chainTimerService,
-    }),
-  );
-
-  /** @type {import('@agoric/vats').NameHub} */
-  // @ts-expect-error intentional fake
-  const agoricNamesHangs = Far('agoricNames that hangs', {
-    lookup: async () => {
-      trace('agoricNames.lookup being called that will never resolve');
-      // BUG: this never resolves
-      return new Promise(() => {});
-    },
-  });
-
-  const { instance } = await E(startUpgradable)({
-    label: 'sendAnywhere',
-    installation: sendAnywhere,
-    privateArgs: {
-      ...privateArgs,
-      agoricNames: agoricNamesHangs,
-    },
-  });
-  produceInstance.resolve(instance);
-  trace('done');
-};
-harden(startSendAnywhere);
-
-export const getManifestForValueVow = ({ restoreRef }, { sendAnywhereRef }) => {
-  trace('sendAnywhereRef', sendAnywhereRef);
-  return {
-    manifest: {
-      [startSendAnywhere.name]: {
-        consume: {
-          agoricNames: true,
-          board: true,
-          chainStorage: true,
-          chainTimerService: true,
-          cosmosInterchainService: true,
-          localchain: true,
-
-          startUpgradable: true,
-        },
-        installation: {
-          consume: { sendAnywhere: true },
-        },
-        instance: {
-          produce: { sendAnywhere: true },
-        },
-      },
-    },
-    installations: {
-      sendAnywhere: restoreRef(sendAnywhereRef),
-    },
-  };
-};
-
-/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
-export const defaultProposalBuilder = async ({ publishRef, install }) =>
-  harden({
-    // Somewhat unorthodox, source the exports from this builder module
-    sourceSpec: '@agoric/builders/scripts/testing/start-buggy-sendAnywhere.js',
-    getManifestCall: [
-      'getManifestForValueVow',
-      {
-        sendAnywhereRef: publishRef(
-          install(
-            '@agoric/orchestration/src/examples/send-anywhere.contract.js',
-          ),
-        ),
-      },
-    ],
-  });
-
-/** @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(startSendAnywhere.name, defaultProposalBuilder);
-};

package/scripts/testing/start-send-anywhere.js

@@ -1,136 +0,0 @@
-/**
- * @file This is for use in tests in a3p-integration
- * Unlike most builder scripts, this one includes the proposal exports as well.
- */
-import {
-  deeplyFulfilledObject,
-  makeTracer,
-  NonNullish,
-} from '@agoric/internal';
-import { E } from '@endo/far';
-
-/// <reference types="@agoric/vats/src/core/types-ambient"/>
-/**
- * @import {Installation} from '@agoric/zoe/src/zoeService/utils.js';
- */
-
-const trace = makeTracer('StartSA', true);
-
-/**
- * @import {start as StartFn} from '@agoric/orchestration/src/examples/send-anywhere.contract.js';
- */
-
-/**
- * @param {BootstrapPowers & {
- *   installation: {
- *     consume: {
- *       sendAnywhere: Installation<StartFn>;
- *     };
- *   };
- * }} powers
- */
-export const startSendAnywhere = async ({
-  consume: {
-    agoricNames,
-    board,
-    chainStorage,
-    chainTimerService,
-    cosmosInterchainService,
-    localchain,
-    startUpgradable,
-  },
-  installation: {
-    consume: { sendAnywhere },
-  },
-  instance: {
-    // @ts-expect-error unknown instance
-    produce: { sendAnywhere: produceInstance },
-  },
-  issuer: {
-    consume: { IST },
-  },
-}) => {
-  trace(startSendAnywhere.name);
-
-  const marshaller = await E(board).getReadonlyMarshaller();
-
-  const privateArgs = await deeplyFulfilledObject(
-    harden({
-      agoricNames,
-      localchain,
-      marshaller,
-      orchestrationService: cosmosInterchainService,
-      storageNode: E(NonNullish(await chainStorage)).makeChildNode(
-        'send-anywhere',
-      ),
-      timerService: chainTimerService,
-    }),
-  );
-
-  const { instance } = await E(startUpgradable)({
-    label: 'send-anywhere',
-    installation: sendAnywhere,
-    issuerKeywordRecord: { Stable: await IST },
-    privateArgs,
-  });
-  produceInstance.resolve(instance);
-  trace('done');
-};
-harden(startSendAnywhere);
-
-export const getManifest = ({ restoreRef }, { installationRef }) => {
-  return {
-    manifest: {
-      [startSendAnywhere.name]: {
-        consume: {
-          agoricNames: true,
-          board: true,
-          chainStorage: true,
-          chainTimerService: true,
-          cosmosInterchainService: true,
-          localchain: true,
-
-          startUpgradable: true,
-        },
-        installation: {
-          consume: { sendAnywhere: true },
-        },
-        instance: {
-          produce: { sendAnywhere: true },
-        },
-        issuer: {
-          consume: { IST: true },
-        },
-      },
-    },
-    installations: {
-      sendAnywhere: restoreRef(installationRef),
-    },
-  };
-};
-
-/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
-export const defaultProposalBuilder = async ({ publishRef, install }) =>
-  harden({
-    // Somewhat unorthodox, source the exports from this builder module
-    sourceSpec: '@agoric/builders/scripts/testing/start-send-anywhere.js',
-    getManifestCall: [
-      getManifest.name,
-      {
-        installationRef: publishRef(
-          install(
-            '@agoric/orchestration/src/examples/send-anywhere.contract.js',
-          ),
-        ),
-      },
-    ],
-  });
-
-/** @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(startSendAnywhere.name, defaultProposalBuilder);
-};