@agoric/governance 0.10.4-dev-cbcea8c.0.cbcea8c → 0.10.4-dev-04baeed.0.04baeed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/governance",
-  "version": "0.10.4-dev-cbcea8c.0.cbcea8c",
+  "version": "0.10.4-dev-04baeed.0.04baeed",
   "description": "Core governance support",
   "type": "module",
   "main": "src/index.js",
@@ -29,13 +29,13 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/ertp": "0.16.3-dev-cbcea8c.0.cbcea8c",
-    "@agoric/internal": "0.3.3-dev-cbcea8c.0.cbcea8c",
-    "@agoric/notifier": "0.6.3-dev-cbcea8c.0.cbcea8c",
-    "@agoric/store": "0.9.3-dev-cbcea8c.0.cbcea8c",
-    "@agoric/time": "0.3.3-dev-cbcea8c.0.cbcea8c",
-    "@agoric/vat-data": "0.5.3-dev-cbcea8c.0.cbcea8c",
-    "@agoric/zoe": "0.26.3-dev-cbcea8c.0.cbcea8c",
+    "@agoric/ertp": "0.16.3-dev-04baeed.0.04baeed",
+    "@agoric/internal": "0.3.3-dev-04baeed.0.04baeed",
+    "@agoric/notifier": "0.6.3-dev-04baeed.0.04baeed",
+    "@agoric/store": "0.9.3-dev-04baeed.0.04baeed",
+    "@agoric/time": "0.3.3-dev-04baeed.0.04baeed",
+    "@agoric/vat-data": "0.5.3-dev-04baeed.0.04baeed",
+    "@agoric/zoe": "0.26.3-dev-04baeed.0.04baeed",
     "@endo/bundle-source": "^4.3.2",
     "@endo/captp": "^4.5.1",
     "@endo/errors": "^1.3.1",
@@ -47,7 +47,7 @@
     "import-meta-resolve": "^4.1.0"
   },
   "devDependencies": {
-    "@agoric/swingset-vat": "0.32.3-dev-cbcea8c.0.cbcea8c",
+    "@agoric/swingset-vat": "0.32.3-dev-04baeed.0.04baeed",
     "@endo/bundle-source": "^4.3.2",
     "@endo/init": "^1.1.13",
     "ava": "^7.0.0",
@@ -76,5 +76,5 @@
   "typeCoverage": {
     "atLeast": 89.5
   },
-  "gitHead": "cbcea8c2415f2c9c4bc1ea9ff90730f2773bafaa"
+  "gitHead": "04baeedd0adc9b2480dd9d272e8daffebc408662"
 }

package/source-spec-registry.d.ts

@@ -20,7 +20,7 @@ export namespace governanceSourceSpecRegistry {
         let sourceSpec_2: string;
         export { sourceSpec_2 as sourceSpec };
     }
