feat: ICA Probe contract (WIP)

Author: dckc

packages/orch-skel/package.json

@@ -22,7 +22,6 @@
     "@agoric/cosmic-proto": "^0.4.0",
     "@agoric/ertp": "^0.16.2",
     "@agoric/fast-usdc": "^0.1.0",
-    "@agoric/internal": "^0.3.2",
     "@agoric/swingset-liveslots": "^0.10.2",
     "@agoric/vow": "^0.1.0",
     "@agoric/zoe": "^0.26.2",
@@ -36,6 +35,7 @@
     "ts-blank-space": "^0.6.1"
   },
   "dependencies": {
+    "@agoric/internal": "^0.3.2",
     "@agoric/orchestration": "^0.1.0",
     "@agoric/vats": "^0.15.1",
     "@endo/errors": "^1.2.10",
@@ -60,4 +60,4 @@
     ],
     "timeout": "20m"
   }
-}
+}

packages/orch-skel/src/ica-probe.contract.js

@@ -0,0 +1,54 @@
+// @ts-check
+import { makeTracer, mustMatch } from '@agoric/internal';
+import { withOrchestration, ChainInfoShape } from '@agoric/orchestration';
+import { M } from '@endo/patterns';
+import * as flows from './ica-probe.flows.js';
+
+/**
+ * @import {TypedPattern} from '@agoric/internal';
+ * @import { ZCF } from '@agoric/zoe/src/zoeService/zoe.js';
+ * @import {Zone} from '@agoric/zone';
+ * @import {ChainInfo} from '@agoric/orchestration';
+ * @import {OrchestrationPowers, OrchestrationTools} from '@agoric/orchestration/src/utils/start-helper.js';
+ */
+
+const trace = makeTracer('ICApr');
+
+/** @type {TypedPattern<{ name: string, chainInfo: ChainInfo }>} */
+const registerArgsShape = harden({
+  name: M.string(),
+  chainInfo: ChainInfoShape,
+});
+
+/**
+ * @param {ZCF} zcf
+ * @param {OrchestrationPowers} privateArgs
+ * @param {Zone} zone
+ * @param {OrchestrationTools} tools
+ */
+const contract = async (zcf, privateArgs, zone, tools) => {
+  const { makeICA } = tools.orchestrateAll(flows, {});
+
+  const registerChainHandler = zone.exo('rch', undefined, {
+    handle(seat, offerArgs) {
+      trace('TODO: charge fee to register chain');
+      mustMatch(offerArgs, registerArgsShape);
+      const { name, chainInfo } = offerArgs;
+      tools.chainHub.registerChain(name, chainInfo);
+      return name;
+    },
+  });
+
+  const publicFacet = zone.exo('ICAProbeAPI', undefined, {
+    makeRegisterChainInvitation() {
+      return zcf.makeInvitation(registerChainHandler, 'register chain');
+    },
+    makeMakeICAIinvitation() {
+      return zcf.makeInvitation(makeICA, 'makeICA');
+    },
+  });
+
+  return { publicFacet };
+};
+
+export const start = withOrchestration(contract);

packages/orch-skel/src/ica-probe.deploy.js

@@ -0,0 +1,90 @@
+import { deeplyFulfilledObject } from '@agoric/internal';
+import { E } from '@endo/far';
+
+/**
+ * @import {CoreEvalBuilder, DeployScriptFunction} from '@agoric/deploy-script-support/src/externalTypes.js'
+ */
+
+const trace = (...args) => console.log('ICAPd', ...args);
+
+export const startICAProbe = async powers => {
+  trace('startICAProbe');
+  const {
+    agoricNames,
+    localchain,
+    board,
+    cosmosInterchainService,
+    chainStorage,
+    chainTimerService,
+  } = powers.consume;
+  const marshaller = await E(board).getReadonlyMarshaller();
+  const privateArgs = await deeplyFulfilledObject(
+    harden({
+      agoricNames,
+      localchain,
+      marshaller,
+      orchestrationService: cosmosInterchainService,
+      storageNode: E(chainStorage).makeChildNode('StkC'),
+      timerService: chainTimerService,
+    }),
+  );
+  trace('privateArgs', Object.keys(privateArgs));
+  const { startUpgradable } = powers.consume;
+  const { ICAProbe: installation } = powers.installation.consume;
+  const kit = E(startUpgradable)({
+    label: 'ICAProbe',
+    installation,
+    privateArgs,
+  });
+  trace('started ICAProbe', Object.keys(kit));
+  powers.instance.ICAProbe.produce(kit.instance);
+  trace('done');
+};
+
+const orchPermit = {
+  consume: {
+    agoricNames: true,
+    chainTimerService: true,
+    chainStorage: true,
+    cosmosInterchainService: true,
+    localchain: true,
+  },
+};
+
+export const getManifest = ({ restoreRef }, { installationRef, options }) => {
+  return {
+    manifest: {
+      [startICAProbe.name]: {
+        consume: { ...orchPermit.consume, board: true, startUpgradable: true },
+        installation: { consume: { ICAProbe: true } },
+        instance: { produce: { ICAProbe: true } },
+      },
+    },
+    installations: { ICAProbe: restoreRef(installationRef) },
+    options,
+  };
+};
+
+/** @satisfies {CoreEvalBuilder} */
+export const defaultProposalBuilder = async (
+  { publishRef, install },
+  options,
+) =>
+  harden({
+    sourceSpec: './ica-probe.deploy.js',
+    getManifestCall: [
+      getManifest.name,
+      {
+        installationRef: publishRef(install('./ica-probe.contract.js')),
+        options,
+      },
+    ],
+  });
+
+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(startICAProbe.name, defaultProposalBuilder);
+};

