@agoric/builders 0.2.0-u19.3 → 0.2.0-u21.0

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

@@ -3,17 +3,7 @@ import {
   getManifest,
   startSendAnywhere,
 } from '@agoric/orchestration/src/proposals/start-send-anywhere.js';
-import { parseArgs } from 'node:util';
-
-/**
- * @import {ParseArgsConfig} from 'node:util'
- */
-
-/** @type {ParseArgsConfig['options']} */
-const parserOpts = {
-  chainInfo: { type: 'string' },
-  assetInfo: { type: 'string' },
-};
+import { parseChainHubOpts } from '../orchestration/helpers.js';
 
 /** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
 export const defaultProposalBuilder = async (
@@ -38,29 +28,8 @@ export const defaultProposalBuilder = async (
 /** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
 export default async (homeP, endowments) => {
   const { scriptArgs } = endowments;
-
-  const {
-    values: { chainInfo, assetInfo },
-  } = parseArgs({
-    args: scriptArgs,
-    options: parserOpts,
-  });
-
-  const parseChainInfo = () => {
-    if (typeof chainInfo !== 'string') return undefined;
-    return JSON.parse(chainInfo);
-  };
-  const parseAssetInfo = () => {
-    if (typeof assetInfo !== 'string') return undefined;
-    return JSON.parse(assetInfo);
-  };
-  const opts = harden({
-    chainInfo: parseChainInfo(),
-    assetInfo: parseAssetInfo(),
-  });
-
+  const opts = parseChainHubOpts(scriptArgs);
   const { writeCoreEval } = await makeHelpers(homeP, endowments);
-
   await writeCoreEval(startSendAnywhere.name, utils =>
     defaultProposalBuilder(utils, opts),
   );

package/scripts/testing/init-swap-anything.js

@@ -0,0 +1,36 @@
+import { makeHelpers } from '@agoric/deploy-script-support';
+import {
+  getManifest,
+  startSwapAnything,
+} from '@agoric/orchestration/src/proposals/start-swap-anything.js';
+import { parseChainHubOpts } from '../orchestration/helpers.js';
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async (
+  { publishRef, install },
+  options,
+) =>
+  harden({
+    sourceSpec: '@agoric/orchestration/src/proposals/start-swap-anything.js',
+    getManifestCall: [
+      getManifest.name,
+      {
+        installationRef: publishRef(
+          install(
+            '@agoric/orchestration/src/examples/swap-anything.contract.js',
+          ),
+        ),
+        options,
+      },
+    ],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { scriptArgs } = endowments;
+  const opts = parseChainHubOpts(scriptArgs);
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval(startSwapAnything.name, utils =>
+    defaultProposalBuilder(utils, opts),
+  );
+};

package/scripts/testing/restart-axelar-gmp.js

@@ -0,0 +1,94 @@
+/**
+ * @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"/>
+
+const trace = makeTracer('StartAxelarGmp', true);
+
+/**
+ * @import {start as StartFn} from '@agoric/orchestration/src/examples/axelar-gmp.contract.js';
+ */
+
+/**
+ * @param {BootstrapPowers} powers
+ */
+export const restartAxelarGmp = async ({
+  consume: {
+    agoricNames,
+    board,
+    chainStorage,
+    chainTimerService,
+    cosmosInterchainService,
+    localchain,
+    contractKits,
+  },
+  instance: instances,
+}) => {
+  trace(restartAxelarGmp.name);
+
+  const marshaller = await E(board).getReadonlyMarshaller();
+  const privateArgs = await deeplyFulfilledObject(
+    harden({
+      agoricNames,
+      localchain,
+      marshaller,
+      orchestrationService: cosmosInterchainService,
+      storageNode: E(NonNullish(await chainStorage)).makeChildNode('axelarGmp'),
+      timerService: chainTimerService,
+    }),
+  );
+
+  // @ts-expect-error unknown instance
+  const instance = await instances.consume.axelarGmp;
+  trace('instance', instance);
+  /** @type {StartedInstanceKit<StartFn>} */
+  const kit = /** @type {any} */ (await E(contractKits).get(instance));
+
+  await E(kit.adminFacet).restartContract(privateArgs);
+  trace('done');
+};
+harden(restartAxelarGmp);
+
+export const getManifest = () => {
+  return {
+    manifest: {
+      [restartAxelarGmp.name]: {
+        consume: {
+          agoricNames: true,
+          board: true,
+          chainTimerService: true,
+          chainStorage: true,
+          cosmosInterchainService: true,
+          localchain: true,
+          contractKits: true,
+        },
+        instance: {
+          consume: { axelarGmp: true },
+        },
+      },
+    },
+  };
+};
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async () =>
+  harden({
+    sourceSpec: '@agoric/builders/scripts/testing/restart-axelar-gmp.js',
+    getManifestCall: [getManifest.name],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const dspModule = await import('@agoric/deploy-script-support');
+  const { makeHelpers } = dspModule;
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval(restartAxelarGmp.name, defaultProposalBuilder);
+};

package/scripts/testing/start-query-flows.js

@@ -7,8 +7,10 @@
 import { deeplyFulfilledObject, makeTracer } from '@agoric/internal';
 import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
 import { E } from '@endo/far';
+import { parseChainHubOpts } from '../orchestration/helpers.js';
 
 /**
+ * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
  * @import {QueryFlowsSF as StartFn} from '@agoric/orchestration/src/fixtures/query-flows.contract.js';
  */
 
@@ -28,25 +30,34 @@ const trace = makeTracer(contractName, true);
  *     };
  *   };
  * }} powers
