@agoric/governance 0.10.4-dev-fa844b5.0 → 0.10.4-dev-21fe8d9.0

package/src/types.d.ts

@@ -0,0 +1,562 @@
+/**
+ * * UNRANKED: "unranked voting" means that the voter specifies some number of
+ *  positions, and is endorsing them equally.
+ * * ORDER: The voter assigns ordinal numbers to some of the positions. The
+ *  positions will be treated as an ordered list with no gaps.
+ *
+ * When voters are limited to choosing a single candidate, either UNRANKED or
+ * ORDER would work. UNRANKED has a simpler representation so we use that.
+ */
+export type ChoiceMethod = 'unranked' | 'order' | 'plurality';
+/**
+ * param_change is very specific. Survey means multiple answers are possible,
+ * Election means some candidates are going to "win". It's not clear these are
+ * orthogonal. The important distinction is that param_change has a structured
+ * issue, while the others have a issue presented as a string.
+ */
+export type ElectionType = 'param_change' | 'election' | 'survey' | 'api_invocation' | 'offer_filter';
+export type QuorumRule = 'majority' | 'all' | 'no_quorum';
+export type SimpleIssue = {
+    text: string;
+};
+export type ParamValue = Amount | Brand | Installation | Instance | bigint | Ratio | string | import('@agoric/time').TimestampRecord | import('@agoric/time').RelativeTimeRecord | unknown;
+export type ParamValueForType<T extends ParamType> = T extends 'amount' ? Amount<any> : T extends 'brand' ? Brand : T extends 'installation' ? Installation : T extends 'instance' ? Instance : T extends 'invitation' ? Amount<'set'> : T extends 'nat' ? bigint : T extends 'ratio' ? Ratio : T extends 'string' ? string : T extends 'timestamp' ? import('@agoric/time').Timestamp : T extends 'relativeTime' ? import('@agoric/time').RelativeTime : T extends 'unknown' ? unknown : never;
+/**
+ * <T>
+ */
+export type ParamValueTyped<T extends ParamType = ParamType> = {
+    type: T;
+    value: ParamValueForType<T>;
+};
+/**
+ * <T>
+ */
+export type GovernanceTerms<T extends import("./contractGovernance/typedParamManager.js").ParamTypesMap> = {
+    electionManager: import('@agoric/zoe/src/zoeService/utils.js').Instance<typeof import("./contractGovernor.js")['start']>;
+    governedParams: import('./contractGovernance/typedParamManager.js').ParamRecordsFromTypes<T & {
+        Electorate: 'invitation';
+    }>;
+};
+export type Issue = SimpleIssue | ParamChangeIssue<unknown> | ApiInvocationIssue | OfferFilterIssue;
+/**
+ * - QuestionSpec plus the Electorate Instance and
+ *   a numerical threshold for the quorum. (The voteCounter doesn't know the
+ *   size of the electorate, so the Electorate has to say what limit to enforce.)
+ */
+export type QuestionTerms = {
+    questionSpec: QuestionSpec;
+    quorumThreshold: number;
+    electorate: Instance;
+};
+export type TextPosition = {
+    text: string;
+};
+export type Position = TextPosition | ChangeParamsPosition | NoChangeParamsPosition | InvokeApiPosition | DontInvokeApiPosition | OfferFilterPosition | NoChangeOfferFilterPosition | InvokeApiPosition;
+export type OutcomeRecord = {
+    question: Handle<'Question'>;
+} & ({
+    outcome: 'win';
+    position: Position;
+} | {
+    outcome: 'fail';
+    reason: 'No quorum';
+});
+export type MultiOutcomeRecord = {
+    question: Handle<'Question'>;
+} & ({
+    outcome: 'win';
+    positions: Position[];
+} | {
+    outcome: 'fail';
+    reason: 'No quorum';
+});
+/**
+ * Specification when requesting creation of a Question
+ */
+export type QuestionSpec<I extends Issue = Issue> = {
+    method: ChoiceMethod;
+    issue: I;
+    positions: Position[];
+    electionType: ElectionType;
+    maxChoices: number;
+    maxWinners: number;
+    closingRule: ClosingRule;
+    quorumRule: QuorumRule;
+    tieOutcome: Position;
+};
+export type QuestionDetailsExtraProperties = {
+    /**
+     * - instance of the VoteCounter
+     */
+    counterInstance: Instance;
+    questionHandle: Handle<'Question'>;
+};
+/**
+ * complete question details: questionSpec plus counter and questionHandle
+ */
+export type QuestionDetails = QuestionSpec & QuestionDetailsExtraProperties;
+export type GovernancePair = {
+    governor: Instance;
+    governed: Instance;
+};
+export type Question = {
+    getVoteCounter: () => Instance;
+    getDetails: () => QuestionDetails;
+};
+export type CompleteUnrankedQuestion = {
+    questionHandle: Handle<'Question'>;
+    /**
+     * - a list of equal-weight preferred positions
+     */
+    chosen: Position[];
+};
+export type CompleteWeightedBallot = {
+    questionHandle: Handle<'Question'>;
+    /**
+     * - list of positions with
+     * weights. VoteCounter may limit weights to a range or require uniqueness.
+     */
+    weighted: [Position, bigint][];
+};
+export type CompleteOrderedBallot = {
+    questionHandle: Handle<'Question'>;
+    /**
+     * - ordered list of position from most preferred
+     * to least preferred
+     */
+    ordered: Position[];
+};
+export type PositionCount = {
+    position: Position;
+    total: bigint;
+};
+export type VoteStatistics = {
+    spoiled: bigint;
+    votes: number;
+    results: PositionCount[];
+};
+export type QuorumCounter = {
+    check: (stats: VoteStatistics) => boolean;
+};
+export type BuildQuestion = (questionSpec: QuestionSpec, instance: Instance) => Question;
+/**
+ * - a facet that the Electorate should
+ *   hold tightly. submitVote() is the core capability that allows the holder to
+ *   specify the identity and choice of a voter. The voteCounter is making that
+ *   available to the Electorate, which should wrap and attenuate it so each
+ *   voter gets only the ability to cast their own vote at a weight specified by
+ *   the electorate.
+ */
+export type VoteCounterCreatorFacet = {
+    submitVote: SubmitVote;
+};
+export type VoteCounterPublicFacet = {
+    isOpen: () => boolean;
+    getQuestion: () => Question;
+    getOutcome: () => Promise<Position>;
+    getDetails: () => QuestionDetails;
+    getStats: () => Promise<VoteStatistics>;
+};
+export type MultiVoteCounterPublicFacet = {
+    isOpen: () => boolean;
+    getQuestion: () => Question;
+    getOutcome: () => Promise<Position[]>;
+    getDetails: () => QuestionDetails;
+    getStats: () => Promise<VoteStatistics>;
+};
+/**
+ * TEST ONLY: Should not be allowed to escape from contracts
+ */
+export type VoteCounterCloseFacet = {
+    closeVoting: () => void;
+};
+export type VoteCounterFacets = {
+    publicFacet: VoteCounterPublicFacet;
+    creatorFacet: VoteCounterCreatorFacet;
+    closeFacet: VoteCounterCloseFacet;
+};
+export type MultiVoteCounterFacets = {
+    publicFacet: MultiVoteCounterPublicFacet;
+    creatorFacet: VoteCounterCreatorFacet;
+    closeFacet: VoteCounterCloseFacet;
+};
+export type BuildVoteCounter = (questionSpec: QuestionSpec, threshold: bigint, instance: Instance, publisher: ERef<Publisher<OutcomeRecord>>) => VoteCounterFacets;
+export type BuildMultiVoteCounter = (questionSpec: QuestionSpec, threshold: bigint, instance: Instance, publisher: ERef<Publisher<MultiOutcomeRecord>>) => MultiVoteCounterFacets;
+export type CompletedBallet = {
+    chosen: Position;
+    shares: bigint;
+};
+export type SubmitVote = (voterHandle: Handle<'Voter'>, chosenPositions: Position[], weight?: bigint | undefined) => CompletedBallet;
+export type GetOpenQuestions = () => Promise<Handle<'Question'>[]>;
+export type GetQuestion = (h: Handle<'Question'>) => Promise<Question>;
+export type ElectoratePublic = {
+    getQuestionSubscriber: () => Subscriber<QuestionDetails>;
+    /**
+     * ,
+     */
+    getOpenQuestions: GetOpenQuestions;
+    getInstance: () => Instance;
+    getQuestion: GetQuestion;
+};
+export type ClaimsElectoratePublic = ElectoratePublic & {
+    makeVoterInvitation: () => ERef<Invitation<unknown, undefined>>;
+};
+export type CommitteeElectoratePublic = ElectoratePublic & {
+    getName: () => string;
+};
+export type PoserFacet = {
+    addQuestion: AddQuestion;
+};
+export type ElectorateCreatorFacet = {
+    /**
+     * can be used directly when the creator doesn't need any
+     * reassurance. When someone needs to connect addQuestion to the Electorate
+     * instance, getPoserInvitation() lets them get addQuestion with assurance.
+     */
+    addQuestion: AddQuestion;
+    getPoserInvitation: () => Promise<Invitation>;
+    getQuestionSubscriber: () => Subscriber<QuestionDetails>;
+    getPublicFacet: () => ElectoratePublic;
+};
+export type GetVoterInvitations = {
+    getVoterInvitations: () => Invitation[];
+};
+/**
+ * - a facet that the Electorate should hold
+ *   tightly. It allows specification of the vote's weight, so the Electorate
+ *   should distribute an attenuated wrapper that doesn't make that available!
+ */
+export type VoterFacet = {
+    submitVote: SubmitVote;
+};
+export type ClosingRule = {
+    timer: ERef<import("@agoric/time").TimerService>;
+    deadline: import('@agoric/time').Timestamp;
+};
+export type CloseVoting = (closingRule: ClosingRule, closeVoting: () => void) => any;
+export type AddQuestionReturn = {
+    publicFacet: VoteCounterPublicFacet;
+    creatorFacet: VoteCounterCreatorFacet;
+    instance: import('@agoric/zoe/src/zoeService/utils.js').Instance<typeof import('./binaryVoteCounter.js').start>;
+    deadline: import('@agoric/time').Timestamp;
+    questionHandle: Handle<'Question'>;
+};
+export type AddQuestion = (voteCounter: ERef<Installation<any>>, questionSpec: QuestionSpec) => Promise<AddQuestionReturn>;
+export type CreateQuestion = (name: string, proposedValue: ParamValue, voteCounterInstallation: Installation, contractInstance: Instance, closingRule: ClosingRule) => Promise<QuestionDetails>;
+export type ParamChangeIssue<P = StandardParamPath> = {
+    spec: ParamChangesSpec<P>;
+    contract: import('@agoric/zoe/src/zoeService/utils.js').Instance<(zcf: ZCF<GovernanceTerms<{}>>) => {}>;
+};
+export type ApiInvocationIssue = {
+    apiMethodName: string;
+    methodArgs: unknown[];
+};
+export type OfferFilterIssue = {
+    strings: string[];
+};
+export type ParamChangePositions = {
+    positive: ChangeParamsPosition;
+    negative: NoChangeParamsPosition;
+};
+/**
+ * details for a question that can change a contract parameter
+ */
+export type ParamChangeIssueDetails = {
+    method: ChoiceMethod;
+    issue: ParamChangeIssue<unknown>;
+    positions: ParamChangePositions;
+    electionType: ElectionType;
+    maxChoices: number;
+    closingRule: ClosingRule;
+    quorumRule: QuorumRule;
+    tieOutcome: NoChangeParamsPosition;
+    /**
+     * - instance of the VoteCounter
+     */
+    counterInstance: Instance;
+    questionHandle: Handle<'Question'>;
+};
+/**
+ * a Record containing
+ *   keyword pairs with descriptions of parameters under governance.
+ */
+export type ParamStateRecord = Record<Keyword, ParamValueTyped>;
+export type GovernanceSubscriptionState = {
+    current: ParamStateRecord;
+};
+/**
+ * The base paramManager with typed getters
+ */
+export type ParamManagerBase = {
+    getParams: () => ERef<ParamStateRecord>;
+    getAmount: (name: string) => Amount;
+    getBrand: (name: string) => Brand;
+    getInstance: (name: string) => Instance;
+    getInstallation: (name: string) => Installation;
+    getInvitationAmount: (name: string) => Amount<'set'>;
+    getNat: (name: string) => bigint;
+    getRatio: (name: string) => Ratio;
+    getString: (name: string) => string;
+    getTimestamp: (name: string) => import('@agoric/time').TimestampRecord;
+    getRelativeTime: (name: string) => import('@agoric/time').RelativeTimeRecord;
+    getUnknown: (name: string) => any;
+    /**
+     * - for
+     * most types, the visible value is the same as proposedValue. For Invitations
+     * the visible value is the amount of the invitation.
+     */
+    getVisibleValue: (name: string, proposedValue: ParamValue) => ParamValue;
+    getInternalParamValue: (name: string) => Promise<Invitation>;
+    getSubscription: () => StoredSubscription<GovernanceSubscriptionState>;
+};
+export type UpdateParams = (paramChanges: Record<string, ParamValue>) => Promise<void>;
+/**
+ * These are typed `any` because the builder pattern of paramManager makes it very
+ * complicated for the type system to know the set of param-specific functions
+ * returned by `.build()`. Instead we let paramManager create the desired methods
+ * and use typedParamManager to create a version that includes the static types.
+ */
+export type ParamManagerGettersAndUpdaters = Record<string, any>;
+/**
+ * These are typed `any` because the builder pattern of paramManager makes it very
+ * complicated for the type system to know the set of param-specific functions
+ * returned by `.build()`. Instead we let paramManager create the desired methods
+ * and use typedParamManager to create a version that includes the static types.
+ */
+export type AnyParamManager = ParamManagerBase & ParamManagerGettersAndUpdaters & {
+    updateParams: UpdateParams;
+};
+export type ParameterNameList = Record<string, string[]>;
+export type AssertParamManagerType = (type: ParamType, value: ParamValue, name: string) => any;
+/**
+ * - ParamManager is a facility that governed
+ *   contracts can use to manage their visible state in a way that allows the
+ *   ContractGovernor to update values using governance. When paramManager is
+ *   instantiated inside the contract, the contract has synchronous access to
+ *   the values, and clients of the contract can verify that a ContractGovernor
+ *   can change the values in a legible way.
+ */
+export type BuildParamManager = (paramDescriptions: Iterable<ParamValueTyped>) => AnyParamManager;
+export type ChangeParamsPosition = {
+    /**
+     * one or more changes to parameters
+     */
+    changes: Record<string, ParamValue>;
+};
+export type OfferFilterPosition = {
+    strings: string[];
+};
+export type NoChangeOfferFilterPosition = {
+    dontUpdate: string[];
+};
+export type InvokeApiPosition = {
+    apiMethodName: string;
+    methodArgs: unknown[];
+};
+export type DontInvokeApiPosition = {
+    dontInvoke: string;
+};
+export type NoChangeParamsPosition = {
+    /**
+     * Parameters in the proposal that this position
+     * is opposed to
+     */
+    noChange: string[];
+};
+export type Governor = {
+    createQuestion: CreateQuestion;
+};
+export type GovernedApis = {
+    [methodName: string]: (...args: any) => unknown;
+};
+export type GovernorPublic = {
+    getElectorate: () => Promise<Instance>;
+    getGovernedContract: () => Instance;
+    validateVoteCounter: (voteCounter: Instance) => Promise<void>;
+    validateElectorate: (regP: ERef<Instance>) => Promise<void>;
+    validateTimer: (closingRule: ClosingRule) => void;
+};
+/**
+ * identifier for a paramManager within a contract
+ */
+export type ParamKey = {
+    key: unknown;
+};
+/**
+ * <P>
+ */
+export type ParamChangesSpec<P> = {
+    paramPath: P;
+    /**
+     * one or more changes to parameters
+     */
+    changes: Record<string, ParamValue>;
+};
+export type ContractGovernanceVoteResult = {
+    /**
+     * - instance of the VoteCounter
+     */
+    instance: Instance;
+    details: ERef<QuestionDetails>;
+    /**
+     * - A promise for the result
+     * of updating the parameter value. Primarily useful for its behavior on
+     * rejection.
+     */
+    outcomeOfUpdate: Promise<ParamValue>;
+};
+export type GovernorCreatorFacet<SF extends GovernableStartFn> = {
+    voteOnParamChanges: VoteOnParamChanges;
+    voteOnApiInvocation: VoteOnApiInvocation;
+    voteOnOfferFilter: VoteOnOfferFilter;
+    /**
+     * facet of the governed contract,
+     * with creator-like powers but without the tightly held ability to change
+     * param values.
+     */
+    getCreatorFacet: () => LimitedCF<SF>;
+    replaceElectorate: (poserInvitation: Invitation) => Promise<void>;
+    getAdminFacet: () => AdminFacet;
+    /**
+     * - public facet of the governed contract
+     */
+    getPublicFacet: () => GovernedPublicFacet<Awaited<ReturnType<SF>>['publicFacet']>;
+    /**
+     * - instance of the governed
+     * contract
+     */
+    getInstance: () => Instance;
+};
+export type GovernedPublicFacetMethods = {
+    getSubscription: (key?: any) => StoredSubscription<GovernanceSubscriptionState>;
+    /**
+     * - get descriptions of
+     * all the governed parameters
+     */
+    getGovernedParams: (key?: any) => ERef<ParamStateRecord>;
+    getInvitationAmount: (name: string) => Amount;
+};
+export type GovernedPublicFacet<PF extends {}> = PF & GovernedPublicFacetMethods;
+export type LimitedCF<SF extends GovernableStartFn> = ReturnType<Awaited<ReturnType<SF>>['creatorFacet']['getLimitedCreatorFacet']>;
+/**
+ * What a governed contract must return as its creatorFacet in order to be governed
+ */
+export type GovernedCreatorFacet<CF extends {}> = {
+    /**
+     * - allows accessing
+     * and updating governed parameters. Should only be directly accessible to the
+     * contractGovernor
+     */
+    getParamMgrRetriever: () => ParamManagerRetriever;
+    /**
+     * - the creator
+     * facet of the governed contract. Doesn't provide access to any governance
+     * functionality
+     */
+    getLimitedCreatorFacet: () => ERef<CF>;
+    getInvitation: (name: string) => Promise<Invitation>;
+    getGovernedApis: () => ERef<GovernedApis>;
+    getGovernedApiNames: () => (string | symbol)[];
+    setOfferFilter: (strings: string[]) => void;
+};
+export type StandardParamPath = {
+    key: string;
+};
+export type ParamManagerRetriever = {
+    get: (paramKey?: ParamKey) => AnyParamManager;
+};
+export type VoteOnParamChanges<P = StandardParamPath> = (voteCounterInstallation: Installation, deadline: import('@agoric/time').Timestamp, paramSpec: ParamChangesSpec<P>) => Promise<ContractGovernanceVoteResult>;
+export type VoteOnApiInvocation = (apiMethodName: string, methodArgs: unknown[], voteCounterInstallation: Installation, deadline: import('@agoric/time').Timestamp) => Promise<ContractGovernanceVoteResult>;
+export type VoteOnOfferFilter = (voteCounterInstallation: Installation, deadline: import('@agoric/time').Timestamp, strings: string[]) => Promise<ContractGovernanceVoteResult>;
+export type ParamGovernor = {
+    voteOnParamChanges: VoteOnParamChanges;
+    createdQuestion: CreatedQuestion;
+};
+export type ApiGovernor = {
+    voteOnApiInvocation: VoteOnApiInvocation;
+    createdQuestion: CreatedQuestion;
+};
+export type FilterGovernor = {
+    voteOnFilter: VoteOnOfferFilter;
+    createdQuestion: CreatedQuestion;
+};
+/**
+ * Was this question created by this ContractGovernor?
+ */
+export type CreatedQuestion = (questionInstance: Instance) => boolean;
+export type PositionIncluded = (positions: Position[], position: Position) => boolean;
+export type GovernedContractTerms = {
+    timer: import('@agoric/time').TimerService;
+    issuerKeywordRecord: IssuerKeywordRecord;
+    privateArgs: object;
+};
+export type AssertContractGovernance = (zoe: ERef<ZoeService>, allegedGoverned: import('@agoric/zoe/src/zoeService/utils.js').Instance<(zcf: ZCF<GovernanceTerms<{}>>) => {}>, allegedGovernor: Instance, contractGovernorInstallation: Installation<(<SF extends GovernableStartFn>(zcf: ZCF<{
+    timer: import("@agoric/time").TimerService;
+    governedContractInstallation: Installation<SF>;
+    governed: {
+        issuerKeywordRecord: IssuerKeywordRecord;
+        terms: {
+            governedParams: {
+                Electorate: import("./contractGovernance/typedParamManager.js").InvitationParam;
+            };
+        };
+        label?: string | undefined;
+    };
+}>, privateArgs: {
+    governed: Record<string, unknown>;
+}, baggage: import("@agoric/vat-data").Baggage) => Promise<{
+    creatorFacet: GovernorCreatorFacet<SF>;
+    publicFacet: GovernorPublic; /**
+     * @callback BuildQuestion
+     * @param {QuestionSpec} questionSpec
+     * @param {Instance} instance - voteCounter instance
+     * @returns {Question}
+     */
+}>)>) => Promise<GovernancePair>;
+/**
+ * - assert that the contract uses the
+ *   electorate
+ */
+export type AssertContractElectorate = (zoe: ERef<ZoeService>, allegedGovernor: Instance, allegedElectorate: Instance) => any;
+export type GovernableStartFn = import("@agoric/zoe/src/zoeService/utils.js").ContractStartFunction & ((zcf?: any, pa?: any, baggage?: any) => ERef<{
+    creatorFacet: GovernedCreatorFacet<{}>;
+    publicFacet: GovernedPublicFacet<{}>;
+}>);
+export type GovernorSF = typeof import("./contractGovernor.js")['start'];
+/**
+ * Same result as StartedInstanceKit but:
+ * - typed for contractGovernor installation being started by Zoe. (It in turn starts the governed contract.)
+ * - parameterized by Installation instead of StartFunction
+ */
+export type GovernorStartedInstallationKit<I extends ERef<Installation<GovernableStartFn>>> = {
+    instance: import('@agoric/zoe/src/zoeService/utils.js').Instance<GovernorSF>;
+    adminFacet: AdminFacet;
+    creatorFacet: GovernorCreatorFacet<InstallationStart<Awaited<I>>>;
+    publicFacet: GovernorPublic;
+};
+/**
+ * Akin to StartedInstanceKit but designed for the results of starting governed contracts. Used in bootstrap space.
+ */
+export type GovernanceFacetKit<SF extends GovernableStartFn> = {
+    /**
+     * of the governed contract
+     */
+    adminFacet: AdminFacet;
+    /**
+     * creator-like facet within the governed contract (without the powers the governor needs)
+     */
+    creatorFacet: LimitedCF<SF>;
+    /**
+     * of the governing contract
+     */
+    governorCreatorFacet: GovernorCreatorFacet<SF>;
+    /**
+     * of the governing contract
+     */
+    governorAdminFacet: AdminFacet;
+    publicFacet: Awaited<ReturnType<SF>>['publicFacet'];
+    instance: Instance;
+    governor: Instance;
+};
+import type { ParamType } from './constants.js';
+//# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"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"}

