@agoric/inter-protocol 0.16.2-upgrade-14-dev-0169c7e.0 → 0.16.2-upgrade-16-dev-8879538.0

package/src/proposals/utils.js

@@ -2,6 +2,8 @@ import { WalletName } from '@agoric/internal';
 import { getCopyMapEntries, makeCopyMap } from '@agoric/store';
 import { E } from '@endo/far';
 
+/** @import {CopyMap} from '@endo/patterns') */
+
 const { Fail } = assert;
 
 /**
@@ -10,7 +12,6 @@ const { Fail } = assert;
  */
 export const reserveThenGetNamePaths = async (nameAdmin, paths) => {
   /**
-   *
    * @param {ERef<import('@agoric/vats').NameAdmin>} nextAdmin
    * @param {string[]} path
    */
@@ -54,7 +55,7 @@ export const reserveThenGetNames = async (nameAdmin, names) =>
  * @param {string} debugName
  * @param {ERef<import('@agoric/vats').NameAdmin>} namesByAddressAdmin
  * @param {string} addr
- * @param {Array<ERef<Payment>>} payments
+ * @param {ERef<Payment>[]} payments
  */
 export const reserveThenDeposit = async (
   debugName,
@@ -79,7 +80,15 @@ export const reserveThenDeposit = async (
   );
 };
 
-/** @type {<T>(store: ERef<Map<string, T> | import('@agoric/internal/src/scratch.js').ScratchPad>, key: string, make: () => T) => Promise<T>} */
+/**
+ * @type {<T>(
+ *   store: ERef<
+ *     Map<string, T> | import('@agoric/internal/src/scratch.js').ScratchPad
+ *   >,
+ *   key: string,
+ *   make: () => T,
+ * ) => Promise<T>}
+ */
 const provideWhen = async (store, key, make) => {
   const found = await E(store).get(key);
   if (found) {
@@ -91,21 +100,33 @@ const provideWhen = async (store, key, make) => {
 };
 
 /**
- * @param {{ scratch: ERef<import('@agoric/internal/src/scratch.js').ScratchPad> }} homeP
+ * @param {{
+ *   scratch: ERef<import('@agoric/internal/src/scratch.js').ScratchPad>;
+ * }} homeP
  * @param {object} opts
- * @param {(specifier: string) => Promise<{default: Bundle}>} opts.loadBundle
+ * @param {(specifier: string) => Promise<{ default: Bundle }>} opts.loadBundle
  * @param {string} [opts.installCacheKey]
  */
 export const makeInstallCache = async (
   homeP,
   { installCacheKey = 'installCache', loadBundle },
 ) => {
-  /** @type {CopyMap<string, {installation: Installation, boardId: string, path?: string}>} */
+  /**
+   * @type {CopyMap<
+   *   string,
+   *   { installation: Installation; boardId: string; path?: string }
+   * >}
+   */
   const initial = await provideWhen(E.get(homeP).scratch, installCacheKey, () =>
     makeCopyMap([]),
   );
   // ISSUE: getCopyMapEntries of CopyMap<K, V> loses K, V.
-  /** @type {Map<string, {installation: Installation, boardId: string, path?: string}>} */
+  /**
+   * @type {Map<
+   *   string,
+   *   { installation: Installation; boardId: string; path?: string }
+   * >}
+   */
   const working = new Map(getCopyMapEntries(initial));
 
   const saveCache = async () => {
@@ -137,3 +158,9 @@ export const makeInstallCache = async (
 
   return { wrapInstall, saveCache };
 };
+
+export const oracleBrandFeedName = (inBrandName, outBrandName) =>
+  `${inBrandName}-${outBrandName} price feed`;
+
+export const scaledPriceFeedName = issuerName =>
+  `scaledPriceAuthority-${issuerName}`;

package/src/provisionPool.d.ts

@@ -0,0 +1,167 @@
+/** @import {Marshal} from '@endo/marshal'; */
+/** @type {ContractMeta} */
+export const meta: ContractMeta;
+export function start(zcf: ZCF<ProvisionTerms>, privateArgs: {
+    poolBank: import("@endo/far").ERef<import("@agoric/vats/src/vat-bank.js").Bank>;
+    initialPoserInvitation: Invitation;
+    storageNode: StorageNode;
+    marshaller: Marshal<any>;
+    metricsOverride?: import("./provisionPoolKit.js").MetricsNotification;
+}, baggage: import("@agoric/vat-data").Baggage): Promise<{
+    creatorFacet: import("@endo/exo").Guarded<{
+        getParamMgrRetriever: () => {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                PerAccountInitialAmount: "amount";
+            } & {
+                Electorate: "invitation";
+            }>;
+        } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                PerAccountInitialAmount: "amount";
+            } & {
+                Electorate: "invitation";
+            }>;
+        }>;
+        getInvitation: (name: any) => Promise<Invitation<unknown, undefined>>;
+        getLimitedCreatorFacet: () => import("@endo/exo").Guarded<{
+            addRevivableAddresses(oldAddresses: string[]): void;
+            getWalletReviver(): import("@endo/exo").Guarded<{
+                reviveWallet(address: string): Promise<{
+                    handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string | null>, canSpend?: boolean | undefined): Promise<void>;
+                    getDepositFacet(): import("@endo/exo").Guarded<{
+                        receive(payment: Payment): Promise<globalThis.Amount>;
+                    }>;
+                    getOffersFacet(): import("@endo/exo").Guarded<{
+                        executeOffer(offerSpec: OfferSpec): Promise<void>;
+                        tryExitOffer(offerId: OfferId): Promise<void>;
+                    }>;
+                    getCurrentSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                    getUpdatesSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                    getPublicTopics(): {
+                        current: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                            storagePath: Promise<string>;
+                        };
+                        updates: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    repairWalletForIncarnation2(key: object): void;
+                } & import("../../../node_modules/@endo/exo/src/get-interface.js").GetInterfaceGuard<{
+                    handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string | null>, canSpend?: boolean | undefined): Promise<void>;
+                    getDepositFacet(): import("@endo/exo").Guarded<{
+                        receive(payment: Payment): Promise<globalThis.Amount>;
+                    }>;
+                    getOffersFacet(): import("@endo/exo").Guarded<{
+                        executeOffer(offerSpec: OfferSpec): Promise<void>;
+                        tryExitOffer(offerId: OfferId): Promise<void>;
+                    }>;
+                    getCurrentSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                    getUpdatesSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                    getPublicTopics(): {
+                        current: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                            storagePath: Promise<string>;
+                        };
+                        updates: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    repairWalletForIncarnation2(key: object): void;
+                }> & import("@endo/eventual-send").RemotableBrand<{}, {
+                    handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string | null>, canSpend?: boolean | undefined): Promise<void>;
+                    getDepositFacet(): import("@endo/exo").Guarded<{
+                        receive(payment: Payment): Promise<globalThis.Amount>;
+                    }>;
+                    getOffersFacet(): import("@endo/exo").Guarded<{
+                        executeOffer(offerSpec: OfferSpec): Promise<void>;
+                        tryExitOffer(offerId: OfferId): Promise<void>;
+                    }>;
+                    getCurrentSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                    getUpdatesSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                    getPublicTopics(): {
+                        current: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                            storagePath: Promise<string>;
+                        };
+                        updates: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    repairWalletForIncarnation2(key: object): void;
+                } & import("../../../node_modules/@endo/exo/src/get-interface.js").GetInterfaceGuard<{
+                    handleBridgeAction(actionCapData: import("@endo/marshal").CapData<string | null>, canSpend?: boolean | undefined): Promise<void>;
+                    getDepositFacet(): import("@endo/exo").Guarded<{
+                        receive(payment: Payment): Promise<globalThis.Amount>;
+                    }>;
+                    getOffersFacet(): import("@endo/exo").Guarded<{
+                        executeOffer(offerSpec: OfferSpec): Promise<void>;
+                        tryExitOffer(offerId: OfferId): Promise<void>;
+                    }>;
+                    getCurrentSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                    getUpdatesSubscriber(): globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                    getPublicTopics(): {
+                        current: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").CurrentWalletRecord>;
+                            storagePath: Promise<string>;
+                        };
+                        updates: {
+                            description: string;
+                            subscriber: globalThis.Subscriber<import("@agoric/smart-wallet/src/smartWallet.js").UpdateRecord>;
+                            storagePath: Promise<string>;
+                        };
+                    };
+                    repairWalletForIncarnation2(key: object): void;
+                }>> & import("@endo/marshal").RemotableObject>;
+                ackWallet(address: string): boolean;
+            }>;
+            setReferences(erefs: ProvisionPoolKitReferences): Promise<void>;
+            makeHandler(): {
+                fromBridge: (obj: any) => Promise<void>;
+            } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+                fromBridge: (obj: any) => Promise<void>;
+            }>;
+            initPSM(brand: Brand, instance: PsmInstance): void;
+        }>;
+        getGovernedApis: () => globalThis.GovernedApis;
+        getGovernedApiNames: () => string[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    }>;
+    publicFacet: import("@endo/exo").Guarded<{
+        getAmount: (name: string) => globalThis.Amount;
+        getBrand: (name: string) => globalThis.Brand;
+        getInstance: (name: string) => Instance;
+        getInstallation: (name: string) => Installation<any>;
+        getInvitationAmount: (name: string) => import("@agoric/ertp/src/types.js").SetAmount<InvitationDetails>;
+        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;
+        getSubscription: () => globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+        getGovernedParams: () => globalThis.ERef<globalThis.ParamStateRecord>;
+        getMetrics(): globalThis.Subscriber<import("./provisionPoolKit.js").MetricsNotification>;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<import("./provisionPoolKit.js").MetricsNotification>;
+        };
+    }>;
+}>;
+/**
+ * TODO: ERef<GovernedCreatorFacet<ProvisionCreator>>
+ */
+export type ProvisionTerms = StandardTerms & GovernanceTerms<{
+    PerAccountInitialAmount: "amount";
+}>;
+import type { Marshal } from '@endo/marshal';
+//# sourceMappingURL=provisionPool.d.ts.map

