@agoric/governance 0.10.4-dev-5dc325b.0 → 0.10.4-getting-started-dev-d127d1d.0

package/src/committee.js

@@ -5,7 +5,6 @@ import { E } from '@endo/eventual-send';
 
 import { StorageNodeShape } from '@agoric/internal';
 import { prepareExo, provideDurableMapStore } from '@agoric/vat-data';
-import { EmptyProposalShape } from '@agoric/zoe/src/typeGuards.js';
 import {
   getOpenQuestions,
   getPoserInvitation,
@@ -24,15 +23,11 @@ const { ceilDivide } = natSafeMath;
  * }} CommitteeElectorateCreatorFacet
  */
 
-/** @type {ContractMeta} */
-export const meta = {
-  privateArgsShape: {
-    storageNode: StorageNodeShape,
-    marshaller: M.remotable('Marshaller'),
-  },
-  upgradability: 'canUpgrade',
+export const privateArgsShape = {
+  storageNode: StorageNodeShape,
+  marshaller: M.remotable('Marshaller'),
 };
-harden(meta);
+harden(privateArgsShape);
 
 /**
  * Each Committee (an Electorate) represents a particular set of voters. The
@@ -51,7 +46,7 @@ harden(meta);
  * @param {import('@agoric/vat-data').Baggage} baggage
  * @returns {{creatorFacet: CommitteeElectorateCreatorFacet, publicFacet: CommitteeElectoratePublic}}
  */
-export const start = (zcf, privateArgs, baggage) => {
+export const prepare = (zcf, privateArgs, baggage) => {
   /** @type {MapStore<Handle<'Question'>, import('./electorateTools.js').QuestionRecord>} */
   const allQuestions = provideDurableMapStore(baggage, 'Question');
 
@@ -80,15 +75,10 @@ export const start = (zcf, privateArgs, baggage) => {
     // This will produce unique descriptions because
     // makeCommitteeVoterInvitation() is only called within the following loop,
     // which is only called once per Electorate.
-    return zcf.makeInvitation(
-      seat => {
-        seat.exit();
-        return makeVoterKit(index);
-      },
-      `Voter${index}`,
-      undefined,
-      EmptyProposalShape,
-    );
+    return zcf.makeInvitation(seat => {
+      seat.exit();
+      return makeVoterKit(index);
+    }, `Voter${index}`);
   };
 
   const { committeeName, committeeSize } = zcf.getTerms();
@@ -180,4 +170,5 @@ export const start = (zcf, privateArgs, baggage) => {
 
   return { publicFacet, creatorFacet };
 };
-harden(start);
+
+harden(prepare);

package/src/constants.d.ts

@@ -0,0 +1,16 @@
+export namespace ParamTypes {
+    const AMOUNT: "amount";
+    const BRAND: "brand";
+    const INSTALLATION: "installation";
+    const INSTANCE: "instance";
+    const INVITATION: "invitation";
+    const NAT: "nat";
+    const RATIO: "ratio";
+    const STRING: "string";
+    const PASSABLE_RECORD: "record";
+    const TIMESTAMP: "timestamp";
+    const RELATIVE_TIME: "relativeTime";
+    const UNKNOWN: "unknown";
+}
+export type ParamType = (typeof ParamTypes)[keyof typeof ParamTypes];
+//# sourceMappingURL=constants.d.ts.map

package/src/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["constants.js"],"names":[],"mappings":";;;;;;;;;;;;;;wBAuBc,CAAA,iBAAiB,EAAC,MAAM,iBAAiB,CAAC"}

package/src/contractGovernance/assertions.d.ts

@@ -0,0 +1,7 @@
+export function makeLooksLikeBrand(name: any): (brand: Brand) => void;
+export function makeAssertInstallation(name: any): (installation: any) => void;
+export function makeAssertInstance(name: any): (instance: any) => void;
+export function makeAssertBrandedRatio(name: any, modelRatio: any): (ratio: any) => boolean;
+export function assertRelativeTime(value: any): void;
+export function assertTimestamp(value: any): void;
+//# sourceMappingURL=assertions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["assertions.js"],"names":[],"mappings":"AAOA,uDACc,KAAK,UAIlB;AAGD,+EAMC;AAGD,uEAMC;AAGD,4FASC;AAGD,qDAEC;AAGD,kDAEC"}

package/src/contractGovernance/governApi.d.ts

@@ -0,0 +1,30 @@
+/**
+ * manage contracts that allow governance to invoke functions.
+ *
+ * @param {ERef<{ [methodName: string]: (...args: any) => unknown }>} governedApis
+ * @param {Array<string | symbol>} governedNames names of the governed API methods
+ * @param {ERef<import('@agoric/time/src/types').TimerService>} timer
+ * @param {() => Promise<PoserFacet>} getUpdatedPoserFacet
+ * @returns {ApiGovernor}
+ */
+export function setupApiGovernance(governedApis: ERef<{
+    [methodName: string]: (...args: any) => unknown;
+}>, governedNames: Array<string | symbol>, timer: ERef<import('@agoric/time/src/types').TimerService>, getUpdatedPoserFacet: () => Promise<PoserFacet>): ApiGovernor;
+/**
+ * Make a pair of positions for a question about whether to invoke an API. If
+ * the vote passes, the method will be called on the governedApis facet with the
+ * arguments that were provided.
+ *
+ * @param {string} apiMethodName
+ * @param {unknown[]} methodArgs
+ */
+export function makeApiInvocationPositions(apiMethodName: string, methodArgs: unknown[]): {
+    positive: {
+        apiMethodName: string;
+        methodArgs: unknown[];
+    };
+    negative: {
+        dontInvoke: string;
+    };
+};
+//# sourceMappingURL=governApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"governApi.d.ts","sourceRoot":"","sources":["governApi.js"],"names":[],"mappings":"AA2BA;;;;;;;;GAQG;AACH;oCANkD,GAAG,KAAK,OAAO;mBACtD,MAAM,MAAM,GAAG,MAAM,CAAC,SACtB,KAAK,OAAO,wBAAwB,EAAE,YAAY,CAAC,wBACnD,MAAM,QAAQ,UAAU,CAAC,GACvB,WAAW,CAwFvB;AA7GD;;;;;;;GAOG;AACH,0DAHW,MAAM,cACN,OAAO,EAAE;;;;;;;;EAMnB"}

package/src/contractGovernance/governFilter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Setup to allow governance to block some invitations.
+ *
+ * @param {ERef<import('@agoric/time/src/types').TimerService>} timer
+ * @param {() => Promise<PoserFacet>} getUpdatedPoserFacet
+ * @param {GovernedCreatorFacet<{}>} governedCF
+ * @returns {FilterGovernor}
+ */
+export function setupFilterGovernance(timer: ERef<import('@agoric/time/src/types').TimerService>, getUpdatedPoserFacet: () => Promise<PoserFacet>, governedCF: GovernedCreatorFacet<{}>): FilterGovernor;
+/**
+ * Make a pair of positions for a question about whether to update the offer
+ * filter. If the vote passes, the list of blocked invitation strings will be
+ * updated.
+ *
+ * @param {string[]} strings
+ */
+export function makeOfferFilterPositions(strings: string[]): {
+    positive: {
+        strings: string[];
+    };
+    negative: {
+        dontUpdate: string[];
+    };
+};
+//# sourceMappingURL=governFilter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"governFilter.d.ts","sourceRoot":"","sources":["governFilter.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,6CALW,KAAK,OAAO,wBAAwB,EAAE,YAAY,CAAC,wBACnD,MAAM,QAAQ,UAAU,CAAC,cACzB,qBAAqB,EAAE,CAAC,GACtB,cAAc,CAqE1B;AAxFD;;;;;;GAMG;AACH,kDAFW,MAAM,EAAE;;;;;;;EAMlB"}

package/src/contractGovernance/governParam.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @param {ERef<ParamManagerRetriever>} paramManagerRetriever
+ * @param {Instance} contractInstance
+ * @param {import('@agoric/time/src/types').TimerService} timer
+ * @param {() => Promise<PoserFacet>} getUpdatedPoserFacet
+ * @returns {ParamGovernor}
+ */
+export function setupParamGovernance(paramManagerRetriever: ERef<ParamManagerRetriever>, contractInstance: Instance, timer: import('@agoric/time/src/types').TimerService, getUpdatedPoserFacet: () => Promise<PoserFacet>): ParamGovernor;
+/**
+ * Return a record containing the positive and negative positions for a
+ * question on changing the param to the proposedValue.
+ *
+ * @param {Record<string, ParamValue>} changes
+ * @returns {ParamChangePositions}
+ */
+export function makeParamChangePositions(changes: Record<string, ParamValue>): ParamChangePositions;
+/**
+ * assert that the parameter described by paramSpec is proposed to be changed in
+ * the question described by questionSpec.
+ *
+ * @param {{ parameterName: string, paramPath: unknown}} paramSpec
+ * @param {QuestionSpec<ParamChangeIssue<unknown>>} questionSpec
+ */
+export function assertBallotConcernsParam(paramSpec: {
+    parameterName: string;
+    paramPath: unknown;
+}, questionSpec: QuestionSpec<ParamChangeIssue<unknown>>): void;
+/**
+ * The electorate that governs changes to the contract's parameters. It must be
+ * declared in the governed contract.
+ */
+export const CONTRACT_ELECTORATE: "Electorate";
+//# sourceMappingURL=governParam.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"governParam.d.ts","sourceRoot":"","sources":["governParam.js"],"names":[],"mappings":"AAqDA;;;;;;GAMG;AACH,4DANW,KAAK,qBAAqB,CAAC,oBAC3B,QAAQ,SACR,OAAO,wBAAwB,EAAE,YAAY,wBAC7C,MAAM,QAAQ,UAAU,CAAC,GACvB,aAAa,CAwFzB;AA9HD;;;;;;GAMG;AACH,kDAHW,OAAO,MAAM,EAAE,UAAU,CAAC,GACxB,oBAAoB,CAQhC;AAED;;;;;;GAMG;AACH;mBAH4B,MAAM;eAAa,OAAO;iBAC3C,aAAa,iBAAiB,OAAO,CAAC,CAAC,QAWjD;AArCD;;;GAGG;AACH,+CAAyC"}

package/src/contractGovernance/paramManager.d.ts

@@ -0,0 +1,45 @@
+export type ParamManagerBuilder = {
+    addAmount: (name: string, value: Amount) => ParamManagerBuilder;
+    addBrand: (name: string, value: Brand) => ParamManagerBuilder;
+    addInstallation: (name: string, value: Installation) => ParamManagerBuilder;
+    addInstance: (name: string, value: Instance) => 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;
+    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;
+    addUnknown: (name: string, value: any) => ParamManagerBuilder;
+    build: () => AnyParamManager;
+};
+/**
+ * @param {ParamManagerBase} paramManager
+ * @param {{[CONTRACT_ELECTORATE]: ParamValueTyped<'invitation'>}} governedParams
+ */
+export function assertElectorateMatches(paramManager: ParamManagerBase, governedParams: {
+    [CONTRACT_ELECTORATE]: ParamValueTyped<'invitation'>;
+}): void;
+/**
+ * @typedef {object} ParamManagerBuilder
+ * @property {(name: string, value: Amount) => ParamManagerBuilder} addAmount
+ * @property {(name: string, value: Brand) => ParamManagerBuilder} addBrand
+ * @property {(name: string, value: Installation) => ParamManagerBuilder} addInstallation
+ * @property {(name: string, value: Instance) => ParamManagerBuilder} addInstance
+ * @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: 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: any) => ParamManagerBuilder} addUnknown
+ * @property {() => AnyParamManager} build
+ */
+/**
+ * @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";
+//# sourceMappingURL=paramManager.d.ts.map

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

@@ -0,0 +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"}

package/src/contractGovernance/paramManager.js

@@ -1,4 +1,3 @@
-/* eslint @typescript-eslint/no-floating-promises: "warn" */
 import { Far, passStyleOf } from '@endo/marshal';
 import { AmountMath } from '@agoric/ertp';
 import { assertKeywordName } from '@agoric/zoe/src/cleanProposal.js';
@@ -367,10 +366,10 @@ const makeParamManagerBuilder = (publisherKit, zoe) => {
     const prepared = await Promise.all(asyncResults);
 
     // actually update
-    for (const [i, name] of paramNames.entries()) {
+    paramNames.forEach((name, i) => {
       const setFn = setters[`update${name}`];
       setFn(prepared[i]);
-    }
+    });
     publish();
   };
 

package/src/contractGovernance/typedParamManager.d.ts

@@ -0,0 +1,29 @@
+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>> & {
+    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>;
+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];
+    value: ParamValueForType<M[T]>;
+}; };
+export type Getters<M extends ParamTypesMap> = { [K in keyof M as `get${string & K}`]: () => ParamValueForType<M[K]>; };
+export type Updaters<T extends ParamTypesMap> = { [K in keyof T as `update${string & K}`]: (value: ParamValueForType<T[K]>) => void; };
+export type TypedParamManager<M extends ParamTypesMap> = ParamManagerBase & Getters<M> & Updaters<M> & {
+    readonly: () => Getters<M>;
+} & {
+    updateParams: UpdateParams;
+};
+/**
+ * param spec tuple
+ */
+export type ST<T extends import("../constants.js").ParamType> = [type: T, value: ParamValueForType<T>];
+export type InvitationParam = {
+    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];
+//# sourceMappingURL=typedParamManager.d.ts.map

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

