@agoric/inter-protocol 0.16.2-other-dev-8f8782b.0 → 0.16.2-other-dev-3eb1a1d.0

package/src/proposals/core-proposal.d.ts

@@ -0,0 +1,149 @@
+export * from "./econ-behaviors.js";
+export * from "./startPSM.js";
+export * from "./startEconCommittee.js";
+export function storeInterContractStartKits({ consume: { contractKits, governedContractKits, econCharterKit, economicCommitteeKit, feeDistributorKit, auctioneerKit, reserveKit, vaultFactoryKit, }, }: import("./econ-behaviors.js").EconomyBootstrapPowers): Promise<void>;
+export const SIM_CHAIN_MANIFEST: {};
+export function getManifestForEconCommittee({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys, econCommitteeOptions }: {
+    installKeys: any;
+    econCommitteeOptions: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                board: boolean;
+                chainStorage: boolean;
+                diagnostics: boolean;
+                zoe: boolean;
+            };
+            produce: {
+                economicCommitteeKit: boolean;
+                economicCommitteeCreatorFacet: string;
+            };
+            installation: {
+                consume: {
+                    committee: string;
+                };
+            };
+            instance: {
+                produce: {
+                    economicCommittee: string;
+                };
+            };
+        };
+    };
+    installations: {
+        contractGovernor: any;
+        committee: any;
+        binaryVoteCounter: any;
+    };
+    options: {
+        econCommitteeOptions: any;
+    };
+};
+export function getManifestForMain({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys, vaultFactoryControllerAddress, minInitialPoolLiquidity, referencedUi, }: {
+    installKeys: any;
+    vaultFactoryControllerAddress: any;
+    minInitialPoolLiquidity: any;
+    referencedUi: any;
+}): {
+    manifest: import("@agoric/vats/src/core/lib-boot.js").BootstrapManifest;
+    installations: {
+        VaultFactory: any;
+        auctioneer: any;
+        feeDistributor: any;
+        reserve: any;
+    };
+    options: {
+        vaultFactoryControllerAddress: any;
+        minInitialPoolLiquidity: any;
+        referencedUi: any;
+    };
+};
+export function getManifestForInterProtocol({ restoreRef }: {
+    restoreRef: any;
+}, { econCommitteeOptions, installKeys, vaultFactoryControllerAddress, minInitialPoolLiquidity, referencedUi, }: {
+    econCommitteeOptions: any;
+    installKeys: any;
+    vaultFactoryControllerAddress: any;
+    minInitialPoolLiquidity: any;
+    referencedUi: any;
+}): {
+    manifest: {
+        [x: string]: import("@agoric/vats/src/core/lib-boot.js").BootstrapManifestPermit | {
+            consume: {
+                board: boolean;
+                chainStorage: boolean;
+                diagnostics: boolean;
+                zoe: boolean;
+            };
+            produce: {
+                economicCommitteeKit: boolean;
+                economicCommitteeCreatorFacet: string;
+            };
+            installation: {
+                consume: {
+                    committee: string;
+                };
+            };
+            instance: {
+                produce: {
+                    economicCommittee: string;
+                };
+            };
+        } | {
+            consume: {
+                chainTimerService: boolean;
+                diagnostics: boolean;
+                bankManager: boolean;
+                vaultFactoryKit: boolean;
+                periodicFeeCollectors: boolean;
+                reserveKit: boolean;
+                zoe: boolean;
+            };
+            produce: {
+                feeDistributorKit: boolean;
+                periodicFeeCollectors: boolean;
+            };
+            instance: {
+                produce: {
+                    feeDistributor: boolean;
+                };
+            };
+            installation: {
+                consume: {
+                    feeDistributor: boolean;
+                };
+            };
+            issuer: {
+                consume: {
+                    IST: string;
+                };
+            };
+            brand: {
+                consume: {
+                    IST: string;
+                };
+            };
+        };
+    };
+    installations: {
+        VaultFactory: any;
+        auctioneer: any;
+        feeDistributor: any;
+        reserve: any;
+        contractGovernor: any;
+        committee: any;
+        binaryVoteCounter: any;
+    };
+    options: {
+        vaultFactoryControllerAddress: any;
+        minInitialPoolLiquidity: any;
+        referencedUi: any;
+        econCommitteeOptions: any;
+    };
+};
+//# sourceMappingURL=core-proposal.d.ts.map