package/src/types.js

@@ -1,4 +1,5 @@
-export {}; 
+export {};
+
 /**
  * @typedef { 'unranked' | 'order' | 'plurality' } ChoiceMethod
  * * UNRANKED: "unranked voting" means that the voter specifies some number of

package/src/validators.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @import {VoteCounterCreatorFacet, VoteCounterPublicFacet, QuestionSpec, OutcomeRecord, AddQuestion, AddQuestionReturn, AssertContractGovernance, AssertContractElectorate} from './types.js';
+ */
+/**
+ * Assert that the governed contract was started by the governor. Throws if
+ * either direction can't be established. If the call succeeds, then the
+ * governor got exclusive access to the governed contract's creatorFacet, and
+ * can be trusted to manage its parameters.
+ *
+ * @type {AssertContractGovernance}
+ */
+export const assertContractGovernance: AssertContractGovernance;
+/**
+ * Assert that the governor refers to the indicated electorate.
+ *
+ * @type {AssertContractElectorate}
+ */
+export const assertContractElectorate: AssertContractElectorate;
+import type { AssertContractGovernance } from './types.js';
+import type { AssertContractElectorate } from './types.js';
+//# sourceMappingURL=validators.d.ts.map

package/src/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["validators.js"],"names":[],"mappings":"AAIA;;GAEG;AAEH;;;;;;;GAOG;AACH,gEAgCE;AAEF;;;;GAIG;AACH,gEAWE;8CA7DiL,YAAY;8CAAZ,YAAY"}