+ * @param {{
+ *   options: {
+ *     chainInfo: Record<string, CosmosChainInfo>;
+ *     assetInfo: [Denom, DenomDetail & { brandKey?: string }][];
+ *   };
+ * }} config
  */
-export const startQueryFlows = async ({
-  consume: {
-    agoricNames,
-    board,
-    chainStorage,
-    chainTimerService,
-    cosmosInterchainService,
-    localchain,
-    startUpgradable,
-  },
-  installation: {
-    consume: { [contractName]: installation },
-  },
-  instance: {
-    // @ts-expect-error unknown instance
-    produce: { [contractName]: produceInstance },
+export const startQueryFlows = async (
+  {
+    consume: {
+      agoricNames,
+      board,
+      chainStorage,
+      chainTimerService,
+      cosmosInterchainService,
+      localchain,
+      startUpgradable,
+    },
+    installation: {
+      consume: { [contractName]: installation },
+    },
+    instance: {
+      // @ts-expect-error unknown instance
+      produce: { [contractName]: produceInstance },
+    },
   },
-}) => {
+  { options: { chainInfo, assetInfo } },
+) => {
   trace(`start ${contractName}`);
 
   const storageNode = await makeStorageNodeChild(chainStorage, contractName);
@@ -60,6 +71,8 @@ export const startQueryFlows = async ({
     privateArgs: await deeplyFulfilledObject(
       harden({
         agoricNames,
+        assetInfo,
+        chainInfo,
         orchestrationService: cosmosInterchainService,
         localchain,
         storageNode,
@@ -76,7 +89,7 @@ harden(startQueryFlows);
 
 export const getManifestForContract = (
   { restoreRef },
-  { installKeys, ...options },
+  { installKeys, options },
 ) => {
   return {
     manifest: {
@@ -106,7 +119,10 @@ export const getManifestForContract = (
 };
 
 /** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
-export const defaultProposalBuilder = async ({ publishRef, install }) => {
+export const defaultProposalBuilder = async (
+  { publishRef, install },
+  options,
+) => {
   return harden({
     // Somewhat unorthodox, source the exports from this builder module
     sourceSpec: '@agoric/builders/scripts/testing/start-query-flows.js',
@@ -120,6 +136,7 @@ export const defaultProposalBuilder = async ({ publishRef, install }) => {
             ),
           ),
         },
+        options,
       },
     ],
   });
@@ -127,9 +144,12 @@ export const defaultProposalBuilder = async ({ publishRef, install }) => {
 
 /** @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;
+  // import dynamically so the modules can work in CoreEval environment
+  const { makeHelpers } = await import('@agoric/deploy-script-support');
+  const { scriptArgs } = endowments;
+  const opts = parseChainHubOpts(scriptArgs);
   const { writeCoreEval } = await makeHelpers(homeP, endowments);
-  await writeCoreEval(startQueryFlows.name, defaultProposalBuilder);
+  await writeCoreEval(startQueryFlows.name, utils =>
+    defaultProposalBuilder(utils, opts),
+  );
 };

package/scripts/testing/tweak-chain-info.js

@@ -1,13 +1,16 @@
 /// <reference types="ses" />
 import { makeHelpers } from '@agoric/deploy-script-support';
 
-/** @type {Record<string, import('@agoric/orchestration/src/chain-info.js').ChainInfo>} */
+/** @type {Record<string, import('@agoric/orchestration').ChainInfo>} */
 const chainInfo = {
   agoric: {
+    bech32Prefix: 'agoric',
     chainId: 'agoric-4',
+    namespace: 'cosmos',
+    reference: 'agoric-4',
   },
   hot: {
-    allegedName: 'Hot New Chain',
+    bech32Prefix: 'hot',
     chainId: 'hot-1',
     connections: {
       'cosmoshub-4': {
@@ -29,6 +32,8 @@ const chainInfo = {
         },
       },
     },
+    namespace: 'cosmos',
+    reference: 'hot-1',
   },
 };
 

package/scripts/vats/upgrade-mintHolder.js

@@ -54,15 +54,16 @@ const configurations = {
   },
   EMERYNET: {
     labelList: [
-      'USDC_axl',
-      'USDT_grv',
+      'ATOM',
+      'USDT',
       'DAI_axl',
       'DAI_grv',
+      'USDC_axl',
+      'stOSMO',
       'stATOM',
-      'USDC_grv',
-      'ATOM',
-      'USDT_axl',
-      'USDC',
+      'stkATOM',
+      'stOSMO2',
+      'ToyUSD',
       'BLD',
     ],
   },

package/scripts/vats/upgrade-orchestration.js

@@ -1,27 +1,21 @@
 import { makeHelpers } from '@agoric/deploy-script-support';
+import { upgradeVatsProposalBuilder } from './upgrade-vats.js';
 
 /** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
-export const defaultProposalBuilder = async ({ publishRef, install }) =>
-  harden({
-    sourceSpec: '@agoric/vats/src/proposals/upgrade-vats-generic-proposal.js',
-    getManifestCall: [
-      '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'),
-          ),
-        },
-      },
-    ],
-  });
+export const defaultProposalBuilder = async powers => {
+  const bundleRecord = {
+    ibc: '@agoric/vats/src/vat-ibc.js',
+    network: '@agoric/vats/src/vat-network.js',
+    localchain: '@agoric/vats/src/vat-localchain.js',
+    transfer: '@agoric/vats/src/vat-transfer.js',
+    orchestration: '@agoric/orchestration/src/vat-orchestration.js',
+  };
+
+  return upgradeVatsProposalBuilder(powers, bundleRecord);
+};
 
 /** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
 export default async (homeP, endowments) => {
   const { writeCoreProposal } = await makeHelpers(homeP, endowments);
-  await writeCoreProposal('upgrade-network', defaultProposalBuilder);
+  await writeCoreProposal('upgrade-orchestration', defaultProposalBuilder);
 };

package/scripts/vats/upgrade-provisionPool-to-BLD.js

@@ -0,0 +1,25 @@
+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-provisionPool-to-BLD-proposal.js',
+    getManifestCall: [
+      'getManifestForUpgradingProvisionPool',
+      {
+        provisionPoolRef: publishRef(
+          install('@agoric/inter-protocol/src/provisionPool.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-provision-pool-to-BLD',
+    defaultProposalBuilder,
+  );
+};

package/scripts/vats/upgrade-vats.js

@@ -0,0 +1,49 @@
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const upgradeVatsProposalBuilder = async (
+  { publishRef, install },
+  vatNameToEntrypoint,
+) => {
+  if (!vatNameToEntrypoint) {
+    throw Error('Missing vatNameToEntrypoint');
+  }
+  return harden({
+    sourceSpec: '@agoric/vats/src/proposals/upgrade-vats-generic-proposal.js',
+    getManifestCall: [
+      'getManifestForUpgradingVats',
+      {
+        bundleRefs: Object.fromEntries(
+          Object.entries(vatNameToEntrypoint).map(
+            ([name, entrypoint]) =>
+              /** @type {const} */ ([name, publishRef(install(entrypoint))]),
+          ),
+        ),
+      },
+    ],
+  });
+};
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const upgradeZoeContractsProposalBuilder = async (
+  { publishRef, install },
+  contractKitSpecs,
+) => {
+  if (!contractKitSpecs) {
+    throw Error('Missing contractKitSpecs');
+  }
+  return harden({
+    sourceSpec: '@agoric/vats/src/proposals/upgrade-vats-generic-proposal.js',
+    getManifestCall: [
+      'getManifestForUpgradingZoeContractKits',
+      {
+        contractKitSpecs,
+        /** @type {{ [bundleName: string]: VatSourceRef }} */
+        installationBundleRefs: Object.fromEntries(
+          contractKitSpecs.map(({ bundleName, entrypoint }) => [
+            bundleName,
+            publishRef(install(entrypoint)),
+          ]),
+        ),
+      },
+    ],
+  });
+};

package/scripts/fast-usdc/add-operators.build.js

@@ -1,83 +0,0 @@
-// @ts-check
-import { makeHelpers } from '@agoric/deploy-script-support';
-import { getManifestForAddOperators } from '@agoric/fast-usdc/src/add-operators.core.js';
-import { toExternalConfig } from '@agoric/fast-usdc/src/utils/config-marshal.js';
-import { configurations } from '@agoric/fast-usdc/src/utils/deploy-config.js';
-import { Far } from '@endo/far';
-import { parseArgs } from 'node:util';
-
-/**
- * @import {CoreEvalBuilder, DeployScriptFunction} from '@agoric/deploy-script-support/src/externalTypes.js';
- * @import {ParseArgsConfig} from 'node:util';
- * @import {FastUSDCConfig, FeedPolicy} from '@agoric/fast-usdc/src/types.js';
- * @import {FastUSDCOpts} from './start-fast-usdc.build.js';
- */
-
-const { keys } = Object;
-
-/** @type {ParseArgsConfig['options']} */
-const options = {
-  net: { type: 'string' },
-  oracle: { type: 'string', multiple: true },
-};
-const oraclesUsage = 'use --oracle name:address ...';
-
-const crossVatContext = /** @type {const} */ ({
-  /** @type {Brand<'nat'>} */
-  USDC: Far('USDC Brand'),
-});
-
-/** @type {CoreEvalBuilder} */
-export const defaultProposalBuilder = async (
-  powers,
-  /** @type {FastUSDCConfig} */ config,
-) => {
-  return harden({
-    sourceSpec: '@agoric/fast-usdc/src/add-operators.core.js',
-    /** @type {[string, Parameters<typeof getManifestForAddOperators>[1]]} */
-    getManifestCall: [
-      getManifestForAddOperators.name,
-      {
-        options: toExternalConfig(config, crossVatContext),
-      },
-    ],
-  });
-};
-
-/** @type {DeployScriptFunction} */
-export default async (homeP, endowments) => {
-  const { writeCoreEval } = await makeHelpers(homeP, endowments);
-  const { scriptArgs } = endowments;
-
-  /** @type {{ values: FastUSDCOpts }} */
-  // @ts-expect-error ensured by options
-  const {
-    values: { oracle: oracleArgs, net },
-  } = parseArgs({ args: scriptArgs, options });
-
-  const parseOracleArgs = () => {
-    if (net) {
-      if (!(net in configurations)) {
-        throw Error(`${net} not in ${keys(configurations)}`);
-      }
-      return configurations[net].oracles;
-    }
-    if (!oracleArgs) throw Error(oraclesUsage);
-    return Object.fromEntries(
-      oracleArgs.map(arg => {
-        const result = arg.match(/(?<name>[^:]+):(?<address>.+)/);
-        if (!(result && result.groups)) throw Error(oraclesUsage);
-        const { name, address } = result.groups;
-        return [name, address];
-      }),
-    );
-  };
-
-  const config = harden({
-    oracles: parseOracleArgs(),
-  });
-
-  await writeCoreEval('add-operators', utils =>
-    defaultProposalBuilder(utils, config),
-  );
-};

package/scripts/fast-usdc/fast-usdc-fees.build.js

@@ -1,75 +0,0 @@
-import { makeHelpers } from '@agoric/deploy-script-support';
-import { AmountMath } from '@agoric/ertp';
-import { getManifestForDistributeFees } from '@agoric/fast-usdc/src/distribute-fees.core.js';
-import { toExternalConfig } from '@agoric/fast-usdc/src/utils/config-marshal.js';
-import {
-  multiplyBy,
-  parseRatio,
-} from '@agoric/zoe/src/contractSupport/ratio.js';
-import { Far } from '@endo/far';
-import { parseArgs } from 'node:util';
-
-/**
- * @import {CoreEvalBuilder, DeployScriptFunction} from '@agoric/deploy-script-support/src/externalTypes.js'
- * @import {FeeDistributionTerms} from '@agoric/fast-usdc/src/distribute-fees.core.js'
- */
-
-const usage =
-  'Use: [--fixedFees <number> | --feePortion <percent>] --destinationAddress <address> ...';
-
-const xVatCtx = /** @type {const} */ ({
-  /** @type {Brand<'nat'>} */
-  USDC: Far('USDC Brand'),
-});
-const { USDC } = xVatCtx;
-const USDC_DECIMALS = 6n;
-const unit = AmountMath.make(USDC, 10n ** USDC_DECIMALS);
-
-/**
- * @param {unknown} _utils
- * @param {FeeDistributionTerms} feeTerms
- * @satisfies {CoreEvalBuilder}
- */
-export const feeProposalBuilder = async (_utils, feeTerms) => {
-  return harden({
-    sourceSpec: '@agoric/fast-usdc/src/distribute-fees.core.js',
-    /** @type {[string, Parameters<typeof getManifestForDistributeFees>[1]]} */
-    getManifestCall: [
-      getManifestForDistributeFees.name,
-      { options: toExternalConfig(harden({ feeTerms }), xVatCtx) },
-    ],
-  });
-};
-
-/** @type {DeployScriptFunction} */
-export default async (homeP, endowments) => {
-  const { writeCoreEval } = await makeHelpers(homeP, endowments);
-  /** @type {{ values: Record<string, string | undefined> }} */
-  const {
-    values: { destinationAddress, ...opt },
-  } = parseArgs({
-    args: endowments.scriptArgs,
-    options: {
-      destinationAddress: { type: 'string' },
-      fixedFees: { type: 'string' },
-      feePortion: { type: 'string' },
-    },
-  });
-  if (!destinationAddress) assert.fail(usage);
-  if (opt.fixedFees && opt.feePortion) assert.fail(usage);
-
-  /** @type {FeeDistributionTerms} */
-  const feeTerms = {
-    destinationAddress,
-    ...((opt.fixedFees && {
-      fixedFees: multiplyBy(unit, parseRatio(opt.fixedFees, USDC)),
-    }) ||
-      (opt.feePortion && {
-        feePortion: parseRatio(opt.feePortion, USDC),
-      }) ||
-      assert.fail(usage)),
-  };
-  await writeCoreEval('eval-fast-usdc-fees', utils =>
-    feeProposalBuilder(utils, feeTerms),
-  );
-};