-    namespace puppetContractGovernor {
+    namespace econCommitteeCharter {
         let bundleName_3: string;
         export { bundleName_3 as bundleName };
         let packagePath_3: string;
@@ -28,6 +28,14 @@ export namespace governanceSourceSpecRegistry {
         let sourceSpec_3: string;
         export { sourceSpec_3 as sourceSpec };
     }
+    namespace puppetContractGovernor {
+        let bundleName_4: string;
+        export { bundleName_4 as bundleName };
+        let packagePath_4: string;
+        export { packagePath_4 as packagePath };
+        let sourceSpec_4: string;
+        export { sourceSpec_4 as sourceSpec };
+    }
 }
 export function getGovernanceSourceSpec(name: keyof typeof governanceSourceSpecRegistry): {
     bundleName: string;
@@ -45,5 +53,9 @@ export function getGovernanceSourceSpec(name: keyof typeof governanceSourceSpecR
     bundleName: string;
     packagePath: string;
     sourceSpec: string;
+} | {
+    bundleName: string;
+    packagePath: string;
+    sourceSpec: string;
 };
 //# sourceMappingURL=source-spec-registry.d.ts.map

package/source-spec-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-spec-registry.d.ts","sourceRoot":"","sources":["source-spec-registry.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCO,8CADK,MAAM,OAAO,4BAA4B;;;;;;;;;;;;;;;;EAEjB"}
+{"version":3,"file":"source-spec-registry.d.ts","sourceRoot":"","sources":["source-spec-registry.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCO,8CADK,MAAM,OAAO,4BAA4B;;;;;;;;;;;;;;;;;;;;EAEjB"}

package/source-spec-registry.js

@@ -22,6 +22,13 @@ export const governanceSourceSpecRegistry = {
     packagePath: '@agoric/governance/src/contractGovernor.js',
     sourceSpec: resolveSourceSpec('@agoric/governance/src/contractGovernor.js'),
   },
+  econCommitteeCharter: {
+    bundleName: 'econCommitteeCharter',
+    packagePath: '@agoric/governance/src/econCommitteeCharter.js',
+    sourceSpec: resolveSourceSpec(
+      '@agoric/governance/src/econCommitteeCharter.js',
+    ),
+  },
   puppetContractGovernor: {
     bundleName: 'puppetContractGovernor',
     packagePath: '@agoric/governance/tools/puppetContractGovernor.js',

package/src/econCommitteeCharter.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @import {MapStore, SetStore} from '@agoric/store';
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {TimestampValue} from '@agoric/time';
+ * @import {ContractMeta, Installation, Instance, ZCF, ZCFSeat} from '@agoric/zoe';
+ * @import {GovernorCreatorFacet} from './types.js';
+ */
+/**
+ * @file This contract makes it possible for those who govern contracts to call
+ *   for votes on changes. A more complete implementation would validate
+ *   parameters, constrain deadlines and possibly split the ability to call for
+ *   votes into separate capabilities for finer grain encapsulation.
+ *
+ *   XXX There is nothing Inter-Protocol- or "econ"-specific in this module: it
+ *   is a generic charter over arbitrary governed contracts. The
+ *   `econCommitteeCharter` name (and the agoricNames registration that uses it)
+ *   is kept for legacy clarity and on-chain continuity. Relocated from
+ *   inter-protocol to @agoric/governance (refs #12719).
+ */
+export const INVITATION_MAKERS_DESC: "charter member invitation";
+/** @type {ContractMeta<typeof start>} */
+export const meta: ContractMeta<typeof start>;
+export function start(zcf: ZCF<{
+    binaryVoteCounterInstallation: Installation;
+}>, _privateArgs: undefined, baggage: Baggage): Promise<{
+    creatorFacet: import("@endo/exo").Guarded<{
+        /**
+         * @param {Instance<unknown>} governedInstance
+         * @param {GovernorCreatorFacet<any>} governorFacet
+         * @param {string} [label] for diagnostic use only
+         */
+        addInstance: (governedInstance: Instance<unknown>, governorFacet: GovernorCreatorFacet<any>, label?: string) => void;
+        makeCharterMemberInvitation: () => Promise<import("@agoric/zoe").Invitation<{
+            invitationMakers: import("@endo/exo").Guarded<{
+                VoteOnParamChange: () => Promise<import("@agoric/zoe").Invitation<import("./types.js").ContractGovernanceVoteResult, ParamChangesOfferArgs>>;
+                VoteOnPauseOffers: (instance: any, strings: any, deadline: any) => Promise<import("@agoric/zoe").Invitation<import("./types.js").ContractGovernanceVoteResult, undefined>>;
+                VoteOnApiCall: (instance: Instance<unknown>, methodName: string, methodArgs: string[], deadline: TimestampValue) => Promise<import("@agoric/zoe").Invitation<import("./types.js").ContractGovernanceVoteResult, undefined>>;
+            }>;
+        }, undefined>>;
+    }>;
+}>;
+export type ParamChangesOfferArgs = {
+    deadline: bigint;
+    instance: Instance<unknown>;
+    params: Record<string, unknown>;
+    /**
+     * paramPath is determined by contract
+     */
+    path?: {
+        paramPath: unknown;
+    } | undefined;
+};
+import type { ContractMeta } from '@agoric/zoe';
+import type { Installation } from '@agoric/zoe';
+import type { ZCF } from '@agoric/zoe';
+import type { Baggage } from '@agoric/vat-data';
+import type { Instance } from '@agoric/zoe';
+import type { GovernorCreatorFacet } from './types.js';
+import type { TimestampValue } from '@agoric/time';
+//# sourceMappingURL=econCommitteeCharter.d.ts.map

package/src/econCommitteeCharter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"econCommitteeCharter.d.ts","sourceRoot":"","sources":["econCommitteeCharter.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AAEH;;;;;;;;;;;GAWG;AAEH,qCAAsC,2BAA2B,CAAC;AAoBlE,yCAAyC;AACzC,mBADW,aAAa,OAAO,KAAK,CAAC,CAMnC;AAQK,2BAJI,IAAI;IAAE,6BAA6B,EAAE,YAAY,CAAA;CAAE,CAAC,gBACpD,SAAS,WACT,OAAO;;QAsHZ;;;;WAIG;wCAHQ,SAAS,OAAO,CAAC,iBACjB,qBAAqB,GAAG,CAAC,UACzB,MAAM;;;;;0CAzEV,SAAS,OAAO,CAAC,cACjB,MAAM,cACN,MAAM,EAAE,YACR,cAAc;;;;GAkF1B;;cAjKa,MAAM;cACN,SAAS,OAAO,CAAC;YACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;mBACV,OAAO;;;kCAxBmC,aAAa;kCAAb,aAAa;yBAAb,aAAa;6BAFxD,kBAAkB;8BAEyB,aAAa;0CAC3C,YAAY;oCAFlB,cAAc"}

package/src/econCommitteeCharter.js

@@ -0,0 +1,197 @@
+import { M, mustMatch } from '@agoric/store';
+import { TimestampShape } from '@agoric/time';
+import { prepareExo, provideDurableMapStore } from '@agoric/vat-data';
+import {
+  InstallationShape,
+  InstanceHandleShape,
+} from '@agoric/zoe/src/typeGuards.js';
+import { E } from '@endo/far';
+
+/**
+ * @import {MapStore, SetStore} from '@agoric/store';
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {TimestampValue} from '@agoric/time';
+ * @import {ContractMeta, Installation, Instance, ZCF, ZCFSeat} from '@agoric/zoe';
+ * @import {GovernorCreatorFacet} from './types.js';
+ */
+
+/**
+ * @file This contract makes it possible for those who govern contracts to call
+ *   for votes on changes. A more complete implementation would validate
+ *   parameters, constrain deadlines and possibly split the ability to call for
+ *   votes into separate capabilities for finer grain encapsulation.
+ *
+ *   XXX There is nothing Inter-Protocol- or "econ"-specific in this module: it
+ *   is a generic charter over arbitrary governed contracts. The
+ *   `econCommitteeCharter` name (and the agoricNames registration that uses it)
+ *   is kept for legacy clarity and on-chain continuity. Relocated from
+ *   inter-protocol to @agoric/governance (refs #12719).
+ */
+
+export const INVITATION_MAKERS_DESC = 'charter member invitation';
+
+/**
+ * @typedef {object} ParamChangesOfferArgs
+ * @property {bigint} deadline
+ * @property {Instance<unknown>} instance
+ * @property {Record<string, unknown>} params
+ * @property {{ paramPath: unknown }} [path] paramPath is determined by contract
+ */
+const ParamChangesOfferArgsShape = M.splitRecord(
+  {
+    deadline: TimestampShape,
+    instance: InstanceHandleShape,
+    params: M.recordOf(M.string(), M.any()),
+  },
+  {
+    path: { paramPath: { key: M.any() } },
+  },
+);
+
+/** @type {ContractMeta<typeof start>} */
+export const meta = {
+  customTermsShape: {
+    binaryVoteCounterInstallation: InstallationShape,
+  },
+  upgradability: 'canUpgrade',
+};
+harden(meta);
+
+/**
+ * @param {ZCF<{ binaryVoteCounterInstallation: Installation }>} zcf
+ * @param {undefined} _privateArgs
+ * @param {Baggage} baggage
+ */
+export const start = async (zcf, _privateArgs, baggage) => {
+  const { binaryVoteCounterInstallation: counter } = zcf.getTerms();
+  /** @type {MapStore<Instance<unknown>, GovernorCreatorFacet<any>>} */
+  const instanceToGovernor = provideDurableMapStore(
+    baggage,
+    'instanceToGovernor',
+  );
+
+  const makeParamInvitation = () => {
+    /**
+     * @param {ZCFSeat} seat
+     * @param {ParamChangesOfferArgs} args
+     */
+    const voteOnParamChanges = (seat, args) => {
+      mustMatch(args, ParamChangesOfferArgsShape);
+      seat.exit();
+
+      const {
+        params,
+        instance,
+        deadline,
+        path = { paramPath: { key: 'governedApi' } },
+      } = args;
+      const governor = instanceToGovernor.get(instance);
+      return E(governor).voteOnParamChanges(counter, deadline, {
+        ...path,
+        // @ts-expect-error XXX
+        changes: params,
+      });
+    };
+
+    return zcf.makeInvitation(voteOnParamChanges, 'vote on param changes');
+  };
+
+  const makeOfferFilterInvitation = (instance, strings, deadline) => {
+    const voteOnOfferFilterHandler = seat => {
+      seat.exit();
+
+      const governor = instanceToGovernor.get(instance);
+      return E(governor).voteOnOfferFilter(counter, deadline, strings);
+    };
+
+    return zcf.makeInvitation(voteOnOfferFilterHandler, 'vote on offer filter');
+  };
+
+  /**
+   * @param {Instance<unknown>} instance
+   * @param {string} methodName
+   * @param {string[]} methodArgs
+   * @param {TimestampValue} deadline
+   */
+  const makeApiInvocationInvitation = (
+    instance,
+    methodName,
+    methodArgs,
+    deadline,
+  ) => {
+    const handler = seat => {
+      seat.exit();
+
+      const governor = instanceToGovernor.get(instance);
+      return E(governor).voteOnApiInvocation(
+        methodName,
+        methodArgs,
+        counter,
+        deadline,
+      );
+    };
+    return zcf.makeInvitation(handler, 'vote on API invocation');
+  };
+
+  const MakerI = M.interface('Charter InvitationMakers', {
+    VoteOnParamChange: M.call().returns(M.promise()),
+    VoteOnPauseOffers: M.call(
+      InstanceHandleShape,
+      M.arrayOf(M.string()),
+      TimestampShape,
+    ).returns(M.promise()),
+    VoteOnApiCall: M.call(
+      InstanceHandleShape,
+      M.string(),
+      M.arrayOf(M.any()),
+      TimestampShape,
+    ).returns(M.promise()),
+  });
+
+  // durable so that when this contract is upgraded this ocap held
+  // by committee members (from their invitations) stay capable
+  const invitationMakers = prepareExo(
+    baggage,
+    'Charter Invitation Makers',
+    MakerI,
+    {
+      VoteOnParamChange: makeParamInvitation,
+      VoteOnPauseOffers: makeOfferFilterInvitation,
+      VoteOnApiCall: makeApiInvocationInvitation,
+    },
+  );
+
+  const charterMemberHandler = seat => {
+    seat.exit();
+    return harden({ invitationMakers });
+  };
+
+  const CharterCreatorI = M.interface('Charter creatorFacet', {
+    addInstance: M.call(InstanceHandleShape, M.any())
+      .optional(M.string())
+      .returns(),
+    makeCharterMemberInvitation: M.call().returns(M.promise()),
+  });
+
+  const creatorFacet = prepareExo(
+    baggage,
+    'Charter creatorFacet',
+    CharterCreatorI,
+    {
+      /**
+       * @param {Instance<unknown>} governedInstance
+       * @param {GovernorCreatorFacet<any>} governorFacet
+       * @param {string} [label] for diagnostic use only
+       */
+      addInstance: (governedInstance, governorFacet, label) => {
+        console.log('charter: adding instance', label);
+        instanceToGovernor.init(governedInstance, governorFacet);
+      },
+      makeCharterMemberInvitation: () =>
+        zcf.makeInvitation(charterMemberHandler, INVITATION_MAKERS_DESC),
+    },
+  );
+
+  return harden({ creatorFacet });
+};
+harden(start);