package/src/proposals/core-proposal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-proposal.d.ts","sourceRoot":"","sources":["core-proposal.js"],"names":[],"mappings":";;;AAgBO,wMADK,OAAO,qBAAqB,EAAE,sBAAsB,iBAmC/D;AA6HD,oCAA6C;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAeN;AAEM;;;;;;;;;;;;;;;;;;;;EAuBN;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCN"}

package/src/proposals/core-proposal.js

@@ -1,23 +1,19 @@
 // @jessie-check
 
-import { Stable } from '@agoric/vats/src/tokens.js';
+import { Stable } from '@agoric/internal/src/tokens.js';
 import * as econBehaviors from './econ-behaviors.js';
 import { ECON_COMMITTEE_MANIFEST } from './startEconCommittee.js';
 
 export * from './econ-behaviors.js';
-// @ts-expect-error Module './econ-behaviors.js' has already exported a member
-// named 'EconomyBootstrapPowers'.
-export * from './startPSM.js'; // eslint-disable-line import/export
-export * from './startEconCommittee.js'; // eslint-disable-line import/export
+export * from './startPSM.js';
+export * from './startEconCommittee.js';
 
 // XXX all the startInstance() should use startUpgradable()
 // or startGovernedUpgradeable() but that would
 // require updating a lot of tests. So for now, we just
 // grab the kits afterward and store them.
 
