@agoric/builders 0.1.1-orchestration-dev-096c4e8.0 → 0.1.1-other-dev-fbe72e7.0.fbe72e7

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/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/restart-basic-flows.js

@@ -0,0 +1,101 @@
+/**
+ * @file This is for use in tests.
+ * 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('RestartBasicFlows', true);
+
+/**
+ * @import {start as StartFn} from '@agoric/orchestration/src/examples/basic-flows.contract.js';
+ */
+
+/**
+ * @param {BootstrapPowers} powers
+ */
+export const restartBasicFlows = async ({
+  consume: {
+    agoricNames,
+    board,
+    chainStorage,
+    chainTimerService,
+    cosmosInterchainService,
+    localchain,
+
+    contractKits,
+  },
+  instance: instances,
+}) => {
+  trace(restartBasicFlows.name);
+
+  // @ts-expect-error unknown instance
+  const instance = await instances.consume.basicFlows;
+  trace('instance', instance);
+  /** @type {StartedInstanceKit<StartFn>} */
+  const kit = /** @type {any} */ (await E(contractKits).get(instance));
+
+  const marshaller = await E(board).getReadonlyMarshaller();
+
+  const privateArgs = await deeplyFulfilledObject(
+    harden({
+      agoricNames,
+      localchain,
+      marshaller,
+      orchestrationService: cosmosInterchainService,
+      storageNode: E(NonNullish(await chainStorage)).makeChildNode(
+        'basicFlows',
+      ),
+      timerService: chainTimerService,
+    }),
+  );
+
+  await E(kit.adminFacet).restartContract(privateArgs);
+  trace('done');
+};
+harden(restartBasicFlows);
+
+export const getManifest = () => {
+  return {
+    manifest: {
+      [restartBasicFlows.name]: {
+        consume: {
+          agoricNames: true,
+          board: true,
+          chainStorage: true,
+          chainTimerService: true,
+          cosmosInterchainService: true,
+          localchain: true,
+
+          contractKits: true,
+        },
+        instance: {
+          consume: { basicFlows: 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/restart-basic-flows.js',
+    getManifestCall: [getManifest.name],
+  });
+
+/** @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(restartBasicFlows.name, defaultProposalBuilder);
+};

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

@@ -0,0 +1,101 @@
+/**
+ * @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('StartSA', true);
+
+/**
+ * @import {start as StartFn} from '@agoric/orchestration/src/examples/send-anywhere.contract.js';
+ */
+
+/**
+ * @param {BootstrapPowers} powers
+ */
+export const restartSendAnywhere = async ({
+  consume: {
+    agoricNames,
+    board,
+    chainStorage,
+    chainTimerService,
+    cosmosInterchainService,
+    localchain,
+
+    contractKits,
+  },
+  instance: instances,
+}) => {
+  trace(restartSendAnywhere.name);
+
+  // @ts-expect-error unknown instance
+  const instance = await instances.consume.sendAnywhere;
+  trace('instance', instance);
+  /** @type {StartedInstanceKit<StartFn>} */
+  const kit = /** @type {any} */ (await E(contractKits).get(instance));
+
+  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,
+    }),
+  );
+
+  await E(kit.adminFacet).restartContract(privateArgs);
+  trace('done');
+};
+harden(restartSendAnywhere);
+
+export const getManifest = () => {
+  return {
+    manifest: {
+      [restartSendAnywhere.name]: {
+        consume: {
+          agoricNames: true,
+          board: true,
+          chainStorage: true,
+          chainTimerService: true,
+          cosmosInterchainService: true,
+          localchain: true,
+
+          contractKits: true,
+        },
+        instance: {
+          consume: { sendAnywhere: 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/restart-send-anywhere.js',
+    getManifestCall: [getManifest.name],
+  });
+
+/** @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(restartSendAnywhere.name, defaultProposalBuilder);
+};

package/scripts/testing/restart-stakeAtom.js

@@ -0,0 +1,91 @@
+/**
+ * @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 } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+import { E } from '@endo/far';
+
+/// <reference types="@agoric/vats/src/core/types-ambient"/>
+
+const trace = makeTracer('RestartSA', true);
+
+/**
+ * @import {start as StartFn} from '@agoric/orchestration/src/examples/stake-ica.contract.js';
+ */
+
+/**
+ * @param {BootstrapPowers} powers
+ */
+export const restartStakeAtom = async ({
+  consume: {
+    agoricNames,
+    board,
+    chainStorage,
+    chainTimerService,
+    cosmosInterchainService,
+    contractKits,
+  },
+  instance: instances,
+}) => {
+  trace(restartStakeAtom.name);
+
+  const instance = await instances.consume.stakeAtom;
+  trace('instance', instance);
+
+  /** @type {StartedInstanceKit<StartFn>} */
+  const kit = /** @type {any} */ (await E(contractKits).get(instance));
+
+  const marshaller = await E(board).getReadonlyMarshaller();
+
+  const privateArgs = await deeplyFulfilledObject(
+    harden({
+      agoricNames,
+      cosmosInterchainService,
+      storageNode: makeStorageNodeChild(chainStorage, 'stakeAtom'),
+      marshaller,
+      timer: chainTimerService,
+    }),
+  );
+
+  await E(kit.adminFacet).restartContract(privateArgs);
+  trace('done');
+};
+harden(restartStakeAtom);
+
+export const getManifest = () => {
+  return {
+    manifest: {
+      [restartStakeAtom.name]: {
+        consume: {
+          agoricNames: true,
+          board: true,
+          chainStorage: true,
+          chainTimerService: true,
+          cosmosInterchainService: true,
+          contractKits: true,
+        },
+        instance: {
+          consume: { stakeAtom: 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/restart-stakeAtom.js',
+    getManifestCall: [getManifest.name],
+  });
+
+/** @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(restartStakeAtom.name, defaultProposalBuilder);
+};

package/scripts/testing/restart-valueVow.js

@@ -0,0 +1,82 @@
+/**
+ * @file This is for use in tests in a3p-integration
+ * Unlike most builder scripts, this one includes the proposal exports as well.
+ */
+import { makeTracer } from '@agoric/internal';
+import { E } from '@endo/far';
+
+/// <reference types="@agoric/vats/src/core/types-ambient"/>
+/**
+ * @import {Instance} from '@agoric/zoe/src/zoeService/utils.js';
+ */
+
+const trace = makeTracer('RestartValueVow', true);
+
+/**
+ * @param {BootstrapPowers & {
+ *   instance: {
+ *     consume: {
+ *       valueVow: Instance<
+ *         import('@agoric/zoe/src/contracts/valueVow.contract.js').start
+ *       >;
+ *     };
+ *   };
+ * }} powers
+ */
+export const restartValueVow = async ({
+  consume: { contractKits },
+  instance: instances,
+}) => {
+  trace(restartValueVow.name);
+
+  const vvInstance = await instances.consume.valueVow;
+  trace('vvInstance', vvInstance);
+  const vvKit = await E(contractKits).get(vvInstance);
+
+  await E(vvKit.adminFacet).restartContract({});
+  trace('done');
+};
+harden(restartValueVow);
+
+export const getManifestForValueVow = ({ restoreRef }, { valueVowRef }) => {
+  console.log('valueVowRef', valueVowRef);
+  return {
+    manifest: {
+      [restartValueVow.name]: {
+        consume: {
+          contractKits: true,
+        },
+        instance: {
+          consume: { valueVow: true },
+        },
+      },
+    },
+    installations: {
+      valueVow: restoreRef(valueVowRef),
+    },
+  };
+};
+
+/** @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/restart-valueVow.js',
+    getManifestCall: [
+      'getManifestForValueVow',
+      {
+        valueVowRef: publishRef(
+          install('@agoric/zoe/src/contracts/valueVow.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(restartValueVow.name, defaultProposalBuilder);
+};