packages/orch-skel/src/ica-probe.flows.js

@@ -0,0 +1,28 @@
+// @ts-check
+import { makeTracer, mustMatch } from '@agoric/internal';
+
+const trace = makeTracer('flows');
+
+/**
+ * @import {Orchestrator, OrchestrationFlow } from '@agoric/orchestration';
+ * @import { ZCFSeat } from '@agoric/zoe/src/zoeService/zoe.js';
+ * @import {Passable, CopyRecord} from '@endo/pass-style';
+ */
+
+/**
+ * @satisfies {OrchestrationFlow}
+ * @param {Orchestrator} orch
+ * @param {{ }} _ctx
+ * @param {ZCFSeat & Passable} seat
+ * @param {{ chainName: string } & CopyRecord } offerArgs
+ */
+export const makeICA = async (orch, _ctx, seat, { chainName }) => {
+  trace('TODO: charge fee', seat.getProposal());
+  const chain = await orch.getChain(chainName);
+  trace('making ICA on', chainName);
+  const ica = await chain.makeAccount();
+  const addr = await ica.getAddress();
+  trace('make ICA with addr', addr);
+  trace('TODO: dispose of ICA? retain it?');
+  return addr;
+};

packages/orch-skel/test/ica-probe-contract.test.ts

@@ -0,0 +1,79 @@
+// prepare-test-env has to go 1st; use a blank line to separate it
+import { test } from '@agoric/zoe/tools/prepare-test-env-ava.js';
+
+import type { CoinSDKType } from '@agoric/cosmic-proto/cosmos/base/v1beta1/coin.js';
+import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
+import { heapVowE as VE } from '@agoric/vow/vat.js';
+import { setUpZoeForTest } from '@agoric/zoe/tools/setup-zoe.js';
+import { E, passStyleOf } from '@endo/far';
+import { Nat } from '@endo/nat';
+import { M, mustMatch } from '@endo/patterns';
+import { createRequire } from 'module';
+import { ChainAddressShape } from '@agoric/orchestration';
+import { buildVTransferEvent } from '@agoric/orchestration/tools/ibc-mocks.js';
+import { commonSetup } from './supports.js';
+
+const nodeRequire = createRequire(import.meta.url);
+
+const contractName = 'myOrchContract';
+const contractFile = nodeRequire.resolve('../src/ica-probe.contract.js');
+type StartFn = typeof import('../src/ica-probe.contract.js').start;
+
+test('start my orch contract', async t => {
+  const common = await commonSetup(t);
+  const { zoe, bundleAndInstall } = await setUpZoeForTest();
+  t.log('contract deployment', contractName);
+
+  const installation: Installation<StartFn> =
+    await bundleAndInstall(contractFile);
+  t.is(passStyleOf(installation), 'remotable');
+
+  const myKit = await E(zoe).startInstance(
+    installation,
+    {}, // issuers
+    {}, // terms
+    common.commonPrivateArgs,
+  );
+  t.notThrows(() =>
+    mustMatch(
+      myKit,
+      M.splitRecord({
+        instance: M.remotable(),
+        publicFacet: M.remotable(),
+        creatorFacet: M.remotable(),
+        // ...others are not relevant here
+      }),
+    ),
+  );
+
+  {
+    const toRegister = await E(myKit.publicFacet).makeRegisterChainInvitation();
+    const { osmosis: chainInfo } = common.commonPrivateArgs.chainInfo;
+    const seat = await E(zoe).offer(
+      toRegister,
+      {},
+      {},
+      { name: 'osmosis', chainInfo },
+    );
+    const result = await E(seat).getOfferResult();
+    t.log('register result', result);
+    t.is(result, 'osmosis');
+  }
+  {
+    const toMakeICA = await E(myKit.publicFacet).makeMakeICAIinvitation();
+    const seat = await E(zoe).offer(
+      toMakeICA,
+      {},
+      {},
+      { chainName: 'osmosis' },
+    );
+    const { vowTools } = common.utils;
+    const result = await vowTools.when(await E(seat).getOfferResult());
+    t.log('register result', result);
+    t.deepEqual(result, {
+      chainId: 'osmosis-1',
+      encoding: 'bech32',
+      value: 'cosmos1test',
+    });
+  }
+});