@agoric/governance 0.10.4-upgrade-14-dev-0169c7e.0 → 0.10.4-upgrade-16-dev-8879538.0

package/src/contractGovernance/paramManager.d.ts

@@ -6,10 +6,10 @@ export type ParamManagerBuilder = {
     addInvitation: (name: string, value: Invitation) => ParamManagerBuilder;
     addNat: (name: string, value: bigint) => ParamManagerBuilder;
     addRatio: (name: string, value: Ratio) => ParamManagerBuilder;
-    addRecord: (name: string, value: import('@endo/marshal').CopyRecord<unknown>) => ParamManagerBuilder;
+    addRecord: (name: string, value: import("@endo/marshal").CopyRecord<any>) => ParamManagerBuilder;
     addString: (name: string, value: string) => ParamManagerBuilder;
-    addTimestamp: (name: string, value: import('@agoric/time/src/types').Timestamp) => ParamManagerBuilder;
-    addRelativeTime: (name: string, value: import('@agoric/time/src/types').RelativeTime) => ParamManagerBuilder;
+    addTimestamp: (name: string, value: import("@agoric/time").Timestamp) => ParamManagerBuilder;
+    addRelativeTime: (name: string, value: import("@agoric/time").RelativeTime) => ParamManagerBuilder;
     addUnknown: (name: string, value: any) => ParamManagerBuilder;
     build: () => AnyParamManager;
 };
