@agoric/inter-protocol 0.16.2-dev-de2008a.0 → 0.16.2-dev-9d7a377.0

package/src/price/fluxAggregatorKit.d.ts

@@ -1,10 +1,10 @@
 export const INVITATION_MAKERS_DESC: "oracle invitation";
 export function prepareFluxAggregatorKit(baggage: Baggage, zcf: ZCF<ChainlinkConfig & {
     timer: TimerService;
-    brandIn: Brand<'nat'>;
-    brandOut: Brand<'nat'>;
-    unitAmountIn?: Amount<'nat'>;
-}>, timerPresence: TimerService, quoteKit: import('./roundsManager.js').QuoteKit, storageNode: StorageNode, makeDurablePublishKit: () => PublishKit<any>, makeRecorder: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorder): Promise<() => import("@endo/exo").GuardedKit<{
+    brandIn: Brand<"nat">;
+    brandOut: Brand<"nat">;
+    unitAmountIn?: Amount<"nat">;
+}>, timerPresence: TimerService, quoteKit: import("./roundsManager.js").QuoteKit, storageNode: StorageNode, makeDurablePublishKit: () => PublishKit<any>, makeRecorder: import("@agoric/zoe/src/contractSupport/recorder.js").MakeRecorder): Promise<() => import("@endo/exo").GuardedKit<{
     creator: {
         /**
          * An "oracle invitation" is an invitation to be able to submit data to
@@ -19,13 +19,13 @@ export function prepareFluxAggregatorKit(baggage: Baggage, zcf: ZCF<ChainlinkCon
         makeOracleInvitation(oracleId: string): Promise<Invitation<{
             invitationMakers: {
                 /** @param {import('./roundsManager.js').PriceRound} result */
-                PushPrice(result: import('./roundsManager.js').PriceRound): Promise<Invitation<void, undefined>>;
+                PushPrice(result: import("./roundsManager.js").PriceRound): Promise<Invitation<void, undefined>>;
             } & import("@endo/eventual-send").RemotableBrand<{}, {
                 /** @param {import('./roundsManager.js').PriceRound} result */
-                PushPrice(result: import('./roundsManager.js').PriceRound): Promise<Invitation<void, undefined>>;
+                PushPrice(result: import("./roundsManager.js").PriceRound): Promise<Invitation<void, undefined>>;
             }>;
             oracle: import("@endo/exo").Guarded<{
-                pushPrice({ roundId: roundIdRaw, unitPrice: valueRaw, }: import("./priceOracleKit.js").PriceDatum): Promise<void>;
+                pushPrice({ roundId: roundIdRaw, unitPrice: valueRaw, }: PriceDatum): Promise<void>;
                 getStatus(): import("./priceOracleKit.js").OracleStatus;
             }>;
         }, undefined>>;
@@ -38,7 +38,7 @@ export function prepareFluxAggregatorKit(baggage: Baggage, zcf: ZCF<ChainlinkCon
                 disable(): void;
             };
             oracle: {
-                pushPrice({ roundId: roundIdRaw, unitPrice: valueRaw, }: import("./priceOracleKit.js").PriceDatum): Promise<void>;
+                pushPrice({ roundId: roundIdRaw, unitPrice: valueRaw, }: PriceDatum): Promise<void>;
                 getStatus(): import("./priceOracleKit.js").OracleStatus;
             };
         }>>;

