@agoric/cosmic-swingset 0.41.4-dev-42d1d4f.0 → 0.41.4-dev-a7d06d8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/cosmic-swingset",
-  "version": "0.41.4-dev-42d1d4f.0+42d1d4f",
+  "version": "0.41.4-dev-a7d06d8.0+a7d06d8",
   "description": "Agoric's Cosmos blockchain integration",
   "type": "module",
   "bin": {
@@ -22,15 +22,15 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/builders": "0.1.1-dev-42d1d4f.0+42d1d4f",
-    "@agoric/cosmos": "0.34.2-dev-42d1d4f.0+42d1d4f",
-    "@agoric/deploy-script-support": "0.10.4-dev-42d1d4f.0+42d1d4f",
-    "@agoric/internal": "0.3.3-dev-42d1d4f.0+42d1d4f",
-    "@agoric/store": "0.9.3-dev-42d1d4f.0+42d1d4f",
-    "@agoric/swing-store": "0.9.2-dev-42d1d4f.0+42d1d4f",
-    "@agoric/swingset-vat": "0.32.3-dev-42d1d4f.0+42d1d4f",
-    "@agoric/telemetry": "0.6.3-dev-42d1d4f.0+42d1d4f",
-    "@agoric/vm-config": "0.1.1-dev-42d1d4f.0+42d1d4f",
+    "@agoric/builders": "0.1.1-dev-a7d06d8.0+a7d06d8",
+    "@agoric/cosmos": "0.34.2-dev-a7d06d8.0+a7d06d8",
+    "@agoric/deploy-script-support": "0.10.4-dev-a7d06d8.0+a7d06d8",
+    "@agoric/internal": "0.3.3-dev-a7d06d8.0+a7d06d8",
+    "@agoric/store": "0.9.3-dev-a7d06d8.0+a7d06d8",
+    "@agoric/swing-store": "0.9.2-dev-a7d06d8.0+a7d06d8",
+    "@agoric/swingset-vat": "0.32.3-dev-a7d06d8.0+a7d06d8",
+    "@agoric/telemetry": "0.6.3-dev-a7d06d8.0+a7d06d8",
+    "@agoric/vm-config": "0.1.1-dev-a7d06d8.0+a7d06d8",
     "@endo/bundle-source": "^3.3.0",
     "@endo/env-options": "^1.1.5",
     "@endo/errors": "^1.2.4",
@@ -70,5 +70,5 @@
   "typeCoverage": {
     "atLeast": 80.6
   },
-  "gitHead": "42d1d4fa872b48c3851a66187cda08671a38c70c"
+  "gitHead": "a7d06d8884c22e8190916d0bb1454bf9f5e92b57"
 }

package/src/chain-main.js

@@ -48,6 +48,8 @@ import {
   validateImporterOptions,
 } from './import-kernel-db.js';
 
+const ignore = () => {};
+
 // eslint-disable-next-line no-unused-vars
 let whenHellFreezesOver = null;
 
@@ -62,6 +64,32 @@ const toNumber = specimen => {
   return number;
 };
 
+/**
+ * A boot message consists of cosmosInitAction fields that are subject to
+ * consensus. See cosmosInitAction in {@link ../../../golang/cosmos/app/app.go}.
+ *
+ * @param {any} initAction
+ */
+const makeBootMsg = initAction => {
+  const {
+    type,
+    blockTime,
+    blockHeight,
+    chainID,
+    params,
+    // NB: resolvedConfig is independent of consensus and MUST NOT be included
+    supplyCoins,
+  } = initAction;
+  return {
+    type,
+    blockTime,
+    blockHeight,
+    chainID,
+    params,
+    supplyCoins,
+  };
+};
+
 /**
  * @template {unknown} [T=unknown]
  * @param {(req: string) => string} call
@@ -214,7 +242,7 @@ export default async function main(progname, args, { env, homedir, agcc }) {
 
   const clearChainSends = async () => {
     // Cosmos should have blocked before calling commit, but wait just in case
-    await stateSyncExport?.exporter?.onStarted().catch(() => {});
+    await stateSyncExport?.exporter?.onStarted().catch(ignore);
 
     const chainSends = savedChainSends;
     savedChainSends = [];
@@ -246,10 +274,15 @@ export default async function main(progname, args, { env, homedir, agcc }) {
   /** @type {((obj: object) => void) | undefined} */
   let writeSlogObject;
 