@@ -18,7 +18,7 @@ export type ParamManagerBuilder = {
  * @param {{[CONTRACT_ELECTORATE]: ParamValueTyped<'invitation'>}} governedParams
  */
 export function assertElectorateMatches(paramManager: ParamManagerBase, governedParams: {
-    [CONTRACT_ELECTORATE]: ParamValueTyped<'invitation'>;
+    Electorate: ParamValueTyped<"invitation">;
 }): void;
 /**
  * @typedef {object} ParamManagerBuilder
@@ -29,10 +29,10 @@ export function assertElectorateMatches(paramManager: ParamManagerBase, governed
  * @property {(name: string, value: Invitation) => ParamManagerBuilder} addInvitation
  * @property {(name: string, value: bigint) => ParamManagerBuilder} addNat
  * @property {(name: string, value: Ratio) => ParamManagerBuilder} addRatio
- * @property {(name: string, value: import('@endo/marshal').CopyRecord<unknown>) => ParamManagerBuilder} addRecord
+ * @property {(name: string, value: import('@endo/marshal').CopyRecord<any>) => ParamManagerBuilder} addRecord
  * @property {(name: string, value: string) => ParamManagerBuilder} addString
- * @property {(name: string, value: import('@agoric/time/src/types').Timestamp) => ParamManagerBuilder} addTimestamp
- * @property {(name: string, value: import('@agoric/time/src/types').RelativeTime) => ParamManagerBuilder} addRelativeTime
+ * @property {(name: string, value: import('@agoric/time').Timestamp) => ParamManagerBuilder} addTimestamp
+ * @property {(name: string, value: import('@agoric/time').RelativeTime) => ParamManagerBuilder} addRelativeTime
  * @property {(name: string, value: any) => ParamManagerBuilder} addUnknown
  * @property {() => AnyParamManager} build
  */
@@ -40,6 +40,10 @@ export function assertElectorateMatches(paramManager: ParamManagerBase, governed
  * @param {import('@agoric/notifier').StoredPublisherKit<GovernanceSubscriptionState>} publisherKit
  * @param {ERef<ZoeService>} [zoe]
  */
-export function makeParamManagerBuilder(publisherKit: import('@agoric/notifier').StoredPublisherKit<GovernanceSubscriptionState>, zoe?: ERef<ZoeService> | undefined): ParamManagerBuilder;
-import { CONTRACT_ELECTORATE } from "./governParam.js";
+export function makeParamManagerBuilder(publisherKit: import("@agoric/notifier").StoredPublisherKit<GovernanceSubscriptionState>, zoe?: globalThis.ERef<ZoeService> | undefined): ParamManagerBuilder;
+import type { AnyParamManager } from '../types.js';
+import type { ParamManagerBase } from '../types.js';
+import { CONTRACT_ELECTORATE } from './governParam.js';
+import type { ParamValueTyped } from '../types.js';
+import type { GovernanceSubscriptionState } from '../types.js';
 //# sourceMappingURL=paramManager.d.ts.map

package/src/contractGovernance/paramManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paramManager.d.ts","sourceRoot":"","sources":["paramManager.js"],"names":[],"mappings":";sBAuCqB,MAAM,SAAS,MAAM,KAAK,mBAAmB;qBAC7C,MAAM,SAAS,KAAK,KAAK,mBAAmB;4BAC5C,MAAM,SAAS,YAAY,KAAK,mBAAmB;wBACnD,MAAM,SAAS,QAAQ,KAAK,mBAAmB;0BAC/C,MAAM,SAAS,UAAU,KAAK,mBAAmB;mBACjD,MAAM,SAAS,MAAM,KAAK,mBAAmB;qBAC7C,MAAM,SAAS,KAAK,KAAK,mBAAmB;sBAC5C,MAAM,SAAS,OAAO,eAAe,EAAE,UAAU,CAAC,OAAO,CAAC,KAAK,mBAAmB;sBAClF,MAAM,SAAS,MAAM,KAAK,mBAAmB;yBAC7C,MAAM,SAAS,OAAO,wBAAwB,EAAE,SAAS,KAAK,mBAAmB;4BACjF,MAAM,SAAS,OAAO,wBAAwB,EAAE,YAAY,KAAK,mBAAmB;uBACpF,MAAM,SAAS,GAAG,KAAK,mBAAmB;WACjD,MAAM,eAAe;;AA9BnC;;;GAGG;AACH,sDAHW,gBAAgB,kBAChB;IAAC,qBAAqB,EAAE,gBAAgB,YAAY,CAAC,CAAA;CAAC,QAYhE;AAED;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH,sDAHW,OAAO,kBAAkB,EAAE,kBAAkB,CAAC,2BAA2B,CAAC,2DAmXpF"}
+{"version":3,"file":"paramManager.d.ts","sourceRoot":"","sources":["paramManager.js"],"names":[],"mappings":";eA2Cc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,mBAAmB;cACpD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,mBAAmB;qBACnD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,KAAK,mBAAmB;iBAC1D,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,KAAK,mBAAmB;mBACtD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,KAAK,mBAAmB;YACxD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,mBAAmB;cACpD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,mBAAmB;eACnD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,eAAe,EAAE,UAAU,CAAC,GAAG,CAAC,KAAK,mBAAmB;eACrF,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,mBAAmB;kBACpD,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,cAAc,EAAE,SAAS,KAAK,mBAAmB;qBAC9E,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,cAAc,EAAE,YAAY,KAAK,mBAAmB;gBACjF,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,mBAAmB;;;AA7B/D;;;GAGG;AACH;;SAUC;AAED;;;;;;;;;;;;;;;GAeG;AAEH;;;GAGG;AACH,sMAgXC;qCA1ZiI,aAAa;sCAAb,aAAa;oCAH3G,kBAAkB;qCAG4E,aAAa;iDAAb,aAAa"}

package/src/contractGovernance/paramManager.js

@@ -17,6 +17,10 @@ import {
 } from './assertions.js';
 import { CONTRACT_ELECTORATE } from './governParam.js';
 
+/**
+ * @import {AnyParamManager, GovernanceSubscriptionState, ParamManagerBase, ParamStateRecord, ParamValueTyped, UpdateParams} from '../types.js';
+ */
+
 const { Fail, quote: q } = assert;
 
 /**
@@ -44,10 +48,10 @@ const assertElectorateMatches = (paramManager, governedParams) => {
  * @property {(name: string, value: Invitation) => ParamManagerBuilder} addInvitation
  * @property {(name: string, value: bigint) => ParamManagerBuilder} addNat
  * @property {(name: string, value: Ratio) => ParamManagerBuilder} addRatio
- * @property {(name: string, value: import('@endo/marshal').CopyRecord<unknown>) => ParamManagerBuilder} addRecord
+ * @property {(name: string, value: import('@endo/marshal').CopyRecord<any>) => ParamManagerBuilder} addRecord
  * @property {(name: string, value: string) => ParamManagerBuilder} addString
- * @property {(name: string, value: import('@agoric/time/src/types').Timestamp) => ParamManagerBuilder} addTimestamp
- * @property {(name: string, value: import('@agoric/time/src/types').RelativeTime) => ParamManagerBuilder} addRelativeTime
+ * @property {(name: string, value: import('@agoric/time').Timestamp) => ParamManagerBuilder} addTimestamp
+ * @property {(name: string, value: import('@agoric/time').RelativeTime) => ParamManagerBuilder} addRelativeTime
  * @property {(name: string, value: any) => ParamManagerBuilder} addUnknown
  * @property {() => AnyParamManager} build
  */
@@ -89,7 +93,7 @@ const makeParamManagerBuilder = (publisherKit, zoe) => {
    * @param {Keyword} name
    * @param {unknown} value
    * @param {(val) => void} assertion
-   * @param {ParamType} type
+   * @param {import('../constants.js').ParamType} type
    */
   const buildCopyParam = (name, value, assertion, type) => {
     let current;
@@ -179,7 +183,7 @@ const makeParamManagerBuilder = (publisherKit, zoe) => {
     return builder;
   };
 
-  /** @type {(name: string, value: import('@endo/marshal').CopyRecord<unknown>, builder: ParamManagerBuilder) => ParamManagerBuilder} */
+  /** @type {(name: string, value: import('@endo/marshal').CopyRecord, builder: ParamManagerBuilder) => ParamManagerBuilder} */
   const addRecord = (name, value, builder) => {
     const assertRecord = v => {
       passStyleOf(v);
@@ -196,13 +200,13 @@ const makeParamManagerBuilder = (publisherKit, zoe) => {
     return builder;
   };
 
-  /** @type {(name: string, value: import('@agoric/time/src/types').Timestamp, builder: ParamManagerBuilder) => ParamManagerBuilder} */
+  /** @type {(name: string, value: import('@agoric/time').Timestamp, builder: ParamManagerBuilder) => ParamManagerBuilder} */
   const addTimestamp = (name, value, builder) => {
     buildCopyParam(name, value, assertTimestamp, ParamTypes.TIMESTAMP);
     return builder;
   };
 
-  /** @type {(name: string, value: import('@agoric/time/src/types').RelativeTime, builder: ParamManagerBuilder) => ParamManagerBuilder} */
+  /** @type {(name: string, value: import('@agoric/time').RelativeTime, builder: ParamManagerBuilder) => ParamManagerBuilder} */
   const addRelativeTime = (name, value, builder) => {
     buildCopyParam(name, value, assertRelativeTime, ParamTypes.RELATIVE_TIME);
     return builder;
@@ -219,10 +223,10 @@ const makeParamManagerBuilder = (publisherKit, zoe) => {
     if (!zoe) {
       throw Fail`zoe must be provided for governed Invitations ${zoe}`;
     }
-    const { instance, installation } = await E(zoe).getInvitationDetails(i);
-    // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -- the build config doesn't expect an error here
-    // @ts-ignore typedefs say they're guaranteed truthy but just to be safe
-    assert(instance && installation, 'must be an invitation');
+
+    // local check on isLive() gives better report than .getInvitationDetails()
+    const isLive = await E(E(zoe).getInvitationIssuer()).isLive(i);
+    isLive || Fail`Invitation passed to paramManager is not live ${i}`;
   };
 
   /**
@@ -366,10 +370,10 @@ const makeParamManagerBuilder = (publisherKit, zoe) => {
     const prepared = await Promise.all(asyncResults);
 
     // actually update
-    paramNames.forEach((name, i) => {
+    for (const [i, name] of paramNames.entries()) {
       const setFn = setters[`update${name}`];
       setFn(prepared[i]);
-    });
+    }
     publish();
   };
 
@@ -377,7 +381,7 @@ const makeParamManagerBuilder = (publisherKit, zoe) => {
   const build = () => {
     // XXX let params be finished async. A concession to upgradability
     // UNTIL https://github.com/Agoric/agoric-sdk/issues/4343
-    E.when(finishBuilding(), () => publish());
+    void E.when(finishBuilding(), () => publish());
 
     // CRUCIAL: Contracts that call buildParamManager should only export the
     // resulting paramManager to their creatorFacet, where it will be picked up by

package/src/contractGovernance/typedParamManager.d.ts

@@ -1,9 +1,11 @@
-export function makeParamManager<T extends Record<string, SyncSpecTuple | AsyncSpecTuple>>(publisherKit: import('@agoric/notifier').StoredPublisherKit<GovernanceSubscriptionState>, spec: T, zcf: ZCF): TypedParamManager<{ [K in keyof T]: T[K][0]; }>;
-export function makeParamManagerSync<T extends Record<string, SyncSpecTuple>>(publisherKit: import('@agoric/notifier').StoredPublisherKit<GovernanceSubscriptionState>, spec: T): TypedParamManager<{ [K in keyof T]: T[K][0]; }>;
-export function makeParamManagerFromTerms<I extends Record<string, Invitation<unknown, never>> & {
+export function makeParamManager<T extends Record<string, SyncSpecTuple | AsyncSpecTuple>>(publisherKit: import("@agoric/notifier").StoredPublisherKit<GovernanceSubscriptionState>, spec: T, zcf: ZCF): TypedParamManager<{ [K in keyof T]: T[K][0]; }>;
+export function makeParamManagerSync<T extends Record<string, SyncSpecTuple>>(publisherKit: import("@agoric/notifier").StoredPublisherKit<GovernanceSubscriptionState>, spec: T): TypedParamManager<{ [K in keyof T]: T[K][0]; }>;
+export function makeParamManagerFromTerms<I extends Record<string, Invitation<unknown, undefined>> & {
     Electorate: Invitation;
-}, M extends ParamTypesMap>(publisherKit: import('@agoric/notifier').StoredPublisherKit<GovernanceSubscriptionState>, zcf: ZCF<GovernanceTerms<M>>, invitations: I, paramTypesMap: M): TypedParamManager<M & { [K in keyof I]: "invitation"; }>;
-export type ParamTypesMap = Record<Keyword, ParamType>;
+}, M extends ParamTypesMap>(publisherKit: import("@agoric/notifier").StoredPublisherKit<GovernanceSubscriptionState>, zcf: ZCF<GovernanceTerms<M>>, invitations: I, paramTypesMap: M): TypedParamManager<M & { [K in keyof I]: "invitation"; }>;
+export type ParamTypesMap = {
+    [x: string]: ParamType;
+};
 export type ParamTypesMapFromRecord<M extends ParamStateRecord> = { [R in keyof M]: M[R]["type"]; };
 export type ParamRecordsFromTypes<M extends ParamTypesMap> = { [T in keyof M]: {
     type: M[T];
@@ -19,11 +21,18 @@ export type TypedParamManager<M extends ParamTypesMap> = ParamManagerBase & Gett
 /**
  * param spec tuple
  */
-export type ST<T extends import("../constants.js").ParamType> = [type: T, value: ParamValueForType<T>];
+export type ST<T extends ParamType> = [type: T, value: ParamValueForType<T>];
 export type InvitationParam = {
-    type: 'invitation';
-    value: Amount<'set'>;
+    type: "invitation";
+    value: Amount<"set">;
 };
-export type SyncSpecTuple = [type: "amount", value: Amount<any>] | ST<"brand"> | ST<"installation"> | ST<"instance"> | ST<"nat"> | ST<"ratio"> | ST<"string"> | ST<"timestamp"> | ST<"relativeTime"> | ST<"unknown">;
-export type AsyncSpecTuple = ['invitation', Invitation];
+export type SyncSpecTuple = ST<"amount"> | ST<"brand"> | ST<"installation"> | ST<"instance"> | ST<"nat"> | ST<"ratio"> | ST<"string"> | ST<"timestamp"> | ST<"relativeTime"> | ST<"unknown">;
+export type AsyncSpecTuple = ["invitation", Invitation];
+import type { GovernanceSubscriptionState } from '../types.js';
+import type { GovernanceTerms } from '../types.js';
+import type { ParamType } from '../constants.js';
+import type { ParamStateRecord } from '../types.js';
+import type { ParamValueForType } from '../types.js';
+import type { ParamManagerBase } from '../types.js';
+import type { UpdateParams } from '../types.js';
 //# sourceMappingURL=typedParamManager.d.ts.map

package/src/contractGovernance/typedParamManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typedParamManager.d.ts","sourceRoot":"","sources":["typedParamManager.js"],"names":[],"mappings":"AAoFO,yGALI,OAAO,kBAAkB,EAAE,kBAAkB,CAAC,2BAA2B,CAAC,gBAE1E,GAAG,mDAwBb;AAaM,4FAJI,OAAO,kBAAkB,EAAE,kBAAkB,CAAC,2BAA2B,CAAC,4DAepF;AAYM;gBARiD,UAAU;0CAEvD,OAAO,kBAAkB,EAAE,kBAAkB,CAAC,2BAA2B,CAAC,4HAiCpF;4BAhKY,OAAO,OAAO,EAAE,SAAS,CAAC;;;;;;;+HAqB2C,IAAI;yDAMzE,gBAAgB,GAAG,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG;IAAC,QAAQ,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAA;CAAC,GAAG;IAAC,YAAY,EAAE,YAAY,CAAA;CAAC;;;;gEAgBzG,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAC,CAAC;8BAItC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,OAAO,KAAK,CAAC,CAAA;CAAE;4BAO5C,wLASK;6BAEL,CAAC,YAAY,EAAE,UAAU,CAAC"}
+{"version":3,"file":"typedParamManager.d.ts","sourceRoot":"","sources":["typedParamManager.js"],"names":[],"mappings":"AAyFO,iCAFyC,CAAC,yJAAD,CAAC,AAFrC,OACD,GAAG,GACD,iBAAiB,CAAC,GAAE,CAAC,IAAI,MAAU,CAAC,AAAJ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAC,CAAC,CAuBxD;AAaM,qCAFyC,CAAC,wIAAD,CAAC,AADrC,GACC,iBAAiB,CAAC,GAAE,CAAC,IAAI,MAAU,CAAC,AAAJ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAC,CAAC,CAaxD;AAYM,0CAFyC,CAAC;gBANO,UAAU;GAMnC,CAAC,6JAAgB,CAAC,AAFrC,iBAEmB,CAAC,AADpB,GACC,iBAAiB,CAAC,CAAC,GAAG,GAAE,CAAC,IAAI,MAAM,CAAC,GAAG,YAAY,GAAC,CAAC,CA6BjE;;;;oCA5J8B,CAAC,6BAAnB,GAAG,CAAC,IAAI,MAAU,CAAC,AAAJ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAC;kCAI0B,CAAC,6BAAC,CAAC;UAAH,CAAC,AAA/B,CAAgC,CAAC,AAA/B,CAAC;;;oBAMwB,CAAC,6BAAC,CAAC;qBAOE,CAAC,6BAAC,CAAC,2EAAO,IAAI;8BAMF,CAAC;cAAf,MAAM,OAAO,CAAC,CAAC,CAAC;;;;;;;eAgBtC,CAAC;8BAIpC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;CAAE;4BAO5C,EAAE,CAAC,QAAQ,CAAC,GACpB,EAAE,CAAC,OAAO,CAAC,GACX,EAAE,CAAC,cAAc,CAAC,GAClB,EAAE,CAAC,UAAU,CAAC,GACd,EAAE,CAAC,KAAK,CAAC,GACT,EAAE,CAAC,OAAO,CAAC,GACX,EAAE,CAAC,QAAQ,CAAC,GACZ,EAAE,CAAC,WAAW,CAAC,GACf,EAAE,CAAC,cAAc,CAAC,GAClB,EAAE,CAAC,SAAS,CAAC;6BAEL,CAAC,YAAY,EAAE,UAAU,CAAC;iDAtE2M,aAAa;qCAAb,aAAa;+BACnO,iBAAiB;sCADqM,aAAa;uCAAb,aAAa;sCAAb,aAAa;kCAAb,aAAa"}

package/src/contractGovernance/typedParamManager.js

@@ -5,6 +5,11 @@ import { makeParamManagerBuilder } from './paramManager.js';
 
 const { Fail, quote: q } = assert;
 
+/**
+ * @import {VoteCounterCreatorFacet, VoteCounterPublicFacet, QuestionSpec, OutcomeRecord, AddQuestion, AddQuestionReturn, GovernanceSubscriptionState, GovernanceTerms, ParamManagerBase, ParamStateRecord, ParamValueForType, UpdateParams} from '../types.js';
+ * @import {ParamType} from '../constants.js';
+ */
+
 /**
  * @typedef {Record<Keyword, ParamType>} ParamTypesMap
  */

package/src/contractGovernor.d.ts

@@ -1,23 +1,29 @@
+/** @type {ContractMeta} */
+export const meta: ContractMeta;
 export function validateQuestionDetails(zoe: ERef<ZoeService>, electorate: Instance, details: ParamChangeIssueDetails): Promise<[void, void, void]>;
 export function validateQuestionFromCounter(zoe: ERef<ZoeService>, electorate: Instance, voteCounter: Instance): Promise<[void, void, void]>;
-export function prepare<SF extends GovernableStartFn>(zcf: ZCF<{
-    timer: import('@agoric/time/src/types').TimerService;
+export function start<SF extends GovernableStartFn>(zcf: ZCF<{
+    timer: import("@agoric/time").TimerService;
     governedContractInstallation: Installation<SF>;
     governed: {
         issuerKeywordRecord: IssuerKeywordRecord;
         terms: {
             governedParams: {
-                [CONTRACT_ELECTORATE]: import('./contractGovernance/typedParamManager.js').InvitationParam;
+                [CONTRACT_ELECTORATE]: import("./contractGovernance/typedParamManager.js").InvitationParam;
             };
         };
         label?: string;
     };
 }>, privateArgs: {
     governed: Record<string, unknown>;
-}, baggage: MapStore<string, unknown>): Promise<{
+}, baggage: import("@agoric/vat-data").Baggage): Promise<{
     creatorFacet: GovernorCreatorFacet<SF>;
     publicFacet: GovernorPublic;
 }>;
 export type ContractGovernorTerms = StandardTerms;
-import { CONTRACT_ELECTORATE } from "./contractGovernance/governParam.js";
+import type { ParamChangeIssueDetails } from './types.js';
+import type { GovernableStartFn } from './types.js';
+import { CONTRACT_ELECTORATE } from './contractGovernance/governParam.js';
+import type { GovernorCreatorFacet } from './types.js';
+import type { GovernorPublic } from './types.js';
 //# sourceMappingURL=contractGovernor.d.ts.map

package/src/contractGovernor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contractGovernor.d.ts","sourceRoot":"","sources":["contractGovernor.js"],"names":[],"mappings":"AAsBO,6CAJI,KAAK,UAAU,CAAC,cAChB,QAAQ,WACR,uBAAuB,+BAkBjC;AAYM,iDAJI,KAAK,UAAU,CAAC,cAChB,QAAQ,eACR,QAAQ,+BAWlB;AA0FM;WAjBK,OAAO,wBAAwB,EAAE,YAAY;;cAE1C;QACd,mBAAyB,EAAE,mBAAmB,CAAC;QAC/C,KAAW,EAAE;YAAC,cAAc,EAAE;gBAAC,qBAAqB,EAAE,OAAO,2CAA2C,EAAE,eAAe,CAAA;aAAC,CAAA;SAAC,CAAC;QAC5H,KAAW,CAAC,EAAE,MAAM,CAAC;KAChB;iBAEK;IACV,QAAY,EAAE,OAAO,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC;;iBAGc,cAAc;GA+D/B;oCAjJY,aAAa"}
+{"version":3,"file":"contractGovernor.d.ts","sourceRoot":"","sources":["contractGovernor.js"],"names":[],"mappings":"AAiBA,2BAA2B;AAC3B,mBADW,YAAY,CAGrB;AAYK,6CAJI,IAAI,CAAC,UAAU,CAAC,cAChB,QAAQ,iEAmBlB;AAYM,iDAJI,IAAI,CAAC,UAAU,CAAC,cAChB,QAAQ,eACR,QAAQ,+BAWlB;AA0FM,sBALiC,EAAE,iCAb/B,GAAG,CAAC;IACd,KAAS,EAAE,OAAO,cAAc,EAAE,YAAY,CAAC;IAC/C,4BAAgC,EAAE,YAAY,CAWP,EAAE,AAXQ,CAAC,CAAC;IACnD,QAAY,EAAE;QACd,mBAAyB,EAAE,mBAAmB,CAAC;QAC/C,KAAW,EAAE;YAAC,cAAc,EAAE;gBAAC,CAAC,mBAAmB,CAAC,EAAE,OAAO,2CAA2C,EAAE,eAAe,CAAA;aAAC,CAAA;SAAC,CAAC;QAC5H,KAAW,CAAC,EAAE,MAAM,CAAC;KAChB,CAAA;CACF,CAAC,eACM;IACV,QAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC,WAKO,OAAO,kBAAkB,EAAE,OAAO;;;GA6D5C;oCAjJY,aAAa;6CA/DyE,YAAY;uCAAZ,YAAY;oCAL3E,qCAAqC;0CAK0B,YAAY;oCAAZ,YAAY"}

package/src/contractGovernor.js

@@ -7,10 +7,20 @@ import { CONTRACT_ELECTORATE } from './contractGovernance/governParam.js';
 import { prepareContractGovernorKit } from './contractGovernorKit.js';
 import { ParamChangesQuestionDetailsShape } from './typeGuards.js';
 
+/**
+ * @import {GovernableStartFn, GovernorCreatorFacet, GovernorPublic, ParamChangeIssueDetails} from './types.js';
+ */
+
 const { Fail } = assert;
 
 const trace = makeTracer('CGov', false);
 
+/** @type {ContractMeta} */
+export const meta = {
+  upgradability: 'canUpgrade',
+};
+harden(meta);
+
 /**
  * Validate that the question details correspond to a parameter change question
  * that the electorate hosts, and that the voteCounter and other details are
@@ -62,7 +72,7 @@ harden(validateQuestionFromCounter);
 
 /**
  * @typedef {StandardTerms} ContractGovernorTerms
- * @property {import('@agoric/time/src/types').TimerService} timer
+ * @property {import('@agoric/time').TimerService} timer
  * @property {Installation} governedContractInstallation
  */
 
@@ -116,7 +126,7 @@ harden(validateQuestionFromCounter);
  * GovernorPublic,
  * GovernorCreatorFacet<PF,CF>,
  * {
- *   timer: import('@agoric/time/src/types').TimerService,
+ *   timer: import('@agoric/time').TimerService,
  *   governedContractInstallation: Installation<CF>,
  *   governed: {
  *     issuerKeywordRecord: IssuerKeywordRecord,
@@ -130,7 +140,7 @@ harden(validateQuestionFromCounter);
  *
  * @template {GovernableStartFn} SF Start function of governed contract
  * @param {ZCF<{
- *   timer: import('@agoric/time/src/types').TimerService,
+ *   timer: import('@agoric/time').TimerService,
  *   governedContractInstallation: Installation<SF>,
  *   governed: {
  *     issuerKeywordRecord: IssuerKeywordRecord,
@@ -147,8 +157,8 @@ harden(validateQuestionFromCounter);
  * }>}
  * @param {import('@agoric/vat-data').Baggage} baggage
  */
-export const prepare = async (zcf, privateArgs, baggage) => {
-  trace('prepare');
+export const start = async (zcf, privateArgs, baggage) => {
+  trace('start');
   const zoe = zcf.getZoeService();
   trace('getTerms', zcf.getTerms());
   const {
@@ -183,8 +193,8 @@ export const prepare = async (zcf, privateArgs, baggage) => {
       const startedInstanceKit = await E(zoe).startInstance(
         governedContractInstallation,
         governedIssuerKeywordRecord,
-        // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -- the build config doesn't expect an error here
-        // @ts-ignore XXX governance types https://github.com/Agoric/agoric-sdk/issues/7178
+
+        // @ts-expect-error XXX governance types https://github.com/Agoric/agoric-sdk/issues/7178
         augmentedTerms,
         privateArgs.governed,
         governedContractLabel,
@@ -202,9 +212,9 @@ export const prepare = async (zcf, privateArgs, baggage) => {
   // Specifically, to the vat of the governed contract for its API names. The exo
   // defers that until API governance is requested to be invoked or validated.
 
-  trace('prepare complete');
+  trace('start complete');
 
   // CRUCIAL: only contractGovernor should get the ability to update params
   return { creatorFacet: governorKit.creator, publicFacet: governorKit.public };
 };
-harden(prepare);
+harden(start);

package/src/contractGovernorKit.d.ts

@@ -1,15 +1,15 @@
-export function prepareContractGovernorKit(baggage: MapStore<string, unknown>, powers: {
-    timer: import('@agoric/time/src/types').TimerService;
+export function prepareContractGovernorKit(baggage: import("@agoric/vat-data").Baggage, powers: {
+    timer: import("@agoric/time").TimerService;
     zoe: ERef<ZoeService>;
-}): (startedInstanceKit: import("@agoric/zoe/src/zoeService/utils.js").StartedInstanceKit<GovernableStartFn>, limitedCreatorFacet: any) => {
+}): (startedInstanceKit: import("@agoric/zoe/src/zoeService/utils.js").StartedInstanceKit<GovernableStartFn>, limitedCreatorFacet: any) => import("@endo/exo").GuardedKit<{
     helper: {
         /** @type {() => Promise<Instance>} */
         getElectorateInstance(): Promise<Instance>;
         /** @type {() => Promise<PoserFacet>} */
         getUpdatedPoserFacet(): Promise<PoserFacet>;
-        provideApiGovernance(): Promise<ApiGovernor>;
-        provideFilterGovernance(): FilterGovernor;
-        provideParamGovernance(): ParamGovernor;
+        provideApiGovernance(): Promise<import("./types.js").ApiGovernor>;
+        provideFilterGovernance(): import("./types.js").FilterGovernor;
+        provideParamGovernance(): import("./types.js").ParamGovernor;
     };
     creator: {
         /**
@@ -18,52 +18,15 @@ export function prepareContractGovernorKit(baggage: MapStore<string, unknown>, p
          */
         replaceElectorate(poserInvitation: Invitation): Promise<void>;
         /** @type {VoteOnParamChanges} */
-        voteOnParamChanges(voteCounterInstallation: Installation<any>, deadline: import("@agoric/time/src/types").Timestamp, paramSpec: ParamChangesSpec<StandardParamPath>): ContractGovernanceVoteResult;
+        voteOnParamChanges(voteCounterInstallation: Installation<any>, deadline: import("@agoric/time").Timestamp, paramSpec: import("./types.js").ParamChangesSpec<import("./types.js").StandardParamPath>): Promise<import("./types.js").ContractGovernanceVoteResult>;
         /** @type {VoteOnApiInvocation} */
-        voteOnApiInvocation(apiMethodName: string, methodArgs: unknown[], voteCounterInstallation: Installation<any>, deadline: import("@agoric/time/src/types").Timestamp): Promise<ContractGovernanceVoteResult>;
+        voteOnApiInvocation(apiMethodName: string, methodArgs: import("@endo/pass-style").Passable[], voteCounterInstallation: Installation, deadline: import("@agoric/time").Timestamp): Promise<import("./types.js").ContractGovernanceVoteResult>;
         /** @type {VoteOnOfferFilter} */
-        voteOnOfferFilter(voteCounterInstallation: Installation<any>, deadline: import("@agoric/time/src/types").Timestamp, strings: string[]): ContractGovernanceVoteResult;
+        voteOnOfferFilter(voteCounterInstallation: Installation, deadline: import("@agoric/time").Timestamp, strings: string[]): Promise<import("./types.js").ContractGovernanceVoteResult>;
         getCreatorFacet(): any;
-        getAdminFacet(): import("@agoric/zoe/src/zoeService/utils.js").AdminFacet;
+        getAdminFacet(): import("@agoric/zoe/src/zoeService/utils.js").AdminFacet<GovernableStartFn>;
         getInstance(): import("@agoric/zoe/src/zoeService/utils.js").Instance<GovernableStartFn>;
-        getPublicFacet(): GovernedPublicFacetMethods;
-    };
-    public: {
-        getElectorate(): Promise<Instance>;
-        getGovernedContract(): import("@agoric/zoe/src/zoeService/utils.js").Instance<GovernableStartFn>;
-        /** @param {Instance} counter */
-        validateVoteCounter(counter: Instance): Promise<void>;
-        /** @param {Instance} regP */
-        validateElectorate(regP: Instance): Promise<void>;
-        /** @param {ClosingRule} closingRule */
-        validateTimer(closingRule: ClosingRule): void;
-    };
-} & import("@endo/eventual-send").RemotableBrand<{}, {
-    helper: {
-        /** @type {() => Promise<Instance>} */
-        getElectorateInstance(): Promise<Instance>;
-        /** @type {() => Promise<PoserFacet>} */
-        getUpdatedPoserFacet(): Promise<PoserFacet>;
-        provideApiGovernance(): Promise<ApiGovernor>;
-        provideFilterGovernance(): FilterGovernor;
-        provideParamGovernance(): ParamGovernor;
-    };
-    creator: {
-        /**
-         * @param {Invitation} poserInvitation
-         * @returns {Promise<void>}
-         */
-        replaceElectorate(poserInvitation: Invitation): Promise<void>;
-        /** @type {VoteOnParamChanges} */
-        voteOnParamChanges(voteCounterInstallation: Installation<any>, deadline: import("@agoric/time/src/types").Timestamp, paramSpec: ParamChangesSpec<StandardParamPath>): ContractGovernanceVoteResult;
-        /** @type {VoteOnApiInvocation} */
-        voteOnApiInvocation(apiMethodName: string, methodArgs: unknown[], voteCounterInstallation: Installation<any>, deadline: import("@agoric/time/src/types").Timestamp): Promise<ContractGovernanceVoteResult>;
-        /** @type {VoteOnOfferFilter} */
-        voteOnOfferFilter(voteCounterInstallation: Installation<any>, deadline: import("@agoric/time/src/types").Timestamp, strings: string[]): ContractGovernanceVoteResult;
-        getCreatorFacet(): any;
-        getAdminFacet(): import("@agoric/zoe/src/zoeService/utils.js").AdminFacet;
-        getInstance(): import("@agoric/zoe/src/zoeService/utils.js").Instance<GovernableStartFn>;
-        getPublicFacet(): GovernedPublicFacetMethods;
+        getPublicFacet(): import("./types.js").GovernedPublicFacetMethods;
     };
     public: {
         getElectorate(): Promise<Instance>;
@@ -77,4 +40,7 @@ export function prepareContractGovernorKit(baggage: MapStore<string, unknown>, p
     };
 }>;
 export type ContractGovernorKit = ReturnType<ReturnType<typeof prepareContractGovernorKit>>;
+import type { GovernableStartFn } from './types.js';
+import type { PoserFacet } from './types.js';
+import type { ClosingRule } from './types.js';
 //# sourceMappingURL=contractGovernorKit.d.ts.map

package/src/contractGovernorKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contractGovernorKit.d.ts","sourceRoot":"","sources":["contractGovernorKit.js"],"names":[],"mappings":"AAqBO,uFALI;IACV,KAAS,EAAE,OAAO,wBAAwB,EAAE,YAAY,CAAC;IACzD,GAAO,EAAE,KAAK,UAAU,CAAC,CAAC;CACvB;;QAiCI,sCAAsC;iCAArB,QAAQ,QAAQ,CAAC;QAQlC,wCAAwC;gCAAvB,QAAQ,UAAU,CAAC;;;;;;QAkEpC;;;WAGG;2CAFQ,UAAU,GACR,QAAQ,IAAI,CAAC;QAgB1B,iCAAiC;;QAOjC,kCAAkC;;QAelC,gCAAgC;;;;;;;;;;QA4BhC,gCAAgC;qCAApB,QAAQ;QAepB,6BAA6B;iCAAjB,QAAQ;QAWpB,uCAAuC;mCAA3B,WAAW;;;;QAxKvB,sCAAsC;iCAArB,QAAQ,QAAQ,CAAC;QAQlC,wCAAwC;gCAAvB,QAAQ,UAAU,CAAC;;;;;;QAkEpC;;;WAGG;2CAFQ,UAAU,GACR,QAAQ,IAAI,CAAC;QAgB1B,iCAAiC;;QAOjC,kCAAkC;;QAelC,gCAAgC;;;;;;;;;;QA4BhC,gCAAgC;qCAApB,QAAQ;QAepB,6BAA6B;iCAAjB,QAAQ;QAWpB,uCAAuC;mCAA3B,WAAW;;GAY9B;kCAEa,WAAW,WAAW,iCAAiC,CAAC,CAAC"}
+{"version":3,"file":"contractGovernorKit.d.ts","sourceRoot":"","sources":["contractGovernorKit.js"],"names":[],"mappings":"AAkEO,oDANI,OAAO,kBAAkB,EAAE,OAAO,UAClC;IACV,KAAS,EAAE,OAAO,cAAc,EAAE,YAAY,CAAC;IAC/C,GAAO,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;CACvB;;QAiCI,sCAAsC;iCAArB,OAAO,CAAC,QAAQ,CAAC;QAOlC,wCAAwC;;;;;;;QAoExC;;;WAGG;2CAFQ,UAAU,GACR,OAAO,CAAC,IAAI,CAAC;QAgB1B,iCAAiC;;QAOjC,kCAAkC;+HAoF8mU,YAAY,YAAqC,OAAO,cAAc,EAAE,SAAS;QArEjuU,gCAAgC;mDAqEmzU,YAAY,YAAqC,OAAO,cAAc,EAAE,SAAS,WAAsB,QAAQ;;;;;;;;;QAzCl8U,gCAAgC;qCAApB,QAAQ;QAepB,6BAA6B;iCAAjB,QAAQ;QAWpB,uCAAuC;;;GAY9C;kCAEa,UAAU,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC;uCArQ2K,YAAY;gCAAZ,YAAY;iCAAZ,YAAY"}

package/src/contractGovernorKit.js

@@ -1,21 +1,66 @@
 import { Fail } from '@agoric/assert';
-import { makeTracer } from '@agoric/internal';
-import { prepareExoClassKit } from '@agoric/vat-data';
+import { UnguardedHelperI, makeTracer } from '@agoric/internal';
+import { M, prepareExoClassKit } from '@agoric/vat-data';
 import { E } from '@endo/eventual-send';
+import {
+  InvitationShape,
+  InstanceHandleShape,
+  InstallationShape,
+} from '@agoric/zoe/src/typeGuards.js';
+import { TimestampShape } from '@agoric/time';
 import { setupApiGovernance } from './contractGovernance/governApi.js';
 import { setupFilterGovernance } from './contractGovernance/governFilter.js';
 import {
   CONTRACT_ELECTORATE,
   setupParamGovernance,
 } from './contractGovernance/governParam.js';
+import { ClosingRuleShape, ParamChangesSpecShape } from './typeGuards.js';
+
+/**
+ * @import {VoteCounterCreatorFacet, VoteCounterPublicFacet, QuestionSpec, OutcomeRecord, AddQuestion, AddQuestionReturn, ClosingRule, GovernableStartFn, LimitedCF, PoserFacet, VoteOnApiInvocation, VoteOnOfferFilter, VoteOnParamChanges} from './types.js';
+ */
 
 const trace = makeTracer('CGK', false);
 
+const ContractGovernorKitI = {
+  helper: UnguardedHelperI,
+  creator: M.interface('Contract Governor Kit creator', {
+    replaceElectorate: M.call(InvitationShape).returns(M.promise()),
+    voteOnParamChanges: M.call(
+      InstallationShape,
+      TimestampShape,
+      ParamChangesSpecShape,
+    ).returns(M.promise()),
+    voteOnApiInvocation: M.call(
+      M.string(),
+      M.arrayOf(M.any()),
+      InstallationShape,
+      TimestampShape,
+    ).returns(M.promise()),
+    voteOnOfferFilter: M.call(
+      InstallationShape,
+      TimestampShape,
+      M.arrayOf(M.string()),
+    ).returns(M.promise()),
+    getCreatorFacet: M.call().returns(M.remotable('ElectorateCreator')),
+    getAdminFacet: M.call().returns(M.remotable('ElectorateAdmin')),
+    getInstance: M.call().returns(InstanceHandleShape),
+    getPublicFacet: M.call().returns(M.remotable('ElectoratePublic')),
+  }),
+  public: M.interface('Contract Governor Kit public', {
+    getElectorate: M.call().returns(M.promise(/* Instance */)),
+    getGovernedContract: M.call().returns(InstanceHandleShape),
+    validateVoteCounter: M.call(InstanceHandleShape).returns(M.promise()),
+    validateElectorate: M.call(InstanceHandleShape).returns(M.promise()),
+    validateTimer: M.call(ClosingRuleShape).returns(),
+  }),
+};
+
 /**
  *
  * @param {import('@agoric/vat-data').Baggage} baggage
  * @param {{
- *   timer: import('@agoric/time/src/types').TimerService,
+ *   timer: import('@agoric/time').TimerService,
  *   zoe: ERef<ZoeService>,
  * }} powers
  */
@@ -36,7 +81,7 @@ export const prepareContractGovernorKit = (baggage, powers) => {
   const makeContractGovernorKit = prepareExoClassKit(
     baggage,
     'ContractGovernorKit',
-    undefined,
+    ContractGovernorKitI,
     /**
      * @param {import('@agoric/zoe/src/zoeService/utils.js').StartedInstanceKit<GovernableStartFn>} startedInstanceKit
      * @param {LimitedCF<unknown>} limitedCreatorFacet
@@ -53,9 +98,8 @@ export const prepareContractGovernorKit = (baggage, powers) => {
         /** @type {() => Promise<Instance>} */
         async getElectorateInstance() {
           const { publicFacet } = this.state;
-          const invitationAmount = await E(publicFacet).getInvitationAmount(
-            CONTRACT_ELECTORATE,
-          );
+          const invitationAmount =
+            await E(publicFacet).getInvitationAmount(CONTRACT_ELECTORATE);
           return invitationAmount.value[0].instance;
         },
         /** @type {() => Promise<PoserFacet>} */
@@ -76,6 +120,7 @@ export const prepareContractGovernorKit = (baggage, powers) => {
         async provideApiGovernance() {
           const { timer } = powers;
           const { creatorFacet } = this.state;
+          await null;
           if (!apiGovernance) {
             trace('awaiting governed API dependencies');
             const [governedApis, governedNames] = await Promise.all([
@@ -84,7 +129,8 @@ export const prepareContractGovernorKit = (baggage, powers) => {
             ]);
             trace('setupApiGovernance');
             apiGovernance = governedNames.length
-              ? setupApiGovernance(governedApis, governedNames, timer, () =>
+              ? // @ts-expect-error FIXME
+                setupApiGovernance(governedApis, governedNames, timer, () =>
                   this.facets.helper.getUpdatedPoserFacet(),
                 )
               : {
@@ -131,8 +177,8 @@ export const prepareContractGovernorKit = (baggage, powers) => {
         replaceElectorate(poserInvitation) {
           const { creatorFacet } = this.state;
           /** @type {Promise<import('./contractGovernance/typedParamManager.js').TypedParamManager<{'Electorate': 'invitation'}>>} */
-          // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error -- the build config doesn't expect an error here
-          // @ts-ignore cast
+
+          // @ts-expect-error cast
           const paramMgr = E(E(creatorFacet).getParamMgrRetriever()).get({
             key: 'governedParams',
           });