package/src/price/fluxAggregatorKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fluxAggregatorKit.d.ts","sourceRoot":"","sources":["fluxAggregatorKit.js"],"names":[],"mappings":"AAsBA,yDAA0D;AAgEnD;;aAXS,KAAK,CAAC,KAAK,CAAC;cACX,KAAK,CAAC,KAAK,CAAC;mBACP,MAAM,CAAC,KAAK,CAAC;2CAIxB,OAAO,oBAAoB,EAAE,QAAQ,eACrC,WAAW,yBACX,MAAM,UAAU,CAAC,GAAG,CAAC,gBACrB,OAAO,6CAA6C,EAAE,YAAY;;QAmJrE;;;;;;;;;WASG;uCADQ,MAAM;;gBAiBX,8DAA8D;kCAAlD,OAAO,oBAAoB,EAAE,UAAU;;gBAAnD,8DAA8D;kCAAlD,OAAO,oBAAoB,EAAE,UAAU;;;;;;;QAqBzD,+BAA+B;+BAAnB,MAAM;;QAalB,+BAA+B;6BAAnB,MAAM;;;;;;;;;QAoBlB;;;;;;;;WAQG;mCAHQ,MAAM,kBACN,MAAM,GACJ,OAAO,CAAC,UAAU,CAAC;;;;;;;;;IAqDvC;;8BA5Ua,OAAO;oBACP,MAAM;sBACN,MAAM;;kBAEN,MAAM;iBACN,MAAM;;;wBAMN,MAAM;wBACN,MAAM;;;;;kBACN,MAAM;;;;;wBAEN,MAAM;;;;;wBAEN,MAAM;;;;;;aAEN,MAAM;;gCA2TN,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC;6BA3VpD,kBAAkB;kCAKb,cAAc;+BAJjB,cAAc"}
+{"version":3,"file":"fluxAggregatorKit.d.ts","sourceRoot":"","sources":["fluxAggregatorKit.js"],"names":[],"mappings":"AAsBA,yDAA0D;AAgEnD;;aAXS,KAAK,CAAC,KAAK,CAAC;cACX,KAAK,CAAC,KAAK,CAAC;mBACP,MAAM,CAAC,KAAK,CAAC;2CAIxB,OAAO,oBAAoB,EAAE,QAAQ,eACrC,WAAW,yBACX,MAAM,UAAU,CAAC,GAAG,CAAC,gBACrB,OAAO,6CAA6C,EAAE,YAAY;;QAmJrE;;;;;;;;;WASG;uCADQ,MAAM;;gBAiBX,8DAA8D;kCAAlD,OAAO,oBAAoB,EAAE,UAAU;;gBAAnD,8DAA8D;kCAAlD,OAAO,oBAAoB,EAAE,UAAU;;;yEA5MvD,UAAU;;;;QAiOZ,+BAA+B;+BAAnB,MAAM;;QAalB,+BAA+B;6BAAnB,MAAM;;;;;;;;;QAoBlB;;;;;;;;WAQG;mCAHQ,MAAM,kBACN,MAAM,GACJ,OAAO,CAAC,UAAU,CAAC;;;;;;;;;IAqDvC;;8BA5Ua,OAAO;oBACP,MAAM;sBACN,MAAM;;kBAEN,MAAM;iBACN,MAAM;;;wBAMN,MAAM;wBACN,MAAM;;;;;kBACN,MAAM;;;;;wBAEN,MAAM;;;;;wBAEN,MAAM;;;;;;aAEN,MAAM;;gCA2TN,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC;6BA3VpD,kBAAkB;kCAKb,cAAc;+BAJjB,cAAc"}

package/src/price/priceOracleKit.d.ts

