@agoric/builders 0.2.0-u20.0 → 0.2.0-u21.0.1

package/scripts/orchestration/axelar-gmp.build.js

@@ -0,0 +1,74 @@
+import { execFileSync } from 'node:child_process';
+import { makeHelpers } from '@agoric/deploy-script-support';
+import { parseArgs } from 'node:util';
+import {
+  getManifest,
+  startAxelarGmp,
+} from '@agoric/orchestration/src/proposals/start-axelar-gmp.js';
+import { assetInfo } from '@agoric/orchestration/src/utils/axelar-static-config.js';
+import { getChainConfig } from './get-chain-config.js';
+
+/** @typedef {{ net?: string, peer?: string[] }} PeerChainOpts */
+
+/**
+ * @import {CoreEvalBuilder} from '@agoric/deploy-script-support/src/externalTypes.js';
+ */
+
+/** @type {CoreEvalBuilder} */
+export const defaultProposalBuilder = async (
+  { publishRef, install },
+  options,
+) =>
+  harden({
+    sourceSpec: '@agoric/orchestration/src/proposals/start-axelar-gmp.js',
+    getManifestCall: [
+      getManifest.name,
+      {
+        installationRef: publishRef(
+          install('@agoric/orchestration/dist/axelar-gmp.contract.bundle.js'),
+        ),
+        options,
+      },
+    ],
+  });
+
+/** @type {import('@agoric/deploy-script-support/src/externalTypes.js').DeployScriptFunction} */
+export default async (homeP, endowments) => {
+  const { scriptArgs } = endowments;
+
+  /** @type {import('node:util').ParseArgsConfig['options']} */
+  const options = {
+    net: {
+      type: 'string',
+    },
+    peer: { type: 'string', multiple: true },
+  };
+
+  /** @type {{ values: PeerChainOpts }} */
+  const { values: flags } = parseArgs({ args: scriptArgs, options });
+
+  const parseAssetInfo = () => {
+    if (typeof assetInfo !== 'string') return undefined;
+    return JSON.parse(assetInfo);
+  };
+
+  if (!flags.net) throw Error('--net required');
+  if (!flags.peer) throw Error('--peer required');
+
+  const chainDetails = await getChainConfig({
+    net: flags.net,
+    peers: flags.peer,
+    execFileSync,
+  });
+
+  const opts = harden({
+    chainInfo: chainDetails,
+    assetInfo: parseAssetInfo(),
+  });
+
+  const { writeCoreEval } = await makeHelpers(homeP, endowments);
+
+  await writeCoreEval(startAxelarGmp.name, utils =>
+    defaultProposalBuilder(utils, opts),
+  );
+};

package/scripts/orchestration/get-chain-config.js

@@ -0,0 +1,117 @@
+import { IBCConnectionInfoShape } from '@agoric/orchestration/src/typeGuards.js';
+import { mustMatch } from '@endo/patterns';
+import { makeAgd } from '@agoric/orchestration/src/utils/agd-lib.js';
+import { networkConfigs } from '@agoric/orchestration/src/utils/gmp.js';
+import * as childProcess from 'node:child_process';
+import fetchedChainInfo from '@agoric/orchestration/src/fetched-chain-info.js';
+
+/**
+ * @import {IBCChannelID, IBCConnectionID} from '@agoric/vats';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '@agoric/orchestration'
+ */
+
+/** @param {string[]} strs */
+const parsePeers = strs => {
+  /** @type {[name: string, conn: IBCConnectionID, chan: IBCChannelID, denom:string][]} */
+  // @ts-expect-error XXX ID syntax should be dynamically checked
+  const peerParts = strs.map(s => s.split(':'));
+  const badPeers = peerParts.filter(d => d.length !== 4);
+  if (badPeers.length) {
+    throw Error(
+      `peers must be name:connection-X:channel-Y:denom, not ${badPeers.join(', ')}`,
+    );
+  }
+  return peerParts;
+};
+
+/**
+ * Get the IBC chain configuration based on the provided network and peer inputs.
+ *
+ * @param {object} args - The arguments object.
+ * @param {string} args.net - The network name (e.g., 'emerynet').
+ * @param {string[]} args.peers - The peers to connect .
+ * @param {childProcess.execFileSync} [args.execFileSync] - Optional execFileSync function.
+ * @returns {Promise<Record<string, CosmosChainInfo>>} A promise that resolves to the chain configuration details keyed by chain name.
+ */
+
+export const getChainConfig = async ({
+  net,
+  peers,
+  execFileSync = childProcess.execFileSync,
+}) => {
+  await null;
+
+  if (net === 'bootstrap') {
+    return {
+      agoric: fetchedChainInfo.agoric,
+      axelar: fetchedChainInfo.axelar,
+    };
+  }
+
+  /** @type {Record<string, CosmosChainInfo>} */
+  const chainDetails = {};
+
+  /** @type {Record<string, IBCConnectionInfo>} */
+  const connections = {};
+  const portId = 'transfer';
+
+  const { chainId, rpc } = networkConfigs[net];
+  const agd = makeAgd({ execFileSync }).withOpts({ rpcAddrs: [rpc] });
+
+  for (const [peerName, myConn, myChan, denom] of parsePeers(peers)) {
+    console.debug(peerName, { denom });
+    const connInfo = await agd
+      .query(['ibc', 'connection', 'end', myConn])
+      .then(x => x.connection);
+    const { client_id: clientId } = connInfo;
+    const clientState = await agd
+      .query(['ibc', 'client', 'state', clientId])
+      .then(x => x.client_state);
+    const { chain_id: peerId } = clientState;
+    console.debug(peerName, { chainId: peerId, denom });
+    chainDetails[peerName] = {
+      namespace: 'cosmos',
+      reference: peerId,
+      chainId: peerId,
+      stakingTokens: [{ denom }],
+      bech32Prefix: peerName,
+    };
+
+    const chan = await agd
+      .query(['ibc', 'channel', 'end', portId, myChan])
+      .then(r => r.channel);
+
+    /** @type {IBCConnectionInfo} */
+    const info = harden({
+      client_id: clientId,
+      counterparty: {
+        client_id: connInfo.counterparty.client_id,
+        connection_id: connInfo.counterparty.connection_id,
+      },
+      id: myConn,
+      state: connInfo.state,
+      transferChannel: {
+        channelId: myChan,
+        counterPartyChannelId: chan.counterparty.channel_id,
+        counterPartyPortId: chan.counterparty.port_id,
+        ordering: chan.ordering,
+        portId,
+        state: chan.state,
+        version: chan.version,
+      },
+    });
+    mustMatch(info, IBCConnectionInfoShape);
+    connections[peerId] = info;
+  }
+
+  chainDetails.agoric = {
+    namespace: 'cosmos',
+    reference: chainId,
+    chainId,
+    stakingTokens: [{ denom: 'ubld' }],
+    connections,
+    bech32Prefix: 'agoric',
+  };
+
+  return chainDetails;
+};

