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

package/src/validators.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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;
+//# 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;;;;;;;GAOG;AACH,uCAFU,wBAAwB,CAmChC;AAEF;;;;GAIG;AACH,uCAFU,wBAAwB,CAahC"}

package/src/validators.js

@@ -33,8 +33,9 @@ const assertContractGovernance = async (
     'The alleged governed did not match the governed contract retrieved from the governor',
   );
 
-  const governorInstallationFromGoverned =
-    await E(zoe).getInstallationForInstance(realGovernorInstance);
+  const governorInstallationFromGoverned = await E(
+    zoe,
+  ).getInstallationForInstance(realGovernorInstance);
 
   assert(
     governorInstallationFromGoverned === contractGovernorInstallation,

package/src/voterKit.d.ts

@@ -0,0 +1,19 @@
+export function prepareVoterKit(baggage: MapStore<string, unknown>, { submitVote, zcf }: {
+    zcf: ZCF;
+    submitVote: (questionHandle: Handle<'Question'>, voterHandle: Handle<'Voter'>, chosenPositions: Position[], weight: bigint) => ERef<CompletedBallet>;
+}): (id?: any) => {
+    voter: {
+        castBallotFor(questionHandle: any, positions: any, weight?: bigint): Promise<CompletedBallet>;
+    };
+    invitationMakers: {
+        makeVoteInvitation(positions: any, questionHandle: any): Promise<Invitation<CompletedBallet, never>>;
+    };
+} & import("@endo/eventual-send").RemotableBrand<{}, {
+    voter: {
+        castBallotFor(questionHandle: any, positions: any, weight?: bigint): Promise<CompletedBallet>;
+    };
+    invitationMakers: {
+        makeVoteInvitation(positions: any, questionHandle: any): Promise<Invitation<CompletedBallet, never>>;
+    };
+}>;
+//# 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":"AA0BO;SAHI,GAAG;iCACc,OAAO,UAAU,CAAC,eAAe,OAAO,OAAO,CAAC,mBAAmB,QAAQ,EAAE,UAAU,MAAM,KAAK,KAAK,eAAe,CAAC;;;;;;;;;;;;;;;GAiClJ"}

package/tools/puppetContractGovernor.d.ts

@@ -0,0 +1,51 @@
+export function start<SF extends GovernableStartFn>(zcf: ZCF<{
+    timer: import('@agoric/time/src/types').TimerService;
+    governedContractInstallation: Installation<SF>;
+    governed: {
+        issuerKeywordRecord?: IssuerKeywordRecord;
+        terms: {
+            governedParams: {
+                [CONTRACT_ELECTORATE]: import('../src/contractGovernance/typedParamManager.js').InvitationParam;
+            };
+        };
+    };
+}>, privateArgs: {
+    governed: Record<string, unknown>;
+}): Promise<{
+    creatorFacet: {
+        changeParams: (paramSpec: ParamChangesSpec<any>) => Promise<void>;
+        invokeAPI: (apiMethodName: string, methodArgs: unknown[]) => Promise<{
+            apiMethodName: string;
+            methodArgs: unknown[];
+        }>;
+        setFilters: (strings: Array<string>) => Promise<void>;
+        getCreatorFacet: () => Promise<{}>;
+        getAdminFacet: () => import("@agoric/zoe/src/zoeService/utils.js").AdminFacet;
+        getInstance: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+        /** @returns {Awaited<ReturnType<SF>>['publicFacet']} */
+        getPublicFacet: () => Awaited<ReturnType<SF>>["publicFacet"];
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        changeParams: (paramSpec: ParamChangesSpec<any>) => Promise<void>;
+        invokeAPI: (apiMethodName: string, methodArgs: unknown[]) => Promise<{
+            apiMethodName: string;
+            methodArgs: unknown[];
+        }>;
+        setFilters: (strings: Array<string>) => Promise<void>;
+        getCreatorFacet: () => Promise<{}>;
+        getAdminFacet: () => import("@agoric/zoe/src/zoeService/utils.js").AdminFacet;
+        getInstance: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+        /** @returns {Awaited<ReturnType<SF>>['publicFacet']} */
+        getPublicFacet: () => Awaited<ReturnType<SF>>["publicFacet"];
+    }>;
+    publicFacet: {
+        getGovernedContract: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getGovernedContract: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+    }>;
+}>;
+/**
+ * <SF>
+ */
+export type PuppetContractGovernorKit<SF extends GovernableStartFn> = Awaited<ReturnType<typeof start<SF>>>;
+import { CONTRACT_ELECTORATE } from "../src/contractGovernance/governParam.js";
+//# sourceMappingURL=puppetContractGovernor.d.ts.map

package/tools/puppetContractGovernor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"puppetContractGovernor.d.ts","sourceRoot":"","sources":["puppetContractGovernor.js"],"names":[],"mappings":"AA8BO;WAXK,OAAO,wBAAwB,EAAE,YAAY;;cAE1C;QACd,mBAAyB,CAAC,EAAE,mBAAmB,CAAC;QAChD,KAAW,EAAE;YAAC,cAAc,EAAE;gBAAC,qBAAqB,EAAE,OAAO,gDAAgD,EAAE,eAAe,CAAA;aAAE,CAAA;SAAC,CAAC;KAC7H;iBAEK;IACV,QAAY,EAAE,OAAO,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC;;kCAkCU,iBAAiB,GAAG,CAAC;mCAUtB,MAAM,cACN,OAAO,EAAE;;;;8BALR,MAAM,MAAM,CAAC;;;;QA2BvB,wDAAwD;;;kCAjC9C,iBAAiB,GAAG,CAAC;mCAUtB,MAAM,cACN,OAAO,EAAE;;;;8BALR,MAAM,MAAM,CAAC;;;;QA2BvB,wDAAwD;;;;;;;;GAS3D;;;;sEAIY,QAAQ,WAAW,aAAa,EAAE,CAAC,CAAC,CAAC"}