@@ -17,7 +17,7 @@ export function prepareOracleAdminKit(baggage: any): (args_0: HeldParams) => imp
 export type HeldParams = {
     oracleId: string;
     roundPowers: {
-        handlePush: (status: OracleStatus, result: import('./roundsManager.js').PriceRound) => Promise<OracleStatus>;
+        handlePush: (status: OracleStatus, result: import("./roundsManager.js").PriceRound) => Promise<OracleStatus>;
     };
 };
 export type PriceDatum = {

package/src/price/roundsManager.d.ts

@@ -3,12 +3,12 @@ export const ROUND_MAX: bigint;
 export function prepareRoundsManagerKit(baggage: any): (args_0: Readonly<import("./fluxAggregatorKit.js").ChainlinkConfig & {
     quoteKit: QuoteKit;
     answerPublisher: Publisher<void>;
-    brandIn: Brand<'nat'>;
-    brandOut: Brand<'nat'>;
-    latestRoundPublisher: import('@agoric/zoe/src/contractSupport/recorder.js').Recorder<LatestRound>;
+    brandIn: Brand<"nat">;
+    brandOut: Brand<"nat">;
+    latestRoundPublisher: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<LatestRound>;
     timerPresence: TimerService;
 }> & {
-    unitAmountIn: Amount<'nat'>;
+    unitAmountIn: Amount<"nat">;
 }) => import("@endo/exo").GuardedKit<{
     helper: {
         /** @param {bigint} roundId */
@@ -142,7 +142,7 @@ export type PriceRound = {
     roundId: number | undefined;
     unitPrice: NatValue;
 };
-export type LatestRound = Pick<RoundData, 'roundId' | 'startedAt'> & {
+export type LatestRound = Pick<RoundData, "roundId" | "startedAt"> & {
     startedBy: string;
 };
 export type RoundData = Round & {
@@ -177,7 +177,7 @@ export type RoundDetails = {
     minSubmissions: number;
     roundTimeout: number;
 };
-export type QuoteKit = IssuerKit<'set'>;
+export type QuoteKit = IssuerKit<"set">;
 export type HeldParams = {
     readonly maxSubmissionCount: number;
     readonly minSubmissionCount: number;
@@ -204,9 +204,9 @@ export type HeldParams = {
     readonly timeout: number;
     readonly quoteKit: QuoteKit;
     readonly answerPublisher: Publisher<void>;
-    readonly brandIn: Brand<'nat'>;
-    readonly brandOut: Brand<'nat'>;
-    readonly latestRoundPublisher: import('@agoric/zoe/src/contractSupport/recorder.js').Recorder<LatestRound>;
+    readonly brandIn: Brand<"nat">;
+    readonly brandOut: Brand<"nat">;
+    readonly latestRoundPublisher: import("@agoric/zoe/src/contractSupport/recorder.js").Recorder<LatestRound>;
     readonly timerPresence: TimerService;
 };
 export type ImmutableState = Readonly<HeldParams & {

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

@@ -0,0 +1,69 @@
+export function addAuction({ consume: { zoe, board, chainTimerService, priceAuthority, chainStorage, economicCommitteeCreatorFacet: electorateCreatorFacet, auctioneerKit: legacyKitP, }, produce: { newAuctioneerKit }, instance: { consume: { reserve: reserveInstance }, }, installation: { consume: { auctioneer: auctionInstallation, contractGovernor: contractGovernorInstallation, }, }, issuer: { consume: { [Stable.symbol]: stableIssuerP }, }, }: import("./econ-behaviors.js").EconomyBootstrapPowers): Promise<void>;
+export const ADD_AUCTION_MANIFEST: {
+    [x: string]: {
+        consume: {
+            zoe: boolean;
+            board: boolean;
+            chainTimerService: boolean;
+            priceAuthority: boolean;
+            chainStorage: boolean;
+            economicCommitteeCreatorFacet: boolean;
+            auctioneerKit: boolean;
+        };
+        produce: {
+            newAuctioneerKit: boolean;
+        };
+        instance: {
+            consume: {
+                reserve: boolean;
+            };
+        };
+        installation: {
+            consume: {
+                auctioneer: boolean;
+                contractGovernor: boolean;
+            };
+        };
+        issuer: {
+            consume: {
+                IST: boolean;
+            };
+        };
+    };
+};
+export function getManifestForAddAuction(): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                zoe: boolean;
+                board: boolean;
+                chainTimerService: boolean;
+                priceAuthority: boolean;
+                chainStorage: boolean;
+                economicCommitteeCreatorFacet: boolean;
+                auctioneerKit: boolean;
+            };
+            produce: {
+                newAuctioneerKit: boolean;
+            };
+            instance: {
+                consume: {
+                    reserve: boolean;
+                };
+            };
+            installation: {
+                consume: {
+                    auctioneer: boolean;
+                    contractGovernor: boolean;
+                };
+            };
+            issuer: {
+                consume: {
+                    IST: boolean;
+                };
+            };
+        };
+    };
+}>;
+import { Stable } from '@agoric/internal/src/tokens.js';
+//# sourceMappingURL=add-auction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"add-auction.d.ts","sourceRoot":"","sources":["add-auction.js"],"names":[],"mappings":"AASO,8bADK,OAAO,qBAAqB,EAAE,sBAAsB,iBAsI/D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BG;AAGI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEN;uBA7KsB,gCAAgC"}

package/src/proposals/add-auction.js

@@ -0,0 +1,177 @@
+import { deeplyFulfilledObject, makeTracer } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+import { E } from '@endo/far';
+import { Stable } from '@agoric/internal/src/tokens.js';
+import { makeGovernedTerms as makeGovernedATerms } from '../auction/params.js';
+
+const trace = makeTracer('NewAuction', true);
+
+/** @param {import('./econ-behaviors.js').EconomyBootstrapPowers} powers */
+export const addAuction = async ({
+  consume: {
+    zoe,
+    board,
+    chainTimerService,
+    priceAuthority,
+    chainStorage,
+    economicCommitteeCreatorFacet: electorateCreatorFacet,
+    auctioneerKit: legacyKitP,
+  },
+  produce: { newAuctioneerKit },
+  instance: {
+    consume: { reserve: reserveInstance },
+  },
+  installation: {
+    consume: {
+      auctioneer: auctionInstallation,
+      contractGovernor: contractGovernorInstallation,
+    },
+  },
+  issuer: {
+    consume: { [Stable.symbol]: stableIssuerP },
+  },
+}) => {
+  trace('addAuction start');
+  const STORAGE_PATH = 'auction';
+
+  const poserInvitationP = E(electorateCreatorFacet).getPoserInvitation();
+
+  const [
+    initialPoserInvitation,
+    electorateInvitationAmount,
+    stableIssuer,
+    legacyKit,
+  ] = await Promise.all([
+    poserInvitationP,
+    E(E(zoe).getInvitationIssuer()).getAmountOf(poserInvitationP),
+    stableIssuerP,
+    legacyKitP,
+  ]);
+
+  // Each field has an extra layer of type +  value:
+  // AuctionStartDelay: { type: 'relativeTime', value: { relValue: 2n, timerBrand: Object [Alleged: timerBrand] {} } }
+  /** @type {any} */
+  const paramValues = await E(legacyKit.publicFacet).getGovernedParams();
+  const params = harden({
+    StartFrequency: paramValues.StartFrequency.value,
+    ClockStep: paramValues.ClockStep.value,
+    StartingRate: paramValues.StartingRate.value,
+    LowestRate: paramValues.LowestRate.value,
+    DiscountStep: paramValues.DiscountStep.value,
+    AuctionStartDelay: paramValues.AuctionStartDelay.value,
+    PriceLockPeriod: paramValues.PriceLockPeriod.value,
+  });
+  const timerBrand = await E(chainTimerService).getTimerBrand();
+
+  const storageNode = await makeStorageNodeChild(chainStorage, STORAGE_PATH);
+  const marshaller = await E(board).getReadonlyMarshaller();
+
+  const reservePublicFacet = await E(zoe).getPublicFacet(reserveInstance);
+
+  const auctionTerms = makeGovernedATerms(
+    { storageNode, marshaller },
+    chainTimerService,
+    priceAuthority,
+    reservePublicFacet,
+    {
+      ...params,
+      ElectorateInvitationAmount: electorateInvitationAmount,
+      TimerBrand: timerBrand,
+    },
+  );
+
+  const governorTerms = await deeplyFulfilledObject(
+    harden({
+      timer: chainTimerService,
+      governedContractInstallation: auctionInstallation,
+      governed: {
+        terms: auctionTerms,
+        issuerKeywordRecord: { Bid: stableIssuer },
+        storageNode,
+        marshaller,
+        label: 'auctioneer',
+      },
+    }),
+  );
+
+  /** @type {GovernorStartedInstallationKit<typeof auctionInstallation>} */
+  const governorStartResult = await E(zoe).startInstance(
+    contractGovernorInstallation,
+    undefined,
+    governorTerms,
+    harden({
+      electorateCreatorFacet,
+      governed: {
+        initialPoserInvitation,
+        storageNode,
+        marshaller,
+      },
+    }),
+    'auctioneer.governor',
+  );
+
+  const [governedInstance, governedCreatorFacet, governedPublicFacet] =
+    await Promise.all([
+      E(governorStartResult.creatorFacet).getInstance(),
+      E(governorStartResult.creatorFacet).getCreatorFacet(),
+      E(governorStartResult.creatorFacet).getPublicFacet(),
+    ]);
+
+  const allIssuers = await E(zoe).getIssuers(legacyKit.instance);
+  const { Bid: _istIssuer, ...auctionIssuers } = allIssuers;
+  await Promise.all(
+    Object.keys(auctionIssuers).map(kwd =>
+      E(governedCreatorFacet).addBrand(auctionIssuers[kwd], kwd),
+    ),
+  );
+
+  // don't overwrite auctioneerKit yet
+  newAuctioneerKit.resolve(
+    harden({
+      label: 'auctioneer',
+      creatorFacet: governedCreatorFacet,
+      adminFacet: governorStartResult.adminFacet,
+      publicFacet: governedPublicFacet,
+      instance: governedInstance,
+
+      governor: governorStartResult.instance,
+      governorCreatorFacet: governorStartResult.creatorFacet,
+      governorAdminFacet: governorStartResult.adminFacet,
+    }),
+  );
+  // don't replace auction instance yet.
+};
+
+export const ADD_AUCTION_MANIFEST = harden({
+  [addAuction.name]: {
+    consume: {
+      zoe: true,
+      board: true,
+      chainTimerService: true,
+      priceAuthority: true,
+      chainStorage: true,
+      economicCommitteeCreatorFacet: true,
+      auctioneerKit: true,
+    },
+    produce: {
+      newAuctioneerKit: true,
+    },
+    instance: {
+      consume: { reserve: true },
+    },
+    installation: {
+      consume: {
+        auctioneer: true,
+        contractGovernor: true,
+      },
+    },
+    issuer: {
+      consume: { [Stable.symbol]: true },
+    },
+  },
+});
+
+/* Add a new auction to a chain that already has one. */
+export const getManifestForAddAuction = async () => {
+  return { manifest: ADD_AUCTION_MANIFEST };
+};

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

@@ -1,11 +1,11 @@
-export function inviteCommitteeMembers({ consume: { namesByAddressAdmin, economicCommitteeCreatorFacet, ...consume }, }: import('./econ-behaviors.js').EconomyBootstrapPowers, { options: { voterAddresses } }: {
+export function inviteCommitteeMembers({ consume: { namesByAddressAdmin, economicCommitteeCreatorFacet, ...consume }, }: import("./econ-behaviors.js").EconomyBootstrapPowers, { options: { voterAddresses } }: {
     options: {
         voterAddresses: Record<string, string>;
     };
 }): Promise<void>;
-export function startEconCharter({ consume: { zoe }, produce: { econCharterKit }, installation: { consume: { binaryVoteCounter: counterP, econCommitteeCharter: installP }, }, instance: { produce: { econCommitteeCharter: instanceP }, }, }: import('./econ-behaviors.js').EconomyBootstrapPowers): Promise<void>;
-export function addGovernorsToEconCharter({ consume: { reserveKit, vaultFactoryKit, econCharterKit, auctioneerKit }, instance: { consume: { reserve, VaultFactory, auctioneer }, }, }: import('./econ-behaviors.js').EconomyBootstrapPowers): Promise<void>;
-export function inviteToEconCharter({ consume: { namesByAddressAdmin, econCharterKit } }: import('./econ-behaviors.js').EconomyBootstrapPowers, { options: { voterAddresses } }: {
+export function startEconCharter({ consume: { zoe }, produce: { econCharterKit }, installation: { consume: { binaryVoteCounter: counterP, econCommitteeCharter: installP }, }, instance: { produce: { econCommitteeCharter: instanceP }, }, }: import("./econ-behaviors.js").EconomyBootstrapPowers): Promise<void>;
+export function addGovernorsToEconCharter({ consume: { reserveKit, vaultFactoryKit, econCharterKit, auctioneerKit }, instance: { consume: { reserve, VaultFactory, auctioneer }, }, }: import("./econ-behaviors.js").EconomyBootstrapPowers): Promise<void>;
+export function inviteToEconCharter({ consume: { namesByAddressAdmin, econCharterKit } }: import("./econ-behaviors.js").EconomyBootstrapPowers, { options: { voterAddresses } }: {
     options: {
         voterAddresses: Record<string, string>;
     };

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

@@ -1,7 +1,7 @@
 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 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;