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

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

@@ -0,0 +1,143 @@
+/**
+ * @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-query-flows.js

@@ -0,0 +1,135 @@
+/**
+ * @file A proposal to start the query-flows contract.
+ *
+ * QueryFlows is a testing fixture that publishes query results to vstorage.
+ * It's purpose is to support E2E testing.
+ */
+import { deeplyFulfilledObject, makeTracer } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+import { E } from '@endo/far';
+
+/**
+ * @import {QueryFlowsSF as StartFn} from '@agoric/orchestration/src/fixtures/query-flows.contract.js';
+ */
+
+const contractName = 'queryFlows';
+const trace = makeTracer(contractName, true);
+
+/**
+ * See `@agoric/builders/builders/scripts/orchestration/init-query-flows.js` for
+ * the accompanying proposal builder. Run `agoric run
+ * packages/builders/scripts/orchestration/init-query-flows.js` to build the
+ * contract and proposal files.
+ *
+ * @param {BootstrapPowers & {
+ *   installation: {
+ *     consume: {
+ *       queryFlows: Installation<StartFn>;
+ *     };
+ *   };
+ * }} powers
+ */
+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 },
+  },
+}) => {
+  trace(`start ${contractName}`);
+
+  const storageNode = await makeStorageNodeChild(chainStorage, contractName);
+  const marshaller = await E(board).getPublishingMarshaller();
+
+  /** @type {StartUpgradableOpts<StartFn>} */
+  const startOpts = {
+    label: 'queryFlows',
+    installation,
+    terms: undefined,
+    privateArgs: await deeplyFulfilledObject(
+      harden({
+        agoricNames,
+        orchestrationService: cosmosInterchainService,
+        localchain,
+        storageNode,
+        marshaller,
+        timerService: chainTimerService,
+      }),
+    ),
+  };
+
+  const { instance } = await E(startUpgradable)(startOpts);
+  produceInstance.resolve(instance);
+};
+harden(startQueryFlows);
+
+export const getManifestForContract = (
+  { restoreRef },
+  { installKeys, ...options },
+) => {
+  return {
+    manifest: {
+      [startQueryFlows.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-query-flows.js',
+    getManifestCall: [
+      'getManifestForContract',
+      {
+        installKeys: {
+          queryFlows: publishRef(
+            install(
+              '@agoric/orchestration/src/fixtures/query-flows.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(startQueryFlows.name, defaultProposalBuilder);
+};

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

@@ -0,0 +1,136 @@
+/**
+ * @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);
+};

package/scripts/testing/start-valueVow.js

@@ -0,0 +1,93 @@
+/**
+ * @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 {Installation} from '@agoric/zoe/src/zoeService/utils.js';
+ */
+
+const trace = makeTracer('StartValueVow', true);
+
+/**
+ * @param {BootstrapPowers & {
+ *   installation: {
+ *     consume: {
+ *       valueVow: Installation<
+ *         import('@agoric/zoe/src/contracts/valueVow.contract.js').start
+ *       >;
+ *     };
+ *   };
+ * }} powers
+ */
+export const startValueVow = async ({
+  consume: { startUpgradable },
+  installation: {
+    consume: { valueVow },
+  },
+  instance: {
+    // @ts-expect-error unknown instance
+    produce: { valueVow: produceInstance },
+  },
+}) => {
+  trace(startValueVow.name);
+
+  const startOpts = {
+    label: 'valueVow',
+    installation: valueVow,
+  };
+
+  const { instance } = await E(startUpgradable)(startOpts);
+  produceInstance.resolve(instance);
+  trace('done');
+};
+harden(startValueVow);
+
+export const getManifestForValueVow = ({ restoreRef }, { valueVowRef }) => {
+  console.log('valueVowRef', valueVowRef);
+  return {
+    manifest: {
+      [startValueVow.name]: {
+        consume: {
+          startUpgradable: true,
+        },
+        installation: {
+          consume: { valueVow: true },
+        },
+        instance: {
+          produce: { 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/start-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('start-valueVow', defaultProposalBuilder);
+};

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

@@ -0,0 +1,51 @@
+/// <reference types="ses" />
+import { makeHelpers } from '@agoric/deploy-script-support';
+
+/** @type {Record<string, import('@agoric/orchestration/src/chain-info.js').ChainInfo>} */
+const chainInfo = {
+  agoric: {
+    chainId: 'agoric-4',
+  },
+  hot: {
+    allegedName: 'Hot New Chain',
+    chainId: 'hot-1',
+    connections: {
+      'cosmoshub-4': {
+        id: 'connection-99',
+        client_id: '07-tendermint-3',
+        counterparty: {
+          client_id: '07-tendermint-2',
+          connection_id: 'connection-1',
+        },
+        state: 3 /* IBCConnectionState.STATE_OPEN */,
+        transferChannel: {
+          portId: 'transfer',
+          channelId: 'channel-1',
+          counterPartyChannelId: 'channel-1',
+          counterPartyPortId: 'transfer',
+          ordering: 1 /* Order.ORDER_UNORDERED */,
+          state: 3 /* IBCConnectionState.STATE_OPEN */,
+          version: 'ics20-1',
+        },
+      },
+    },
+  },
+};
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
+export const defaultProposalBuilder = async () =>
+  harden({
+    sourceSpec: '@agoric/orchestration/src/proposals/revise-chain-info.js',
+    getManifestCall: [
+      'getManifestForReviseChains',
+      {
+        chainInfo,
+      },
+    ],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('revise-chain-info', defaultProposalBuilder);
+};

package/scripts/vats/add-auction.js

@@ -0,0 +1,31 @@
+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/inter-protocol/src/proposals/add-auction.js',
+    getManifestCall: [
+      'getManifestForAddAuction',
+      {
+        auctioneerRef: publishRef(
+          install(
+            '@agoric/inter-protocol/src/auction/auctioneer.js',
+            '../../inter-protocol/bundles/bundle-auctioneer.js',
+          ),
+        ),
+        contractGovernorRef: publishRef(
+          install(
+            '@agoric/governance/src/contractGovernor.js',
+            '../bundles/bundle-contractGovernor.js',
+          ),
+        ),
+      },
+    ],
+  });
+};
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('add-auction', defaultProposalBuilder);
+};

package/scripts/vats/init-core.js

@@ -1,6 +1,6 @@
 import { makeHelpers } from '@agoric/deploy-script-support';
 
-/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
 export const defaultProposalBuilder = async ({ publishRef, install }) =>
   harden({
     sourceSpec: '@agoric/vats/src/core/startWalletFactory.js',
@@ -25,7 +25,8 @@ export const defaultProposalBuilder = async ({ publishRef, install }) =>
     ],
   });
 
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
 export default async (homeP, endowments) => {
-  const { writeCoreProposal } = await makeHelpers(homeP, endowments);
-  await writeCoreProposal('gov-vats', defaultProposalBuilder);
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('gov-vats', defaultProposalBuilder);
 };

package/scripts/vats/init-localchain.js

@@ -1,6 +1,6 @@
 import { makeHelpers } from '@agoric/deploy-script-support';
 
-/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
 export const defaultProposalBuilder = async ({ publishRef, install }) =>
   harden({
     sourceSpec: '@agoric/vats/src/proposals/localchain-proposal.js',
@@ -14,7 +14,8 @@ export const defaultProposalBuilder = async ({ publishRef, install }) =>
     ],
   });
 
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
 export default async (homeP, endowments) => {
-  const { writeCoreProposal } = await makeHelpers(homeP, endowments);
-  await writeCoreProposal('gov-localchain', defaultProposalBuilder);
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('gov-localchain', defaultProposalBuilder);
 };

package/scripts/vats/init-network.js

@@ -1,6 +1,6 @@
 import { makeHelpers } from '@agoric/deploy-script-support';
 
-/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').ProposalBuilder} */
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').CoreEvalBuilder} */
 export const defaultProposalBuilder = async ({ publishRef, install }) =>
   harden({
     sourceSpec: '@agoric/vats/src/proposals/network-proposal.js',
@@ -13,7 +13,8 @@ export const defaultProposalBuilder = async ({ publishRef, install }) =>
     ],
   });
 
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
 export default async (homeP, endowments) => {
-  const { writeCoreProposal } = await makeHelpers(homeP, endowments);
-  await writeCoreProposal('gov-network', defaultProposalBuilder);
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('gov-network', defaultProposalBuilder);
 };

package/scripts/vats/init-orchestration.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/orchestration/src/proposals/orchestration-proposal.js',
+    getManifestCall: [
+      'getManifestForOrchestration',
+      {
+        orchestrationRef: publishRef(
+          install('@agoric/orchestration/src/vat-orchestration.js'),
+        ),
+      },
+    ],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+  await writeCoreEval('gov-orchestration', defaultProposalBuilder);
+};

package/scripts/vats/init-transfer.js

@@ -0,0 +1,19 @@
+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/transfer-proposal.js',
+    getManifestCall: [
+      'getManifestForTransfer',
+      {
+        transferRef: publishRef(install('@agoric/vats/src/vat-transfer.js')),
+      },
+    ],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { writeCoreProposal } = await makeHelpers(homeP, endowments);
+  await writeCoreProposal('gov-transfer', defaultProposalBuilder);
+};