package/tools/puppetGovernance.d.ts

@@ -0,0 +1,101 @@
+export function setUpGovernedContract<T extends GovernableStartFn>(zoe: ERef<ZoeService>, governedP: ERef<Installation<T>>, timer: import('@agoric/swingset-vat/src/vats/timer/vat-timer.js').TimerService, termsOfGoverned?: {
+    [k: string]: any;
+    governedParams?: Record<string, unknown> | undefined;
+    governedApis?: string[] | undefined;
+}, privateArgsOfGoverned?: {}, issuerKeywordRecord?: IssuerKeywordRecord | undefined): Promise<{
+    getFakeInvitation: () => Promise<{
+        fakeInvitationPayment: any;
+        fakeInvitationAmount: Amount<"set">;
+    }>;
+    governorFacets: import("@agoric/zoe/src/zoeService/utils.js").StartedInstanceKit<(<SF extends GovernableStartFn>(zcf: ZCF<{
+        timer: import("@agoric/time/src/types.js").TimerService;
+        governedContractInstallation: Installation<SF>;
+        governed: {
+            issuerKeywordRecord?: IssuerKeywordRecord | undefined;
+            terms: {
+                governedParams: {
+                    Electorate: import("../src/contractGovernance/typedParamManager.js").InvitationParam;
+                };
+            };
+        };
+    }>, privateArgs: {
+        governed: Record<string, unknown>;
+    }) => Promise<{
+        creatorFacet: {
+            changeParams: (paramSpec: ParamChangesSpec<any>) => Promise<void>;
+            invokeAPI: (apiMethodName: string, methodArgs: unknown[]) => Promise<{
+                apiMethodName: string;
+                methodArgs: unknown[];
+            }>;
+            setFilters: (strings: string[]) => Promise<void>;
+            getCreatorFacet: () => Promise<{}>;
+            getAdminFacet: () => import("@agoric/zoe/src/zoeService/utils.js").AdminFacet;
+            getInstance: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+            getPublicFacet: () => Awaited<ReturnType<SF>>["publicFacet"];
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            changeParams: (paramSpec: ParamChangesSpec<any>) => Promise<void>;
+            invokeAPI: (apiMethodName: string, methodArgs: unknown[]) => Promise<{
+                apiMethodName: string;
+                methodArgs: unknown[];
+            }>;
+            setFilters: (strings: string[]) => Promise<void>;
+            getCreatorFacet: () => Promise<{}>;
+            getAdminFacet: () => import("@agoric/zoe/src/zoeService/utils.js").AdminFacet;
+            getInstance: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+            getPublicFacet: () => Awaited<ReturnType<SF>>["publicFacet"];
+        }>;
+        publicFacet: {
+            getGovernedContract: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+        } & import("@endo/eventual-send").RemotableBrand<{}, {
+            getGovernedContract: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+        }>;
+    }>)>;
+    installs: {
+        governor: Installation<(<SF extends GovernableStartFn>(zcf: ZCF<{
+            timer: import("@agoric/time/src/types.js").TimerService;
+            governedContractInstallation: Installation<SF>;
+            governed: {
+                issuerKeywordRecord?: IssuerKeywordRecord | undefined;
+                terms: {
+                    governedParams: {
+                        Electorate: import("../src/contractGovernance/typedParamManager.js").InvitationParam;
+                    };
+                };
+            };
+        }>, privateArgs: {
+            governed: Record<string, unknown>;
+        }) => Promise<{
+            creatorFacet: {
+                changeParams: (paramSpec: ParamChangesSpec<any>) => Promise<void>;
+                invokeAPI: (apiMethodName: string, methodArgs: unknown[]) => Promise<{
+                    apiMethodName: string;
+                    methodArgs: unknown[];
+                }>;
+                setFilters: (strings: string[]) => Promise<void>;
+                getCreatorFacet: () => Promise<{}>;
+                getAdminFacet: () => import("@agoric/zoe/src/zoeService/utils.js").AdminFacet;
+                getInstance: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+                getPublicFacet: () => Awaited<ReturnType<SF>>["publicFacet"];
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                changeParams: (paramSpec: ParamChangesSpec<any>) => Promise<void>;
+                invokeAPI: (apiMethodName: string, methodArgs: unknown[]) => Promise<{
+                    apiMethodName: string;
+                    methodArgs: unknown[];
+                }>;
+                setFilters: (strings: string[]) => Promise<void>;
+                getCreatorFacet: () => Promise<{}>;
+                getAdminFacet: () => import("@agoric/zoe/src/zoeService/utils.js").AdminFacet;
+                getInstance: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+                getPublicFacet: () => Awaited<ReturnType<SF>>["publicFacet"];
+            }>;
+            publicFacet: {
+                getGovernedContract: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+            } & import("@endo/eventual-send").RemotableBrand<{}, {
+                getGovernedContract: () => import("@agoric/zoe/src/zoeService/utils.js").Instance<SF>;
+            }>;
+        }>)>;
+        autoRefund: Installation<any>;
+        governed: Installation<T>;
+    };
+}>;
+//# sourceMappingURL=puppetGovernance.d.ts.map