@@ -0,0 +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"}

package/src/contractGovernor.d.ts

@@ -0,0 +1,23 @@
+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;
+    governedContractInstallation: Installation<SF>;
+    governed: {
+        issuerKeywordRecord: IssuerKeywordRecord;
+        terms: {
+            governedParams: {
+                [CONTRACT_ELECTORATE]: import('./contractGovernance/typedParamManager.js').InvitationParam;
+            };
+        };
+        label?: string;
+    };
+}>, privateArgs: {
+    governed: Record<string, unknown>;
+}, baggage: MapStore<string, unknown>): Promise<{
+    creatorFacet: GovernorCreatorFacet<SF>;
+    publicFacet: GovernorPublic;
+}>;
+export type ContractGovernorTerms = StandardTerms;
+import { CONTRACT_ELECTORATE } from "./contractGovernance/governParam.js";
+//# sourceMappingURL=contractGovernor.d.ts.map

package/src/contractGovernor.d.ts.map

@@ -0,0 +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"}

package/src/contractGovernor.js

@@ -11,12 +11,6 @@ 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
@@ -153,8 +147,8 @@ harden(validateQuestionFromCounter);
  * }>}
  * @param {import('@agoric/vat-data').Baggage} baggage
  */
-export const start = async (zcf, privateArgs, baggage) => {
-  trace('start');
+export const prepare = async (zcf, privateArgs, baggage) => {
+  trace('prepare');
   const zoe = zcf.getZoeService();
   trace('getTerms', zcf.getTerms());
   const {
@@ -208,9 +202,9 @@ export const start = 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('start complete');
+  trace('prepare complete');
 
   // CRUCIAL: only contractGovernor should get the ability to update params
   return { creatorFacet: governorKit.creator, publicFacet: governorKit.public };
 };
-harden(start);
+harden(prepare);

package/src/contractGovernorKit.d.ts

@@ -0,0 +1,80 @@
+export function prepareContractGovernorKit(baggage: MapStore<string, unknown>, powers: {
+    timer: import('@agoric/time/src/types').TimerService;
+    zoe: ERef<ZoeService>;
+}): (startedInstanceKit: import("@agoric/zoe/src/zoeService/utils.js").StartedInstanceKit<GovernableStartFn>, limitedCreatorFacet: any) => {
+    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;
+    };
+    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;
+    };
+    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;
+    };
+}>;
+export type ContractGovernorKit = ReturnType<ReturnType<typeof prepareContractGovernorKit>>;
+//# sourceMappingURL=contractGovernorKit.d.ts.map