-  // the storagePort used to change for every single message. It's defined out
+  // In the past, storagePort could change with every message. It's defined out
   // here so 'sendToChainStorage' can close over the single mutable instance,
   // when we updated the 'portNums.storage' value each time toSwingSet was called.
-  async function launchAndInitializeSwingSet(bootMsg) {
+  async function launchAndInitializeSwingSet(initAction) {
+    // As a kludge, back-propagate selected configuration into environment variables.
+    const { slogfile } = initAction.resolvedConfig || {};
+    // eslint-disable-next-line dot-notation
+    if (slogfile) env['SLOGFILE'] = slogfile;
+
     const sendToChainStorage = msg => chainSend(portNums.storage, msg);
     // this object is used to store the mailbox state.
     const fromBridgeMailbox = data => {
@@ -363,7 +396,7 @@ export default async function main(progname, args, { env, homedir, agcc }) {
     };
 
     const argv = {
-      bootMsg,
+      bootMsg: makeBootMsg(initAction),
     };
     const getVatConfig = async () => {
       const vatHref = await importMetaResolve(
@@ -489,21 +522,19 @@ export default async function main(progname, args, { env, homedir, agcc }) {
 
     let pendingBlockingSend = Promise.resolve();
 
-    registerShutdown(async interrupted =>
-      Promise.all([
+    registerShutdown(async interrupted => {
+      await Promise.all([
         interrupted && pendingBlockingSend.then(shutdown),
         discardStateSyncExport(),
-      ]).then(() => {}),
-    );
+      ]);
+    });
 
-    return async action => {
+    const blockingSendSpy = async action => {
       const result = blockingSend(action);
-      pendingBlockingSend = Promise.resolve(result).then(
-        () => {},
-        () => {},
-      );
+      pendingBlockingSend = Promise.resolve(result).then(ignore, ignore);
       return result;
     };
+    return blockingSendSpy;
   }
 
   /** @type {Awaited<ReturnType<typeof launch>>['blockingSend'] | undefined} */
@@ -658,6 +689,7 @@ export default async function main(progname, args, { env, homedir, agcc }) {
 
         !blockingSend || Fail`Swingset already initialized`;
 
+        // Capture "port numbers" for communicating with cosmos modules.
         for (const [key, value] of Object.entries(action)) {
           const portAlias = CosmosInitKeyToBridgeId[key];
           if (portAlias) {

package/src/launch-chain.js

@@ -214,7 +214,7 @@ export async function buildSwingset(
     return bridgedCoreProposals;
   }
 
-  const coreProposals = await ensureSwingsetInitialized();
+  const pendingCoreProposals = await ensureSwingsetInitialized();
   upgradeSwingset(kernelStorage);
   const controller = await makeSwingsetController(
     kernelStorage,
@@ -233,7 +233,7 @@ export async function buildSwingset(
   // (either on bootstrap block (0) or in endBlock).
 
   return {
-    coreProposals,
+    coreProposals: pendingCoreProposals,
     controller,
     mb: mailboxDevice,
     bridgeInbound: bridgeDevice.deliverInbound,
@@ -568,8 +568,15 @@ export async function launch({
   let savedBeginHeight = Number(
     kvStore.get(getHostKey('beginHeight')) || savedHeight,
   );
+  /**
+   * duration of the latest swingset execution in either END_BLOCK or
+   * once-per-chain bootstrap (the latter excluding "bridged" core proposals
+   * that run outside the bootstrap vat)
+   */
   let runTime = 0;
+  /** duration of the latest saveChainState(), which commits mailbox data to chain storage */
   let chainTime;
+  /** duration of the latest saveOutsideState(), which commits to swing-store host storage */
   let saveTime = 0;
   let endBlockFinish = 0;
   let blockParams;
@@ -724,33 +731,16 @@ export async function launch({
 
   /**
    * @template T
-   * @param {string} type
+   * @param {string} label
    * @param {() => Promise<T>} fn
+   * @param {() => void} onSettled
    */
-  async function processAction(type, fn) {
-    const start = Date.now();
-    const finish = res => {
-      // blockManagerConsole.error(
-      //   'Action',
-      //   action.type,
-      //   action.blockHeight,
-      //   'is done!',
-      // );
-      runTime += Date.now() - start;
-      return res;
-    };
-
+  function withErrorLogging(label, fn, onSettled) {
     const p = fn();
-    // Just attach some callbacks, but don't use the resulting neutered result
-    // promise.
-    void E.when(p, finish, e => {
-      // None of these must fail, and if they do, log them verbosely before
-      // returning to the chain.
-      blockManagerConsole.error(type, 'error:', e);
-      finish();
+    void E.when(p, onSettled, err => {
+      blockManagerConsole.error(label, 'error:', err);
+      onSettled();
     });
-    // Return the original promise so that the caller gets the original
-    // resolution or rejection.
     return p;
   }
 
@@ -821,8 +811,13 @@ export async function launch({
       // Start a block transaction, but without changing state
       // for the upcoming begin block check
       saveBeginHeight(savedBeginHeight);
-      await processAction(action.type, async () =>
-        bootstrapBlock(blockHeight, blockTime, bootstrapBlockParams),
+      const start = Date.now();
+      await withErrorLogging(
+        action.type,
+        () => bootstrapBlock(blockHeight, blockTime, bootstrapBlockParams),
+        () => {
+          runTime += Date.now() - start;
+        },
       );
     } finally {
       controller.writeSlogObject({
@@ -927,17 +922,16 @@ export async function launch({
           await doBootstrap(action);
         }
 
-        // Merge the core proposals from the bootstrap block with the
-        // ones from the upgrade.
+        // Concatenate together any pending core proposals from chain bootstrap
+        // with any from this inbound init action, then execute them all.
         const coreProposals = mergeCoreProposals(
           bootstrapCoreProposals,
           softwareUpgradeCoreProposals,
           upgradeInfoCoreProposals,
         );
-
         if (coreProposals.steps.length) {
-          upgradeDetails ||
-            isBootstrap ||
+          isBootstrap ||
+            upgradeDetails ||
             Fail`Unexpected core proposals outside of consensus start`;
           await doCoreProposals(action, coreProposals);
         }
@@ -964,9 +958,9 @@ export async function launch({
         });
 
         // Save the kernel's computed state just before the chain commits.
-        const start2 = Date.now();
+        const start = Date.now();
         await saveOutsideState(savedHeight);
-        saveTime = Date.now() - start2;
+        saveTime = Date.now() - start;
 
         blockParams = undefined;
 
@@ -1064,14 +1058,19 @@ export async function launch({
 
           provideInstallationPublisher();
 
-          await processAction(action.type, async () =>
-            endBlock(blockHeight, blockTime, blockParams),
+          const start = Date.now();
+          await withErrorLogging(
+            action.type,
+            () => endBlock(blockHeight, blockTime, blockParams),
+            () => {
+              runTime += Date.now() - start;
+            },
           );
 
           // We write out our on-chain state as a number of chainSends.
-          const start = Date.now();
+          const start2 = Date.now();
           await saveChainState();
-          chainTime = Date.now() - start;
+          chainTime = Date.now() - start2;
 
           // Advance our saved state variables.
           savedHeight = blockHeight;