package/tools/puppetGovernance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"puppetGovernance.d.ts","sourceRoot":"","sources":["puppetGovernance.js"],"names":[],"mappings":"AAgCO,wEAPI,KAAK,UAAU,CAAC,2CAEhB,OAAO,kDAAkD,EAAE,YAAY;;;;2BAEvE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EZ"}

package/tools/puppetGovernance.js

@@ -1,3 +1,5 @@
+/* eslint-disable import/no-extraneous-dependencies */
+
 import bundleSource from '@endo/bundle-source';
 import { E } from '@endo/eventual-send';
 import { resolve as importMetaResolve } from 'import-meta-resolve';

package/tools/storageDoc.d.ts

@@ -0,0 +1,10 @@
+export function documentStorageSchema(t: import('ava').ExecutionContext<unknown>, storage: import('@agoric/internal/src/storage-test-utils.js').MockChainStorageRoot, opts: ({
+    note: string;
+} | {
+    node: string;
+    owner: string;
+}) & ({} | {
+    pattern: string;
+    replacement: string;
+})): Promise<void>;
+//# sourceMappingURL=storageDoc.d.ts.map

package/tools/storageDoc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storageDoc.d.ts","sourceRoot":"","sources":["storageDoc.js"],"names":[],"mappings":"AASO,yCANI,OAAO,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,WACvC,OAAO,4CAA4C,EAAE,oBAAoB;UAChE,MAAM;;UAAa,MAAM;WAAS,MAAM;;aAC5C,MAAM;iBAAe,MAAM;mBA8B1C"}