package/src/provisionPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provisionPool.d.ts","sourceRoot":"","sources":["provisionPool.js"],"names":[],"mappings":"AAgBA,8CAA8C;AAE9C,2BAA2B;AAC3B,mBADW,YAAY,CAerB;AAqBK,2BAZI,GAAG,CAAC,cAAc,CAAC;cAEf,OAAO,WAAW,EAAE,IAAI,CACtC,OAAa,8BAA8B,EAAE,IAAI,CAC5C;4BACuB,UAAU;iBACrB,WAAW;;sBAEN,OAAO,uBAAuB,EAAE,mBAAmB;YAE/D,OAAO,kBAAkB,EAAE,OAAO;;;;;;;;;;;;;;;;;gDAsEi4E,QAAQ;;;sDAA40+B,OAAO,eAAe,EAAE,OAAO,CAAC,SAAQ,IAAK,CAAC;;yCAAzjS,OAAO;;;gDAAm5I,SAAS;8CAA+tH,OAAO;;;;;;;;;;;;;;;;;;8EAA05B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;8EAAP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;8EAAP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAlj+B,0BAA0B;;;;;;2BAAgkC,KAAK,YAA2B,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;GAHn3H;;;;6BAlFY,aAAa,GACzB,eAAmB,CAAC;IACpB,uBAA6B,EAAE,QAAQ,CAAC;CACnC,CAAC;6BAxBoB,eAAe"}

