feat: publish vote results from the voteCounter

packages/governance/src/binaryVoteCounter.js

@@ -3,6 +3,7 @@
 import { Far } from '@endo/marshal';
 import { makePromiseKit } from '@endo/promise-kit';
 import { makeHeapFarInstance, keyEQ, makeStore } from '@agoric/store';
+import { E } from '@endo/eventual-send';
 
 import {
   buildUnrankedQuestion,
@@ -53,7 +54,12 @@ const validateBinaryQuestionSpec = questionSpec => {
 // independently. The standard Zoe start function is at the bottom of this file.
 
 /** @type {BuildVoteCounter} */
-const makeBinaryVoteCounter = (questionSpec, threshold, instance) => {
+const makeBinaryVoteCounter = (
+  questionSpec,
+  threshold,
+  instance,
+  publisher,
+) => {
   validateBinaryQuestionSpec(questionSpec);
 
   const question = buildUnrankedQuestion(questionSpec, instance);
@@ -113,6 +119,12 @@ const makeBinaryVoteCounter = (questionSpec, threshold, instance) => {
 
     if (!makeQuorumCounter(threshold).check(stats)) {
       outcomePromise.reject('No quorum');
+      const voteOutcome = {
+        question: details.questionHandle,
+        outcome: 'No quorum',
+      };
+      // @ts-expect-error Expand type to allow non-position?
+      E(publisher).publish(voteOutcome);
       return;
     }
 
@@ -123,6 +135,12 @@ const makeBinaryVoteCounter = (questionSpec, threshold, instance) => {
     } else {
       outcomePromise.resolve(questionSpec.tieOutcome);
     }
+
+    // XXX if we should distinguish ties, publish should be called in if above
+    E.when(outcomePromise.promise, outcome => {
+      const voteOutcome = { question: details.questionHandle, outcome };
+      return E(publisher).publish(voteOutcome);
+    });
   };
 
   const closeFacet = makeHeapFarInstance(
@@ -198,7 +216,7 @@ const makeBinaryVoteCounter = (questionSpec, threshold, instance) => {
 /**
  * @type {ContractStartFn<VoteCounterPublicFacet, VoteCounterCreatorFacet, {questionSpec: QuestionSpec, quorumThreshold: bigint}>}
  */
-const start = zcf => {
+const start = (zcf, { outcomesPublisher }) => {
   // There are a variety of ways of counting quorums. The parameters must be
   // visible in the terms. We're doing a simple threshold here. If we wanted to
   // discount abstentions, we could refactor to provide the quorumCounter as a
@@ -210,6 +228,7 @@ const start = zcf => {
     questionSpec,
     quorumThreshold,
     zcf.getInstance(),
+    outcomesPublisher,
   );
 
   scheduleClose(questionSpec.closingRule, () => closeFacet.closeVoting());

packages/governance/src/committee.js

@@ -43,12 +43,12 @@ const start = (zcf, privateArgs) => {
   const allQuestions = makeStore('Question');
   assert(privateArgs?.storageNode, 'Missing storageNode');
   assert(privateArgs?.marshaller, 'Missing marshaller');
+  const questionNode = E(privateArgs.storageNode).makeChildNode(
+    'latestQuestion',
+  );
   /** @type {StoredPublishKit<QuestionDetails>} */
   const { subscriber: questionsSubscriber, publisher: questionsPublisher } =
-    makeStoredPublishKit(
-      E(privateArgs.storageNode).makeChildNode('latestQuestion'),
-      privateArgs.marshaller,
-    );
+    makeStoredPublishKit(questionNode, privateArgs.marshaller);
 
   const makeCommitteeVoterInvitation = index => {
     /** @type {OfferHandler} */
@@ -158,13 +158,24 @@ const start = (zcf, privateArgs) => {
           }
         };
 
+        const outcomeNode = E(privateArgs.storageNode).makeChildNode(
+          'latestOutcome',
+        );
+
+        /** @type {StoredPublishKit<{question: Handle<'Question'>,outcome: Position}>} */
+        const { publisher: outcomesPublisher } = makeStoredPublishKit(
+          outcomeNode,
+          privateArgs.marshaller,
+        );
+
         return startCounter(
           zcf,
           questionSpec,
           quorumThreshold(questionSpec.quorumRule),
           voteCounter,
           allQuestions,
           questionsPublisher,
+          outcomesPublisher,
         );
       },
       getVoterInvitations() {

packages/governance/src/electorateTools.js

@@ -14,7 +14,8 @@ const startCounter = async (
   quorumThreshold,
   voteCounter,
   questionStore,
-  publisher,
+  questionsPublisher,
+  outcomesPublisher,
 ) => {
   const voteCounterTerms = {
     questionSpec,
@@ -26,10 +27,10 @@ const startCounter = async (
   /** @type {{ creatorFacet: VoteCounterCreatorFacet, publicFacet: VoteCounterPublicFacet, instance: Instance }} */
   const { creatorFacet, publicFacet, instance } = await E(
     zcf.getZoeService(),
-  ).startInstance(voteCounter, {}, voteCounterTerms);
+  ).startInstance(voteCounter, {}, voteCounterTerms, { outcomesPublisher });
   const details = await E(publicFacet).getDetails();
   const { deadline } = questionSpec.closingRule;
-  publisher.publish(details);
+  questionsPublisher.publish(details);
   const questionHandle = details.questionHandle;
 
   const voteCounterFacets = { voteCap: creatorFacet, publicFacet, deadline };

packages/governance/src/internalTypes.js

@@ -13,5 +13,6 @@
  * @param {ERef<Installation>} voteCounter
  * @param {Store<Handle<'Question'>, QuestionRecord>} questionStore
  * @param {Publisher<unknown>} publisher
+ * @param {Publisher<{question: Handle<'Question'>,outcome: Position}>} storageNode`
  * @returns {AddQuestionReturn}
  */

packages/governance/src/types.js

@@ -213,6 +213,7 @@
  * @param {bigint} threshold - questionSpec includes quorumRule; the electorate
  *    converts that to a number that the counter can enforce.
  * @param {Instance} instance
+ * @param {ERef<Publisher<{question: Handle<'Question'>,outcome: Position}>>} publisher
  * @returns {VoteCounterFacets}
  */