package/src/contractGovernorKit.d.ts.map

@@ -0,0 +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"}

package/src/contractGovernorKit.js

@@ -53,8 +53,9 @@ 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>} */
@@ -75,7 +76,6 @@ 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([

package/src/contractHelper.d.ts

@@ -0,0 +1,136 @@
+export const GOVERNANCE_STORAGE_KEY: "governance";
+export function validateElectorate(zcf: ZCF<GovernanceTerms<{}> & {}>, paramManager: import('./contractGovernance/typedParamManager').TypedParamManager<unknown>): Promise<void>;
+/**
+ * Helper for the 90% of contracts that will have only a single set of
+ * parameters. Using this for managed parameters, a contract only has to
+ *
+ * - Define the parameter template, which includes name, type and value
+ * - Add any methods needed in the public and creator facets.
+ *
+ * It's also crucial that the governed contract not interact with the product of
+ * makeGovernorFacet(). The wrapped creatorFacet has the power to change
+ * parameter values, and the governance guarantees only hold if they're not used
+ * directly by the governed contract.
+ *
+ * @template {import('./contractGovernance/typedParamManager').ParamTypesMap} M
+ *   Map of types of custom governed terms
+ * @param {ZCF<GovernanceTerms<M>>} zcf
+ * @param {Invitation} initialPoserInvitation
+ * @param {M} paramTypesMap
+ * @param {ERef<StorageNode>} [storageNode]
+ * @param {ERef<Marshaller>} [marshaller]
+ */
+export function handleParamGovernance<M extends import("./contractGovernance/typedParamManager.js").ParamTypesMap>(zcf: ZCF<GovernanceTerms<M>>, initialPoserInvitation: Invitation, paramTypesMap: M, storageNode?: ERef<StorageNode> | undefined, marshaller?: ERef<Marshaller<unknown>> | undefined): {
+    publicMixin: {
+        getAmount: (name: string) => Amount<AssetKind>;
+        getBrand: (name: string) => Brand<AssetKind>;
+        getInstance: (name: string) => Instance;
+        getInstallation: (name: string) => Installation<any>;
+        getInvitationAmount: (name: string) => Amount<"set">;
+        getNat: (name: string) => bigint;
+        getRatio: (name: string) => Ratio;
+        getString: (name: string) => string;
+        getTimestamp: (name: string) => import("@agoric/time/src/types.js").TimestampRecord;
+        getRelativeTime: (name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord;
+        getUnknown: (name: string) => any;
+        getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams: () => ERef<ParamStateRecord>;
+    };
+    augmentPublicFacet: <PF extends {}>(originalPublicFacet: PF) => GovernedPublicFacet<PF>;
+    augmentVirtualPublicFacet: <OPF extends {}>(originalPublicFacet: OPF) => OPF & {
+        getAmount: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getBrand: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getInstance: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getInstallation: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getInvitationAmount: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getNat: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getRatio: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getString: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getTimestamp: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getRelativeTime: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getUnknown: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams: () => ERef<ParamStateRecord>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, OPF & {
+        getAmount: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getBrand: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getInstance: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getInstallation: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getInvitationAmount: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getNat: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getRatio: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getString: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getTimestamp: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getRelativeTime: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getUnknown: import("@agoric/vat-data/src/types.js").PlusContext<never, ((name: string) => Amount<AssetKind>) | ((name: string) => Brand<AssetKind>) | ((name: string) => Instance) | ((name: string) => Installation<any>) | ((name: string) => Amount<"set">) | ((name: string) => bigint) | ((name: string) => Ratio) | ((name: string) => string) | ((name: string) => import("@agoric/time/src/types.js").TimestampRecord) | ((name: string) => import("@agoric/time/src/types.js").RelativeTimeRecord) | ((name: string) => any)>;
+        getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+        getGovernedParams: () => ERef<ParamStateRecord>;
+    }>;
+    makeGovernorFacet: <CF extends {}>(originalCreatorFacet: CF, governedApis?: {} | undefined) => GovernedCreatorFacet<CF>;
+    makeFarGovernorFacet: <CF_1 extends {}>(limitedCreatorFacet: CF_1, governedApis?: Record<string, (...any: any[]) => unknown> | undefined) => GovernedCreatorFacet<CF_1>;
+    makeVirtualGovernorFacet: (limitedCreatorFacet: {
+        [methodName: string]: (context?: unknown, ...rest: unknown[]) => unknown;
+    }) => {
+        governorFacet: import("@agoric/vat-data/src/types.js").FunctionsPlusContext<unknown, GovernedCreatorFacet<{
+            [methodName: string]: (context?: unknown, ...rest: unknown[]) => unknown;
+        }>>;
+        limitedCreatorFacet: {
+            [methodName: string]: (context?: unknown, ...rest: unknown[]) => unknown;
+        };
+    };
+    makeDurableGovernorFacet: <CF_2>(baggage: MapStore<string, unknown>, limitedCreatorFacet: CF_2, governedApis?: Record<string, (...any: any[]) => unknown> | undefined) => {
+        governorFacet: {
+            getParamMgrRetriever: () => {
+                get: () => import("./contractGovernance/typedParamManager.js").TypedParamManager<M & {
+                    Electorate: "invitation";
+                }>;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                get: () => import("./contractGovernance/typedParamManager.js").TypedParamManager<M & {
+                    Electorate: "invitation";
+                }>;
+            }>;
+            getInvitation: (name: any) => Promise<Invitation<unknown, never>>;
+            getLimitedCreatorFacet: () => CF_2;
+            /** @type {() => GovernedApis} */
+            getGovernedApis: () => GovernedApis;
+            getGovernedApiNames: () => string[];
+            setOfferFilter: (strings: any) => Promise<void>;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            getParamMgrRetriever: () => {
+                get: () => import("./contractGovernance/typedParamManager.js").TypedParamManager<M & {
+                    Electorate: "invitation";
+                }>;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                get: () => import("./contractGovernance/typedParamManager.js").TypedParamManager<M & {
+                    Electorate: "invitation";
+                }>;
+            }>;
+            getInvitation: (name: any) => Promise<Invitation<unknown, never>>;
+            getLimitedCreatorFacet: () => CF_2;
+            /** @type {() => GovernedApis} */
+            getGovernedApis: () => GovernedApis;
+            getGovernedApiNames: () => string[];
+            setOfferFilter: (strings: any) => Promise<void>;
+        }>;
+        limitedCreatorFacet: CF_2;
+    };
+    params: import("./contractGovernance/typedParamManager.js").Getters<M & {
+        Electorate: "invitation";
+    }>;
+};
+export namespace publicMixinAPI {
+    const getSubscription: any;
+    const getGovernedParams: any;
+    const getAmount: any;
+    const getBrand: any;
+    const getInstance: any;
+    const getInstallation: any;
+    const getInvitationAmount: any;
+    const getNat: any;
+    const getRatio: any;
+    const getString: any;
+    const getTimestamp: any;
+    const getRelativeTime: any;
+    const getUnknown: any;
+}
+//# sourceMappingURL=contractHelper.d.ts.map