@agoric/inter-protocol 0.16.2-upgrade-14-dev-c8f9e7b.0 → 0.16.2-upgrade-16-fi-dev-8879538.0

package/src/proposals/add-auction.js

@@ -0,0 +1,181 @@
+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(
+        /** @type {Issuer<'nat'>} */ (auctionIssuers[kwd]),
+        kwd,
+      ),
+    ),
+  );
+
+  newAuctioneerKit.resolve(
+    // @ts-expect-error XXX governance types
+    harden({
+      label: 'auctioneer',
+      creatorFacet: governedCreatorFacet,
+      adminFacet: governorStartResult.adminFacet,
+      publicFacet: governedPublicFacet,
+      instance: governedInstance,
+
+      governor: governorStartResult.instance,
+      governorCreatorFacet: governorStartResult.creatorFacet,
+      governorAdminFacet: governorStartResult.adminFacet,
+    }),
+  );
+  // don't overwrite auctioneerKit or auction instance yet. Wait until
+  // upgrade-vault.js
+};
+
+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/addAssetToVault.d.ts

@@ -0,0 +1,160 @@
+export * from "./startPSM.js";
+export function publishInterchainAssetFromBoardId({ consume: { board, agoricNamesAdmin } }: BootstrapPowers, { options: { interchainAssetOptions } }: {
+    options: {
+        interchainAssetOptions: InterchainAssetOptions;
+    };
+}): Promise<[void, void]>;
+export function publishInterchainAssetFromBank({ consume: { bankManager, agoricNamesAdmin, reserveKit, startUpgradable }, installation: { consume: { mintHolder }, }, }: EconomyBootstrapPowers, { options: { interchainAssetOptions } }: {
+    options: {
+        interchainAssetOptions: InterchainAssetOptions;
+    };
+}): Promise<void>;
+export function registerScaledPriceAuthority({ consume: { agoricNamesAdmin, startUpgradable, priceAuthorityAdmin, priceAuthority, }, instance: { produce: produceInstance }, }: BootstrapPowers, { options: { interchainAssetOptions } }: {
+    options: {
+        interchainAssetOptions: InterchainAssetOptions;
+    };
+}): Promise<void>;
+export function addAssetToVault({ consume: { vaultFactoryKit, agoricNamesAdmin, auctioneerKit, chainTimerService, }, brand: { consume: { [Stable.symbol]: stableP }, }, instance: { consume: consumeInstance }, }: EconomyBootstrapPowers, { options: { debtLimitValue, interestRateValue, interchainAssetOptions, }, }: {
+    options: {
+        interchainAssetOptions: InterchainAssetOptions;
+        debtLimitValue: bigint | number | string;
+        interestRateValue: bigint;
+    };
+}): Promise<void>;
+export function getManifestForAddAssetToVault({ restoreRef }: {
+    restoreRef: any;
+}, { debtLimitValue, interestRateValue, interchainAssetOptions, scaledPriceAuthorityRef, }: {
+    debtLimitValue: any;
+    interestRateValue: any;
+    interchainAssetOptions: any;
+    scaledPriceAuthorityRef: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                board: boolean;
+                agoricNamesAdmin: boolean;
+                bankManager?: undefined;
+                reserveKit?: undefined;
+                startUpgradable?: undefined;
+                priceAuthorityAdmin?: undefined;
+                priceAuthority?: undefined;
+                auctioneerKit?: undefined;
+                vaultFactoryKit?: undefined;
+                chainTimerService?: undefined;
+            };
+            produce?: undefined;
+            installation?: undefined;
+            instance?: undefined;
+            brand?: undefined;
+        } | {
+            consume: {
+                bankManager: boolean;
+                agoricNamesAdmin: boolean;
+                reserveKit: boolean;
+                startUpgradable: boolean;
+                board?: undefined;
+                priceAuthorityAdmin?: undefined;
+                priceAuthority?: undefined;
+                auctioneerKit?: undefined;
+                vaultFactoryKit?: undefined;
+                chainTimerService?: undefined;
+            };
+            produce: {
+                bankMints: boolean;
+                vBankKits: boolean;
+            };
+            installation: {
+                consume: {
+                    mintHolder: boolean;
+                    scaledPriceAuthority?: undefined;
+                };
+            };
+            instance?: undefined;
+            brand?: undefined;
+        } | {
+            consume: {
+                agoricNamesAdmin: boolean;
+                startUpgradable: boolean;
+                priceAuthorityAdmin: boolean;
+                priceAuthority: boolean;
+                board?: undefined;
+                bankManager?: undefined;
+                reserveKit?: undefined;
+                auctioneerKit?: undefined;
+                vaultFactoryKit?: undefined;
+                chainTimerService?: undefined;
+            };
+            instance: {
+                produce: boolean;
+                consume?: undefined;
+            };
+            installation: {
+                consume: {
+                    scaledPriceAuthority: boolean;
+                    mintHolder?: undefined;
+                };
+            };
+            produce?: undefined;
+            brand?: undefined;
+        } | {
+            consume: {
+                auctioneerKit: string;
+                vaultFactoryKit: string;
+                agoricNamesAdmin: boolean;
+                chainTimerService: boolean;
+                board?: undefined;
+                bankManager?: undefined;
+                reserveKit?: undefined;
+                startUpgradable?: undefined;
+                priceAuthorityAdmin?: undefined;
+                priceAuthority?: undefined;
+            };
+            brand: {
+                consume: {
+                    IST: boolean;
+                };
+            };
+            instance: {
+                consume: boolean;
+                produce?: undefined;
+            };
+            produce?: undefined;
+            installation?: undefined;
+        };
+    };
+    installations: {
+        scaledPriceAuthority: any;
+    };
+    options: {
+        debtLimitValue: any;
+        interchainAssetOptions: any;
+        interestRateValue: any;
+    };
+};
+export type InterchainAssetOptions = {
+    issuerBoardId?: string | undefined;
+    denom?: string | undefined;
+    decimalPlaces?: number | undefined;
+    /**
+     * - used in regstering with reserve, vaultFactory
+     */
+    keyword: string;
+    /**
+     * - used in agoricNames for compatibility:
+     * defaults to `keyword` if not provided
+     */
+    issuerName?: string | undefined;
+    /**
+     * - defaults to `issuerName` if not provided
+     */
+    proposedName?: string | undefined;
+    /**
+     * - defaults to `issuerName` if not provided
+     */
+    oracleBrand?: string | undefined;
+    initialPrice?: number | undefined;
+};
+import type { EconomyBootstrapPowers } from './econ-behaviors.js';
+import { Stable } from '@agoric/internal/src/tokens.js';
+//# sourceMappingURL=addAssetToVault.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addAssetToVault.d.ts","sourceRoot":"","sources":["addAssetToVault.js"],"names":[],"mappings":";AA6CO,4FALI,eAAe;IAEA,OAAO;QACiB,sBAAsB,EAA7D,sBAAsB;;0BAuBhC;AAQM;IAHmB,OAAO;QACiB,sBAAsB,EAA7D,sBAAsB;;kBAoDhC;AAQM,gLALI,eAAe;IAEA,OAAO;QACiB,sBAAsB,EAA7D,sBAAsB;;kBA2GhC;AA+EM;IALmB,OAAO;QACiB,sBAAsB,EAA7D,sBAAsB;QACmB,cAAc,EAAvD,MAAM,GAAG,MAAM,GAAG,MAAM;QACD,iBAAiB,EAAxC,MAAM;;kBA0EhB;AAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8EN;;;;;;;;aAvba,MAAM;;;;;;;;;;;;;;;;4CAQsB,qBAAqB;uBA3BxC,gCAAgC"}