package/scripts/orchestration/helpers.js

@@ -0,0 +1,46 @@
+/**
+ * @import {DeployScriptEndownments} from '@agoric/deploy-script-support/src/externalTypes.js';
+ * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
+ * @import {ParseArgsConfig} from 'node:util'
+ */
+
+/**
+ * Parse `chainInfo` and `assetInfo` into builder opts
+ *
+ * NOTE: Ambient authority via `node:util`
+ *
+ * @param {DeployScriptEndownments['scriptArgs']} scriptArgs
+ * @returns {Promise<{
+ *      chainInfo: Record<string, CosmosChainInfo>;
+ *     assetInfo: [Denom, DenomDetail & { brandKey?: string }][];
+ * }>}
+ */
+export const parseChainHubOpts = async scriptArgs => {
+  // import dynamically so the modules can work in CoreEval environment
+  const { parseArgs } = await import('node:util');
+
+  /** @type {ParseArgsConfig['options']} */
+  const parserOpts = {
+    chainInfo: { type: 'string' },
+    assetInfo: { type: 'string' },
+  };
+  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);
+  };
+  return harden({
+    chainInfo: parseChainInfo(),
+    assetInfo: parseAssetInfo(),
+  });
+};

package/scripts/orchestration/init-basic-flows.js

@@ -1,16 +1,6 @@
 import { makeHelpers } from '@agoric/deploy-script-support';
 import { startBasicFlows } from '@agoric/orchestration/src/proposals/start-basic-flows.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 './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(startBasicFlows.name, utils =>
     defaultProposalBuilder(utils, opts),
   );

package/scripts/orchestration/init-stakeAtom.js

@@ -1,7 +1,11 @@
 import { makeHelpers } from '@agoric/deploy-script-support';
+import { parseChainHubOpts } from './helpers.js';
 
 /** @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({
     sourceSpec: '@agoric/orchestration/src/proposals/start-stakeAtom.js',
     getManifestCall: [
@@ -12,6 +16,7 @@ export const defaultProposalBuilder = async ({ publishRef, install }) => {
             install('@agoric/orchestration/src/examples/stake-ica.contract.js'),
           ),
         },
+        options,
       },
     ],
   });
@@ -19,6 +24,10 @@ export const defaultProposalBuilder = async ({ publishRef, install }) => {
 
 /** @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('start-stakeAtom', defaultProposalBuilder);
+  await writeCoreEval('start-stakeAtom', utils =>
+    defaultProposalBuilder(utils, opts),
+  );
 };

package/scripts/orchestration/init-stakeOsmo.js

@@ -1,7 +1,11 @@
 import { makeHelpers } from '@agoric/deploy-script-support';
+import { parseChainHubOpts } from './helpers.js';
 
 /** @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({
     sourceSpec: '@agoric/orchestration/src/proposals/start-stakeOsmo.js',
     getManifestCall: [
@@ -12,6 +16,7 @@ export const defaultProposalBuilder = async ({ publishRef, install }) => {
             install('@agoric/orchestration/src/examples/stake-ica.contract.js'),
           ),
         },
+        options,
       },
     ],
   });
@@ -19,6 +24,10 @@ export const defaultProposalBuilder = async ({ publishRef, install }) => {
 
 /** @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('start-stakeOsmo', defaultProposalBuilder);
+  await writeCoreEval('start-stakeOsmo', utils =>
+    defaultProposalBuilder(utils, opts),
+  );
 };

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

@@ -6,17 +6,7 @@
  */
 import { makeHelpers } from '@agoric/deploy-script-support';
 import { startAutoStakeIt } from '@agoric/orchestration/src/proposals/start-auto-stake-it.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 (
@@ -44,29 +34,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(startAutoStakeIt.name, utils =>
     defaultProposalBuilder(utils, opts),
   );

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