-/**
- * @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers
- */
+/** @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers */
 export const storeInterContractStartKits = async ({
   consume: {
     contractKits,
@@ -31,13 +27,15 @@ export const storeInterContractStartKits = async ({
   },
 }) => {
   /**
-   * @param {Promise<MapStore<string, {instance: Instance}>>} storeP
-   * @param {Promise<{instance: Instance}>[]} kitPs
+   * @param {Promise<MapStore<Instance, { instance: Instance }>>} storeP
+   * @param {Promise<{ instance: Instance }>[]} kitPs
    */
   const storeAll = async (storeP, kitPs) => {
     const store = await storeP;
     const kits = await Promise.all(kitPs);
-    kits.forEach(kit => store.init(kit.instance, kit));
+    for (const kit of kits) {
+      store.init(kit.instance, kit);
+    }
   };
 
   await storeAll(contractKits, [

package/src/proposals/deploy-price-feeds.d.ts

@@ -0,0 +1,76 @@
+/** @type {ChainlinkConfig} */
+export const DEFAULT_CONTRACT_TERMS: ChainlinkConfig;
+export function ensureOracleBrand({ namedVat: { consume: { agoricNames }, }, oracleBrand: { produce: oracleBrandProduce }, }: EconomyBootstrapPowers & NamedVatPowers, { name, decimalPlaces }: {
+    name: string;
+    decimalPlaces: number;
+}): Promise<Brand<"nat">>;
+export function deployPriceFeeds(powers: EconomyBootstrapPowers & NamedVatPowers, config: {
+    options: PriceFeedConfig & {
+        priceAggregatorRef: {
+            bundleID: string;
+        };
+        scaledPARef: {
+            bundleID: string;
+        };
+        inBrandsDecimals?: number;
+        contractTerms?: ChainlinkConfig;
+        outBrandName?: string;
+        outBrandDecimals?: number;
+    };
+}): Promise<void>;
+export function getManifestForPriceFeeds({ restoreRef: _restoreRef }: {
+    restoreRef: any;
+}, priceFeedOptions: PriceFeedConfig & {
+    priceAggregatorRef: any;
+}): Promise<{
+    manifest: {
+        [x: string]: {
+            namedVat: string;
+            consume: {
+                agoricNamesAdmin: string;
+                agoricNames: string;
+                board: string;
+                chainStorage: string;
+                chainTimerService: string;
+                contractKits: string;
+                econCharterKit: string;
+                highPrioritySendersManager: string;
+                instancePrivateArgs: string;
+                namesByAddressAdmin: string;
+                priceAuthority: string;
+                priceAuthorityAdmin: string;
+                startGovernedUpgradable: string;
+                startUpgradable: string;
+                zoe: string;
+            };
+            installation: {
+                produce: {
+                    priceAggregator: string;
+                };
+            };
+            instance: {
+                produce: string;
+            };
+            oracleBrand: {
+                produce: string;
+            };
+            produce: {
+                priceAuthority8400: string;
+            };
+        };
+    };
+    options: {
+        oracleAddresses: string[];
+        inBrandNames: string[];
+        contractTerms?: Partial<ChainlinkConfig>;
+        priceAggregatorRef: any;
+    };
+}>;
+export type PriceFeedConfig = {
+    oracleAddresses: string[];
+    inBrandNames: string[];
+    contractTerms?: Partial<ChainlinkConfig>;
+};
+import type { ChainlinkConfig } from '@agoric/inter-protocol/src/price/fluxAggregatorKit.js';
+import type { EconomyBootstrapPowers } from './econ-behaviors.js';
+//# sourceMappingURL=deploy-price-feeds.d.ts.map

package/src/proposals/deploy-price-feeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deploy-price-feeds.d.ts","sourceRoot":"","sources":["deploy-price-feeds.js"],"names":[],"mappings":"AAcA,8BAA8B;AAC9B,qCADW,eAAe,CAQxB;AA4CK,8HAJI,sBAAsB,GAAG,cAAc,2BACvC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GACrC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAmBjC;AA0HM,yCAZI,sBAAsB,GAAG,cAAc,UACvC;IACN,OAAO,EAAE,eAAe,GAAG;QACzB,kBAAkB,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QACzC,WAAW,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAClC,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,aAAa,CAAC,EAAE,eAAe,CAAC;QAChC,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,CAAC;CACH,iBAoEH;AAWM,sEAHJ;IAAmB,UAAU,EAArB,GAAG;CACX,oBAAQ,eAAe,GAAG;IAAE,kBAAkB,EAAE,GAAG,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAxPlC,MAAM,EAAE;sBACX,MAAM,EAAE;wBACN,OAAO,CAAC,eAAe,CAAC;4BAsPM,GAAG;;GAmCpD;8BA5RW;IACR,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;CAC1C;qCAV+B,uDAAuD;4CADhD,qBAAqB"}

package/src/proposals/deploy-price-feeds.js

@@ -0,0 +1,316 @@
+import { makeTracer } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+import { E } from '@endo/far';
+
+import { unitAmount } from '@agoric/zoe/src/contractSupport/priceQuote.js';
+import {
+  oracleBrandFeedName,
+  reserveThenDeposit,
+  sanitizePathSegment,
+} from './utils.js';
+import { replaceScaledPriceAuthorities } from './replace-scaledPriceAuthorities.js';
+
+const STORAGE_PATH = 'priceFeed';
+
+/** @type {ChainlinkConfig} */
+export const DEFAULT_CONTRACT_TERMS = {
+  maxSubmissionCount: 1000,
+  minSubmissionCount: 2,
+  restartDelay: 1n, // the number of rounds an Oracle has to wait before they can initiate another round
+  timeout: 10, // in seconds according to chainTimerService
+  minSubmissionValue: 1,
+  maxSubmissionValue: 2 ** 256,
+};
+
+/** @import {EconomyBootstrapPowers} from './econ-behaviors.js'; */
+/** @import {ChainlinkConfig} from '@agoric/inter-protocol/src/price/fluxAggregatorKit.js'; */
+/** @import {FluxStartFn} from '@agoric/inter-protocol/src/price/fluxAggregatorContract.js'; */
+
+const trace = makeTracer('DeployPriceFeed', true);
+
+/**
+ * @typedef {{
+ *   oracleAddresses: string[];
+ *   inBrandNames: string[];
+ *   contractTerms?: Partial<ChainlinkConfig>;
+ * }} PriceFeedConfig
+ */
+
+/**
+ * @param {EconomyBootstrapPowers} powers
+ * @param {string} bundleID
+ */
+const installPriceAggregator = async (
+  {
+    consume: { zoe },
+    installation: {
+      produce: { priceAggregator },
+    },
+  },
+  bundleID,
+) => {
+  /** @type {Installation<FluxStartFn>} */
+  const installation = await E(zoe).installBundleID(bundleID);
+  priceAggregator.reset();
+  priceAggregator.resolve(installation);
+  trace('installed priceAggregator', bundleID.slice(0, 'b1-1234567'.length));
+  return installation;
+};
+
+/**
+ * Provide (find/create) inert brands (no mint or issuer) referred to by oracles
+ *
+ * @param {EconomyBootstrapPowers & NamedVatPowers} space
+ * @param {{ name: string; decimalPlaces: number }} opt
+ * @returns {Promise<Brand<'nat'>>}
+ */
+export const ensureOracleBrand = async (
+  {
+    namedVat: {
+      consume: { agoricNames },
+    },
+    oracleBrand: { produce: oracleBrandProduce },
+  },
+  { name, decimalPlaces },
+) => {
+  const brand = E(agoricNames).provideInertBrand(name, {
+    assetKind: 'nat',
+    decimalPlaces,
+  });
+
+  oracleBrandProduce[name].reset();
+  oracleBrandProduce[name].resolve(brand);
+  return brand;
+};
+
+/**
+ * @param {EconomyBootstrapPowers} powers
+ * @param {{
+ *   AGORIC_INSTANCE_NAME: string;
+ *   contractTerms: import('@agoric/inter-protocol/src/price/fluxAggregatorKit.js').ChainlinkConfig;
+ *   brandIn: Brand<'nat'>;
+ *   brandOut: Brand<'nat'>;
+ * }} config
+ * @param {Installation<FluxStartFn>} installation
+ */
+const startPriceAggregatorInstance = async (
+  {
+    consume: {
+      board,
+      chainStorage,
+      chainTimerService,
+      econCharterKit,
+      highPrioritySendersManager,
+      namesByAddressAdmin,
+      startGovernedUpgradable,
+    },
+    instance: { produce: produceInstance },
+  },
+  { AGORIC_INSTANCE_NAME, contractTerms, brandIn, brandOut },
+  installation,
+) => {
+  trace('startPriceAggregatorInstance', AGORIC_INSTANCE_NAME);
+  const label = sanitizePathSegment(AGORIC_INSTANCE_NAME);
+
+  const feedsStorage = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
+  const storageNode = await E(feedsStorage).makeChildNode(label);
+  const marshaller = await E(board).getReadonlyMarshaller();
+
+  const terms = harden({
+    ...contractTerms,
+    description: AGORIC_INSTANCE_NAME,
+    brandIn,
+    brandOut,
+    // XXX powerful TimerService, see #6003
+    timer: await chainTimerService,
+    unitAmountIn: await unitAmount(brandIn),
+  });
+  const privateArgs = {
+    highPrioritySendersManager: await highPrioritySendersManager,
+    marshaller,
+    namesByAddressAdmin,
+    storageNode,
+  };
+  const governedKit = await E(startGovernedUpgradable)({
+    governedParams: {},
+    privateArgs,
+    terms,
+    label,
+    // @ts-expect-error GovernableStartFn vs. fluxAggregatorContract.js start
+    installation,
+  });
+  produceInstance[AGORIC_INSTANCE_NAME].reset();
+  produceInstance[AGORIC_INSTANCE_NAME].resolve(governedKit.instance);
+  trace(
+    'new instance',
+    label,
+    { terms, privateArgs, installation },
+    governedKit,
+  );
+
+  await E(E.get(econCharterKit).creatorFacet).addInstance(
+    governedKit.instance,
+    governedKit.governorCreatorFacet,
+    AGORIC_INSTANCE_NAME,
+  );
+  trace('added', label, 'instance to econCharter');
+
+  /** @type {import('@agoric/zoe/src/zoeService/utils.js').StartedInstanceKit<FluxStartFn>} */
+  // @ts-expect-error
+  const { instance, publicFacet, creatorFacet } = governedKit;
+
+  return harden({ instance, publicFacet, creatorFacet });
+};
+
+/**
+ * Send invitations to oracle operators for a price feed.
+ *
+ * @param {EconomyBootstrapPowers} powers
+ * @param {{ oracleAddresses: string[]; AGORIC_INSTANCE_NAME: string }} config
+ * @param {any} creatorFacet
+ */
+const distributeInvitations = async (
+  { consume: { namesByAddressAdmin } },
+  { oracleAddresses, AGORIC_INSTANCE_NAME },
+  creatorFacet,
+) => {
+  /** @param {string} addr */
+  const addOracle = async addr => {
+    const invitation = await E(creatorFacet).makeOracleInvitation(addr);
+    const debugName = `${AGORIC_INSTANCE_NAME} member ${addr}`;
+    await reserveThenDeposit(debugName, namesByAddressAdmin, addr, [
+      invitation,
+    ]).catch(err => console.error(`failed deposit to ${debugName}`, err));
+  };
+
+  trace('distributing invitations', oracleAddresses);
+  // This doesn't resolve until oracle operators create their smart wallets.
+  // Don't block completion on it.
+  void Promise.all(oracleAddresses.map(addOracle));
+  trace('createPriceFeed complete');
+};
+
+/**
+ * @param {EconomyBootstrapPowers & NamedVatPowers} powers
+ * @param {{
+ *   options: PriceFeedConfig & {
+ *     priceAggregatorRef: { bundleID: string };
+ *     scaledPARef: { bundleID: string };
+ *     inBrandsDecimals?: number;
+ *     contractTerms?: ChainlinkConfig;
+ *     outBrandName?: string;
+ *     outBrandDecimals?: number;
+ *   };
+ * }} config
+ */
+export const deployPriceFeeds = async (powers, config) => {
+  const {
+    inBrandNames,
+    oracleAddresses,
+    contractTerms,
+    priceAggregatorRef,
+    scaledPARef,
+    inBrandsDecimals = 6,
+    outBrandName = 'USD',
+    outBrandDecimals = 6,
+  } = config.options;
+  await null;
+
+  const installation = await installPriceAggregator(
+    powers,
+    priceAggregatorRef.bundleID,
+  );
+
+  const { priceAuthorityAdmin, priceAuthority } = powers.consume;
+
+  trace({ oracleAddresses });
+  trace({ inBrandNames });
+  for (const inBrandName of inBrandNames) {
+    const AGORIC_INSTANCE_NAME = oracleBrandFeedName(inBrandName, outBrandName);
+    const brandIn = await ensureOracleBrand(powers, {
+      name: inBrandName,
+      decimalPlaces: inBrandsDecimals,
+    });
+    const brandOut = await ensureOracleBrand(powers, {
+      name: outBrandName,
+      decimalPlaces: outBrandDecimals,
+    });
+    const kit = await startPriceAggregatorInstance(
+      powers,
+      {
+        AGORIC_INSTANCE_NAME,
+        brandIn,
+        brandOut,
+        contractTerms: { ...DEFAULT_CONTRACT_TERMS, ...contractTerms },
+      },
+      installation,
+    );
+
+    const forceReplace = true;
+    await E(priceAuthorityAdmin).registerPriceAuthority(
+      E(kit.publicFacet).getPriceAuthority(),
+      brandIn,
+      brandOut,
+      forceReplace,
+    );
+
+    await distributeInvitations(
+      powers,
+      { oracleAddresses, AGORIC_INSTANCE_NAME },
+      kit.creatorFacet,
+    );
+  }
+
+  // @ts-expect-error replaceScaledPriceAuthorities uses a subset of the powers.
+  await replaceScaledPriceAuthorities(powers, {
+    options: { scaledPARef },
+  });
+
+  trace('resolving priceAuthority8400');
+  // cf. #8400 QuotePayments storage leak
+  powers.produce.priceAuthority8400.resolve(priceAuthority);
+};
+
+const t = 'priceFeed';
+
+/**
+ * Thread price feed upgrade options through from builder to core-eval.
+ *
+ * @param {object} utils
+ * @param {any} utils.restoreRef
+ * @param {PriceFeedConfig & { priceAggregatorRef: any }} priceFeedOptions
+ */
+export const getManifestForPriceFeeds = async (
+  { restoreRef: _restoreRef },
+  priceFeedOptions,
+) => ({
+  manifest: {
+    [deployPriceFeeds.name]: {
+      namedVat: t,
+      consume: {
+        agoricNamesAdmin: t,
+        agoricNames: t,
+        board: t,
+        chainStorage: t,
+        chainTimerService: t,
+        contractKits: t,
+        econCharterKit: t,
+        highPrioritySendersManager: t,
+        instancePrivateArgs: t,
+        namesByAddressAdmin: t,
+        priceAuthority: t,
+        priceAuthorityAdmin: t,
+        startGovernedUpgradable: t,
+        startUpgradable: t,
+        zoe: t,
+      },
+      installation: { produce: { priceAggregator: t } },
+      instance: {
+        produce: t,
+      },
+      oracleBrand: { produce: t },
+      produce: { priceAuthority8400: t },
+    },
+  },
+  options: { ...priceFeedOptions },
+});