package/src/provisionPool.js

@@ -0,0 +1,122 @@
+// @jessie-check
+// @ts-check
+
+import {
+  handleParamGovernance,
+  ParamTypes,
+  publicMixinAPI,
+} from '@agoric/governance';
+import { InvitationShape } from '@agoric/governance/src/typeGuards.js';
+import { M } from '@agoric/store';
+import { prepareExo } from '@agoric/vat-data';
+import { provideSingleton } from '@agoric/zoe/src/contractSupport/durability.js';
+import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
+import { TopicsRecordShape } from '@agoric/zoe/src/contractSupport/topics.js';
+import { prepareProvisionPoolKit } from './provisionPoolKit.js';
+
+/** @import {Marshal} from '@endo/marshal'; */
+
+/** @type {ContractMeta} */
+export const meta = {
+  privateArgsShape: M.splitRecord(
+    {
+      poolBank: M.eref(M.remotable('bank')),
+      storageNode: M.eref(M.remotable('storageNode')),
+      marshaller: M.eref(M.remotable('marshaller')),
+    },
+    {
+      // only necessary on first invocation, not subsequent
+      initialPoserInvitation: InvitationShape,
+      metricsOverride: M.recordOf(M.string()),
+    },
+  ),
+  upgradability: 'canUpgrade',
+};
+harden(meta);
+
+/**
+ * @typedef {StandardTerms &
+ *   GovernanceTerms<{
+ *     PerAccountInitialAmount: 'amount';
+ *   }>} ProvisionTerms
+ *   TODO: ERef<GovernedCreatorFacet<ProvisionCreator>>
+ * @param {ZCF<ProvisionTerms>} zcf
+ * @param {{
+ *   poolBank: import('@endo/far').ERef<
+ *     import('@agoric/vats/src/vat-bank.js').Bank
+ *   >;
+ *   initialPoserInvitation: Invitation;
+ *   storageNode: StorageNode;
+ *   marshaller: Marshal<any>;
+ *   metricsOverride?: import('./provisionPoolKit.js').MetricsNotification;
+ * }} privateArgs
+ * @param {import('@agoric/vat-data').Baggage} baggage
+ */
+export const start = async (zcf, privateArgs, baggage) => {
+  const { poolBank, metricsOverride } = privateArgs;
+
+  const { makeRecorderKit } = prepareRecorderKitMakers(
+    baggage,
+    privateArgs.marshaller,
+  );
+
+  // Governance
+  const { publicMixin, makeDurableGovernorFacet, params } =
+    await handleParamGovernance(
+      zcf,
+      privateArgs.initialPoserInvitation,
+      {
+        PerAccountInitialAmount: ParamTypes.AMOUNT,
+      },
+      privateArgs.storageNode,
+      privateArgs.marshaller,
+    );
+
+  const makeProvisionPoolKit = prepareProvisionPoolKit(baggage, {
+    makeRecorderKit,
+    params,
+    poolBank,
+    zcf,
+  });
+
+  const provisionPoolKit = await provideSingleton(
+    baggage,
+    'provisionPoolKit',
+    () =>
+      makeProvisionPoolKit({
+        // XXX governance can change the brand of the amount but should only be able to change the value
+        // NB: changing the brand will break this pool
+        // @ts-expect-error XXX Brand AssetKind
+        poolBrand: params.getPerAccountInitialAmount().brand,
+        storageNode: privateArgs.storageNode,
+      }),
+    kit => kit.helper.start({ metrics: metricsOverride }),
+  );
+
+  const publicFacet = prepareExo(
+    baggage,
+    'Provisioning Pool public',
+    M.interface('ProvisionPool', {
+      getMetrics: M.call().returns(M.remotable('MetricsSubscriber')),
+      getPublicTopics: M.call().returns(TopicsRecordShape),
+      ...publicMixinAPI,
+    }),
+    {
+      getMetrics() {
+        return provisionPoolKit.public.getPublicTopics().metrics.subscriber;
+      },
+      getPublicTopics() {
+        return provisionPoolKit.public.getPublicTopics();
+      },
+      ...publicMixin,
+    },
+  );
+
+  return harden({
+    creatorFacet: makeDurableGovernorFacet(baggage, provisionPoolKit.machine)
+      .governorFacet,
+    publicFacet,
+  });
+};
+
+harden(start);