package/src/validators.js

@@ -2,6 +2,10 @@ import { E } from '@endo/eventual-send';
 
 const { Fail, quote: q } = assert;
 
+/**
+ * @import {VoteCounterCreatorFacet, VoteCounterPublicFacet, QuestionSpec, OutcomeRecord, AddQuestion, AddQuestionReturn, AssertContractGovernance, AssertContractElectorate} from './types.js';
+ */
+
 /**
  * Assert that the governed contract was started by the governor. Throws if
  * either direction can't be established. If the call succeeds, then the

package/src/voterKit.d.ts

@@ -0,0 +1,14 @@
+export function prepareVoterKit(baggage: import('@agoric/vat-data').Baggage, { submitVote, zcf }: {
+    zcf: ZCF;
+    submitVote: (questionHandle: Handle<'Question'>, voterHandle: Handle<'Voter'>, chosenPositions: Position[], weight: bigint) => ERef<CompletedBallet>;
+}): (id?: any) => import("@endo/exo").GuardedKit<{
+    voter: {
+        castBallotFor(questionHandle: any, positions: any, weight?: bigint): Promise<CompletedBallet>;
+    };
+    invitationMakers: {
+        makeVoteInvitation(positions: any, questionHandle: any): Promise<Invitation<CompletedBallet, undefined>>;
+    };
+}>;
+import type { Position } from './types.js';
+import type { CompletedBallet } from './types.js';
+//# sourceMappingURL=voterKit.d.ts.map

package/src/voterKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voterKit.d.ts","sourceRoot":"","sources":["voterKit.js"],"names":[],"mappings":"AA8BO,yCALI,OAAO,kBAAkB,EAAE,OAAO;SAElC,GAAG;iCACc,OAAO,UAAU,CAAC,eAAe,OAAO,OAAO,CAAC,uCAAuC,MAAM;;;;;;;;GAiCxH;8BAvDyJ,YAAY;qCAAZ,YAAY"}

package/src/voterKit.js

@@ -3,6 +3,10 @@ import { defineDurableHandle } from '@agoric/zoe/src/makeHandle.js';
 import { E } from '@endo/eventual-send';
 import { PositionShape, QuestionHandleShape } from './typeGuards.js';
 
+/**
+ * @import {VoteCounterCreatorFacet, VoteCounterPublicFacet, QuestionSpec, OutcomeRecord, AddQuestion, AddQuestionReturn, CompletedBallet, Position} from './types.js';
+ */
+
 const VoterI = M.interface('voter', {
   castBallotFor: M.call(QuestionHandleShape, M.arrayOf(PositionShape)).returns(
     M.promise(),