@agoric/inter-protocol 0.17.0-u17.1 → 0.17.0-u18.0

package/src/price/roundsManager.js

@@ -26,7 +26,7 @@ const V3_NO_DATA_ERROR = 'No data present';
 /** @type {bigint} */
 export const ROUND_MAX = BigInt(2 ** 32 - 1);
 
-const trace = makeTracer('RoundsM', false);
+const trace = makeTracer('RoundsM', true);
 
 /** @param {bigint} roundId */
 const validRoundId = roundId => {
@@ -172,10 +172,13 @@ export const prepareRoundsManagerKit = baggage =>
         rounds,
         unitIn,
       };
+
+      const roundId = 0n;
+
       return {
         ...immutable,
         lastValueOutForUnitIn: null,
-        reportingRoundId: 0n,
+        reportingRoundId: roundId,
       };
     },
     {
@@ -600,8 +603,8 @@ export const prepareRoundsManagerKit = baggage =>
 
         /**
          * a method to provide all current info oracleStatuses need. Intended
-         * only only to be callable by oracleStatuses. Not for use by contracts
-         * to read state.
+         * only to be callable by oracleStatuses. Not for use by contracts to
+         * read state.
          *
          * @param {OracleStatus} status
          * @param {Timestamp} blockTimestamp
@@ -728,4 +731,50 @@ export const prepareRoundsManagerKit = baggage =>
         },
       },
     },
+    {
+      finish: ({ state }) => {
+        const { details, rounds, timerPresence } = state;
+        // Zero is treated as special as roundId and in times. It's hard to
+        // avoid on restart and in tests, so make 1 the minimum
+
+        const firstRound = 1n;
+        state.reportingRoundId = firstRound;
+        details.init(
+          firstRound,
+          harden({
+            submissions: [],
+            maxSubmissions: state.maxSubmissionCount,
+            minSubmissions: state.minSubmissionCount,
+            roundTimeout: state.timeout,
+          }),
+        );
+
+        // Cannot await in first crank. Fail if no timestamp available
+        void E.when(
+          E(timerPresence).getCurrentTimestamp(),
+          nowMaybe => {
+            const now =
+              TimeMath.compareAbs(nowMaybe, 1n) < 0
+                ? TimeMath.coerceTimestampRecord(1n, nowMaybe.timerBrand)
+                : nowMaybe;
+
+            const round = harden({
+              answer: 0n,
+              startedAt: now,
+              updatedAt: 0n,
+              answeredInRound: 0n,
+            });
+            rounds.init(firstRound, round);
+
+            // In case this is a replacement priceFeed, set roundId in vstorage.
+            void state.latestRoundPublisher.write({
+              roundId: firstRound,
+              startedAt: round.startedAt,
+              startedBy: 'uninitialized',
+            });
+          },
+          reason => Fail`need a timestamp to start roundsManager ${reason}`,
+        );
+      },
+    },
   );

package/src/proposals/add-auction.d.ts

@@ -1,8 +1,9 @@
-export function addAuction({ consume: { agoricNamesAdmin, auctioneerKit: legacyKitP, board, chainStorage, chainTimerService, economicCommitteeCreatorFacet: electorateCreatorFacet, econCharterKit, priceAuthority, zoe, }, produce: { auctioneerKit: produceAuctioneerKit, auctionUpgradeNewInstance }, instance: { consume: { reserve: reserveInstance }, produce: { auctioneer: auctionInstance }, }, installation: { consume: { contractGovernor: contractGovernorInstallation }, produce: { auctioneer: produceInstallation }, }, issuer: { consume: { [Stable.symbol]: stableIssuerP }, }, }: import("./econ-behaviors.js").EconomyBootstrapPowers & interlockPowers, { options }: {
+export function addAuction({ consume: { agoricNamesAdmin, auctioneerKit: legacyKitP, board, chainStorage, chainTimerService, economicCommitteeCreatorFacet: electorateCreatorFacet, econCharterKit, governedContractKits: governedContractKitsP, priceAuthority8400, zoe, }, produce: { auctioneerKit: produceAuctioneerKit, auctionUpgradeNewInstance, auctionUpgradeNewGovCreator, newContractGovBundleId, }, instance: { consume: { reserve: reserveInstance }, produce: { auctioneer: auctionInstance }, }, installation: { consume: { auctioneer: auctioneerInstallationP }, }, issuer: { consume: { [Stable.symbol]: stableIssuerP }, }, }: import("./econ-behaviors.js").EconomyBootstrapPowers & interlockPowers, { options: { contractGovernorRef: contractGovernorBundle, contractGovernorInstallation, }, }: {
     options: {
-        auctionsRef: {
+        contractGovernorRef: {
             bundleID: string;
         };
+        contractGovernorInstallation: Installation;
     };
 }): Promise<void>;
 export const ADD_AUCTION_MANIFEST: {
@@ -15,12 +16,15 @@ export const ADD_AUCTION_MANIFEST: {
             chainTimerService: boolean;
             econCharterKit: boolean;
             economicCommitteeCreatorFacet: boolean;
-            priceAuthority: boolean;
+            governedContractKits: boolean;
+            priceAuthority8400: boolean;
             zoe: boolean;
         };
         produce: {
             auctioneerKit: boolean;
             auctionUpgradeNewInstance: boolean;
+            auctionUpgradeNewGovCreator: boolean;
+            newContractGovBundleId: boolean;
         };
         instance: {
             consume: {
@@ -33,8 +37,6 @@ export const ADD_AUCTION_MANIFEST: {
         installation: {
             consume: {
                 contractGovernor: boolean;
-            };
-            produce: {
                 auctioneer: boolean;
             };
         };
@@ -45,7 +47,9 @@ export const ADD_AUCTION_MANIFEST: {
         };
     };
 };
-export function getManifestForAddAuction(_ign: object, addAuctionOptions: any): Promise<{
+export function getManifestForAddAuction({ restoreRef }: {
+    restoreRef: any;
+}, { auctioneerRef, contractGovernorRef }: any): Promise<{
     manifest: {
         [x: string]: {
             consume: {
@@ -56,12 +60,15 @@ export function getManifestForAddAuction(_ign: object, addAuctionOptions: any):
                 chainTimerService: boolean;
                 econCharterKit: boolean;
                 economicCommitteeCreatorFacet: boolean;
-                priceAuthority: boolean;
+                governedContractKits: boolean;
+                priceAuthority8400: boolean;
                 zoe: boolean;
             };
             produce: {
                 auctioneerKit: boolean;
                 auctionUpgradeNewInstance: boolean;
+                auctionUpgradeNewGovCreator: boolean;
+                newContractGovBundleId: boolean;
             };
             instance: {
                 consume: {
@@ -74,8 +81,6 @@ export function getManifestForAddAuction(_ign: object, addAuctionOptions: any):
             installation: {
                 consume: {
                     contractGovernor: boolean;
-                };
-                produce: {
                     auctioneer: boolean;
                 };
             };
@@ -86,10 +91,19 @@ export function getManifestForAddAuction(_ign: object, addAuctionOptions: any):
             };
         };
     };
-    options: any;
+    options: {
+        contractGovernorRef: any;
+        contractGovernorInstallation: any;
+    };
+    installations: {
+        auctioneer: any;
+        contractGovernor: any;
+    };
 }>;
 export type interlockPowers = PromiseSpaceOf<{
     auctionUpgradeNewInstance: Instance;
+    auctionUpgradeNewGovCreator: any;
+    newContractGovBundleId: string;
 }>;
 import { Stable } from '@agoric/internal/src/tokens.js';
 //# sourceMappingURL=add-auction.d.ts.map

package/src/proposals/add-auction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-auction.d.ts","sourceRoot":"","sources":["add-auction.js"],"names":[],"mappings":"AAmBO,okBAJI,OAAO,qBAAqB,EAAE,sBAAsB,GAC9D,eAAmB,eACT;IAAE,OAAO,EAAE;QAAE,WAAW,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAA;CAAE,iBA0K5D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BG;AAQI,+CAHI,MAAM,qBACN,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAOb;8BAhOY,cAAc,CAAC;IAC3B,yBAA6B,EAAE,QAAQ,CAAC;CACrC,CAAC;uBARkB,gCAAgC"}
+{"version":3,"file":"add-auction.d.ts","sourceRoot":"","sources":["add-auction.js"],"names":[],"mappings":"AA0BO,knBATI,OAAO,qBAAqB,EAAE,sBAAsB,GAC1D,eAAe,gGACT;IACN,OAAO,EAAE;QACP,mBAAmB,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAC1C,4BAA4B,EAAE,YAAY,CAAC;KAC5C,CAAC;CACH,iBAuLH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BG;AASI,yDAHJ;IAAmB,UAAU,EAArB,GAAG;CACX,0CAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBb;8BA/PY,cAAc,CAAC;IACvB,yBAAyB,EAAE,QAAQ,CAAC;IACpC,2BAA2B,EAAE,GAAG,CAAC;IACjC,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC;uBAVkB,gCAAgC"}

package/src/proposals/add-auction.js

@@ -9,13 +9,20 @@ const trace = makeTracer('NewAuction', true);
 /**
  * @typedef {PromiseSpaceOf<{
  *   auctionUpgradeNewInstance: Instance;
+ *   auctionUpgradeNewGovCreator: any;
+ *   newContractGovBundleId: string;
  * }>} interlockPowers
  */
 
 /**
  * @param {import('./econ-behaviors.js').EconomyBootstrapPowers &
  *   interlockPowers} powers
- * @param {{ options: { auctionsRef: { bundleID: string } } }} options
+ * @param {{
+ *   options: {
+ *     contractGovernorRef: { bundleID: string };
+ *     contractGovernorInstallation: Installation;
+ *   };
+ * }} options
  */
 export const addAuction = async (
   {
@@ -27,49 +34,50 @@ export const addAuction = async (
       chainTimerService,
       economicCommitteeCreatorFacet: electorateCreatorFacet,
       econCharterKit,
-      priceAuthority,
+      governedContractKits: governedContractKitsP,
+      priceAuthority8400,
       zoe,
     },
-    produce: { auctioneerKit: produceAuctioneerKit, auctionUpgradeNewInstance },
+    produce: {
+      auctioneerKit: produceAuctioneerKit,
+      auctionUpgradeNewInstance,
+      auctionUpgradeNewGovCreator,
+      newContractGovBundleId,
+    },
     instance: {
       consume: { reserve: reserveInstance },
       produce: { auctioneer: auctionInstance },
     },
     installation: {
-      consume: { contractGovernor: contractGovernorInstallation },
-      produce: { auctioneer: produceInstallation },
+      consume: { auctioneer: auctioneerInstallationP },
     },
     issuer: {
       consume: { [Stable.symbol]: stableIssuerP },
     },
   },
-  { options },
+  {
+    options: {
+      contractGovernorRef: contractGovernorBundle,
+      contractGovernorInstallation,
+    },
+  },
 ) => {
-  trace('addAuction start', options);
+  trace('addAuction start');
   const STORAGE_PATH = 'auction';
-  const { auctionsRef } = options;
 
   const poserInvitationP = E(electorateCreatorFacet).getPoserInvitation();
-  const bundleID = auctionsRef.bundleID;
-  /**
-   * @type {Promise<
-   *   Installation<import('../../src/auction/auctioneer.js')['start']>
-   * >}
-   */
-  const installationP = E(zoe).installBundleID(bundleID);
-  produceInstallation.reset();
-  produceInstallation.resolve(installationP);
-
   const [
     initialPoserInvitation,
     electorateInvitationAmount,
     stableIssuer,
     legacyKit,
+    auctioneerInstallation,
   ] = await Promise.all([
     poserInvitationP,
     E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
     stableIssuerP,
     legacyKitP,
+    auctioneerInstallationP,
   ]);
 
   // Each field has an extra layer of type +  value:
@@ -95,7 +103,7 @@ export const addAuction = async (
   const auctionTerms = makeGovernedATerms(
     { storageNode, marshaller },
     chainTimerService,
-    priceAuthority,
+    priceAuthority8400,
     reservePublicFacet,
     {
       ...params,
@@ -104,12 +112,10 @@ export const addAuction = async (
     },
   );
 
-  const installation = await installationP;
-
   const governorTerms = await deeplyFulfilledObject(
     harden({
       timer: chainTimerService,
-      governedContractInstallation: installation,
+      governedContractInstallation: auctioneerInstallation,
       governed: {
         terms: auctionTerms,
         issuerKeywordRecord: { Bid: stableIssuer },
@@ -120,7 +126,12 @@ export const addAuction = async (
     }),
   );
 
-  /** @type {GovernorStartedInstallationKit<typeof installationP>} */
+  const bundleIdFromZoe = await E(zoe).getBundleIDFromInstallation(
+    contractGovernorInstallation,
+  );
+  trace('governor bundle ID', bundleIdFromZoe, contractGovernorBundle.bundleID);
+
+  /** @type {GovernorStartedInstallationKit<typeof auctioneerInstallationP>} */
   const governorStartResult = await E(zoe).startInstance(
     contractGovernorInstallation,
     undefined,
@@ -136,12 +147,17 @@ export const addAuction = async (
     'auctioneer.governor',
   );
 
-  const [governedInstance, governedCreatorFacet, governedPublicFacet] =
-    await Promise.all([
-      E(governorStartResult.creatorFacet).getInstance(),
-      E(governorStartResult.creatorFacet).getCreatorFacet(),
-      E(governorStartResult.creatorFacet).getPublicFacet(),
-    ]);
+  const [
+    governedInstance,
+    governedCreatorFacet,
+    governedPublicFacet,
+    governedAdminFacet,
+  ] = await Promise.all([
+    E(governorStartResult.creatorFacet).getInstance(),
+    E(governorStartResult.creatorFacet).getCreatorFacet(),
+    E(governorStartResult.creatorFacet).getPublicFacet(),
+    E(governorStartResult.creatorFacet).getAdminFacet(),
+  ]);
 
   const allIssuers = await E(zoe).getIssuers(legacyKit.instance);
   const { Bid: _istIssuer, ...auctionIssuers } = allIssuers;
@@ -157,7 +173,7 @@ export const addAuction = async (
   const kit = harden({
     label: 'auctioneer',
     creatorFacet: governedCreatorFacet,
-    adminFacet: governorStartResult.adminFacet,
+    adminFacet: governedAdminFacet,
     publicFacet: governedPublicFacet,
     instance: governedInstance,
 
@@ -184,7 +200,11 @@ export const addAuction = async (
     governedInstance,
   );
 
+  const governedContractKits = await governedContractKitsP;
+  governedContractKits.init(kit.instance, kit);
   auctionUpgradeNewInstance.resolve(governedInstance);
+  auctionUpgradeNewGovCreator.resolve(kit.governorCreatorFacet);
+  newContractGovBundleId.resolve(contractGovernorBundle.bundleID);
 };
 
 export const ADD_AUCTION_MANIFEST = harden({
@@ -197,22 +217,22 @@ export const ADD_AUCTION_MANIFEST = harden({
       chainTimerService: true,
       econCharterKit: true,
       economicCommitteeCreatorFacet: true,
-      priceAuthority: true,
+      governedContractKits: true,
+      priceAuthority8400: true,
       zoe: true,
     },
     produce: {
       auctioneerKit: true,
       auctionUpgradeNewInstance: true,
+      auctionUpgradeNewGovCreator: true,
+      newContractGovBundleId: true,
     },
     instance: {
       consume: { reserve: true },
       produce: { auctioneer: true },
     },
     installation: {
-      consume: {
-        contractGovernor: true,
-      },
-      produce: { auctioneer: true },
+      consume: { contractGovernor: true, auctioneer: true },
     },
     issuer: {
       consume: { [Stable.symbol]: true },
@@ -223,12 +243,23 @@ export const ADD_AUCTION_MANIFEST = harden({
 /**
  * Add a new auction to a chain that already has one.
  *
- * @param {object} _ign
+ * @param {object} utils
+ * @param {any} utils.restoreRef
  * @param {any} addAuctionOptions
  */
-export const getManifestForAddAuction = async (_ign, addAuctionOptions) => {
+export const getManifestForAddAuction = async (
+  { restoreRef },
+  { auctioneerRef, contractGovernorRef },
+) => {
+  const contractGovernorInstallation = restoreRef(contractGovernorRef);
   return {
     manifest: ADD_AUCTION_MANIFEST,
-    options: addAuctionOptions,
+    // XXX we should be able to receive contractGovernorInstallation via
+    // installations.consume, but the received installation isn't right.
+    options: { contractGovernorRef, contractGovernorInstallation },
+    installations: {
+      auctioneer: restoreRef(auctioneerRef),
+      contractGovernor: restoreRef(contractGovernorRef),
+    },
   };
 };

package/src/proposals/addAssetToVault.d.ts

@@ -9,10 +9,23 @@ export function publishInterchainAssetFromBank({ consume: { bankManager, agoricN
         interchainAssetOptions: InterchainAssetOptions;
     };
 }): Promise<void>;
-export function registerScaledPriceAuthority({ consume: { agoricNamesAdmin, startUpgradable, priceAuthorityAdmin, priceAuthority, }, instance: { produce: produceInstance }, }: BootstrapPowers, { options: { interchainAssetOptions } }: {
+export function startScaledPriceAuthority({ consume: { agoricNamesAdmin, startUpgradable, priceAuthorityAdmin, priceAuthority, }, }: BootstrapPowers, { options: { interchainAssetOptions } }: {
     options: {
         interchainAssetOptions: InterchainAssetOptions;
     };
+}): Promise<{
+    instance: import("@agoric/zoe/src/zoeService/utils.js").Instance<import("@agoric/zoe/src/zoeService/utils.js").ContractStartFunction>;
+    adminFacet: import("@agoric/zoe/src/zoeService/utils.js").AdminFacet<import("@agoric/zoe/src/zoeService/utils.js").ContractStartFunction>;
+    creatorFacet: {};
+    publicFacet: {};
+} & {
+    creatorFacet?: {};
+    publicFacet?: {};
+} & {
+    label: string;
+}>;
+export function registerScaledPriceAuthority(powers: BootstrapPowers, { options }: {
+    options: object;
 }): Promise<void>;
 export function addAssetToVault({ consume: { vaultFactoryKit, agoricNamesAdmin, auctioneerKit, chainTimerService, }, brand: { consume: { [Stable.symbol]: stableP }, }, instance: { consume: consumeInstance }, }: EconomyBootstrapPowers, { options: { debtLimitValue, interestRateValue, interchainAssetOptions, }, }: {
     options: {

package/src/proposals/addAssetToVault.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addAssetToVault.d.ts","sourceRoot":"","sources":["addAssetToVault.js"],"names":[],"mappings":";AA4CO,4FALI,eAAe,2CAEvB;IAAuB,OAAO,EAC9B;QAA+C,sBAAsB,EAA7D,sBAAsB;KAChC;CAAA,yBAsBA;AAQM,yKALI,sBAAsB,2CAE9B;IAAuB,OAAO,EAC9B;QAA+C,sBAAsB,EAA7D,sBAAsB;KAChC;CAAA,iBAmDA;AAQM,gLALI,eAAe,2CAEvB;IAAuB,OAAO,EAC9B;QAA+C,sBAAsB,EAA7D,sBAAsB;KAChC;CAAA,iBA0GA;AA+EM,mNAPI,sBAAsB,gFAE9B;IAAuB,OAAO,EAC9B;QAA+C,sBAAsB,EAA7D,sBAAsB;QACmB,cAAc,EAAvD,MAAM,GAAG,MAAM,GAAG,MAAM;QACD,iBAAiB,EAAxC,MAAM;KAChB;CAAA,iBAyEA;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8EN;;;;;;;;aAvba,MAAM;;;;;;;;;;;;;;;;4CAQsB,qBAAqB;uBAzBxC,gCAAgC"}
+{"version":3,"file":"addAssetToVault.d.ts","sourceRoot":"","sources":["addAssetToVault.js"],"names":[],"mappings":";AA4CO,4FALI,eAAe,2CAEvB;IAAuB,OAAO,EAC9B;QAA+C,sBAAsB,EAA7D,sBAAsB;KAChC;CAAA,yBAsBA;AAQM,yKALI,sBAAsB,2CAE9B;IAAuB,OAAO,EAC9B;QAA+C,sBAAsB,EAA7D,sBAAsB;KAChC;CAAA,iBAmDA;AAQM,qIALI,eAAe,2CAEvB;IAAuB,OAAO,EAC9B;QAA+C,sBAAsB,EAA7D,sBAAsB;KAChC;CAAA;;;;;;;;;;GAuGA;AAOM,qDAJI,eAAe,eAEvB;IAAuB,OAAO,EAAtB,MAAM;CAChB,iBAgBA;AA+EM,mNAPI,sBAAsB,gFAE9B;IAAuB,OAAO,EAC9B;QAA+C,sBAAsB,EAA7D,sBAAsB;QACmB,cAAc,EAAvD,MAAM,GAAG,MAAM,GAAG,MAAM;QACD,iBAAiB,EAAxC,MAAM;KAChB;CAAA,iBAyEA;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8EN;;;;;;;;aA1ca,MAAM;;;;;;;;;;;;;;;;4CAQsB,qBAAqB;uBAzBxC,gCAAgC"}

package/src/proposals/addAssetToVault.js

@@ -129,7 +129,7 @@ export const publishInterchainAssetFromBank = async (
  * @param {object} config.options
  * @param {InterchainAssetOptions} config.options.interchainAssetOptions
  */
-export const registerScaledPriceAuthority = async (
+export const startScaledPriceAuthority = async (
   {
     consume: {
       agoricNamesAdmin,
@@ -137,7 +137,6 @@ export const registerScaledPriceAuthority = async (
       priceAuthorityAdmin,
       priceAuthority,
     },
-    instance: { produce: produceInstance },
   },
   { options: { interchainAssetOptions } },
 ) => {
@@ -170,8 +169,9 @@ export const registerScaledPriceAuthority = async (
     ]),
   ]);
 
+  // TODO get unit amounts elsewhere https://github.com/Agoric/agoric-sdk/issues/10235
   // We need "unit amounts" of each brand in order to get the ratios right.  You
-  // can ignore decimalPlaces when adding and subtracting a brand with itself,
+  // can ignore unit amounts when adding and subtracting a brand with itself,
   // but not when creating ratios.
   const getDecimalP = async brand => {
     const displayInfo = E(brand).getDisplayInfo();
@@ -230,6 +230,25 @@ export const registerScaledPriceAuthority = async (
     true, // force
   );
 
+  return spaKit;
+};
+
+/**
+ * @param {BootstrapPowers} powers
+ * @param {object} config
+ * @param {object} config.options
+ */
+export const registerScaledPriceAuthority = async (powers, { options }) => {
+  const {
+    instance: { produce: produceInstance },
+  } = powers;
+
+  const { keyword, issuerName = keyword } = options.interchainAssetOptions;
+
+  const spaKit = await startScaledPriceAuthority(powers, { options });
+
+  const label = scaledPriceFeedName(issuerName);
+
   // publish into agoricNames so that others can await its presence.
   // This must stay after registerPriceAuthority above so it's evidence of registration.
   // eslint-disable-next-line no-restricted-syntax -- computed property

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"}