@agoric/inter-protocol 0.16.2-other-dev-1f26562.0 → 0.16.2-other-dev-3eb1a1d.0

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

@@ -0,0 +1,109 @@
+export function addAuction({ consume: { agoricNamesAdmin, auctioneerKit: legacyKitP, board, chainStorage, chainTimerService, economicCommitteeCreatorFacet: electorateCreatorFacet, 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: {
+        contractGovernorRef: {
+            bundleID: string;
+        };
+        contractGovernorInstallation: Installation;
+    };
+}): Promise<void>;
+export const ADD_AUCTION_MANIFEST: {
+    [x: string]: {
+        consume: {
+            agoricNamesAdmin: boolean;
+            auctioneerKit: boolean;
+            board: boolean;
+            chainStorage: boolean;
+            chainTimerService: boolean;
+            econCharterKit: boolean;
+            economicCommitteeCreatorFacet: boolean;
+            governedContractKits: boolean;
+            priceAuthority8400: boolean;
+            zoe: boolean;
+        };
+        produce: {
+            auctioneerKit: boolean;
+            auctionUpgradeNewInstance: boolean;
+            auctionUpgradeNewGovCreator: boolean;
+            newContractGovBundleId: boolean;
+        };
+        instance: {
+            consume: {
+                reserve: boolean;
+            };
+            produce: {
+                auctioneer: boolean;
+            };
+        };
+        installation: {
+            consume: {
+                contractGovernor: boolean;
+                auctioneer: boolean;
+            };
+        };
+        issuer: {
+            consume: {
+                IST: boolean;
+            };
+        };
+    };
+};
+export function getManifestForAddAuction({ restoreRef }: {
+    restoreRef: any;
+}, { auctioneerRef, contractGovernorRef }: any): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNamesAdmin: boolean;
+                auctioneerKit: boolean;
+                board: boolean;
+                chainStorage: boolean;
+                chainTimerService: boolean;
+                econCharterKit: boolean;
+                economicCommitteeCreatorFacet: boolean;
+                governedContractKits: boolean;
+                priceAuthority8400: boolean;
+                zoe: boolean;
+            };
+            produce: {
+                auctioneerKit: boolean;
+                auctionUpgradeNewInstance: boolean;
+                auctionUpgradeNewGovCreator: boolean;
+                newContractGovBundleId: boolean;
+            };
+            instance: {
+                consume: {
+                    reserve: boolean;
+                };
+                produce: {
+                    auctioneer: boolean;
+                };
+            };
+            installation: {
+                consume: {
+                    contractGovernor: boolean;
+                    auctioneer: boolean;
+                };
+            };
+            issuer: {
+                consume: {
+                    IST: boolean;
+                };
+            };
+        };
+    };
+    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

@@ -0,0 +1 @@
+{"version":3,"file":"add-auction.d.ts","sourceRoot":"","sources":["add-auction.js"],"names":[],"mappings":"AA0BO,kmBATI,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,iBA8KH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BG;AASI,yDAHJ;IAAmB,UAAU,EAArB,GAAG;CACX,0CAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBb;8BAtPY,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

@@ -0,0 +1,256 @@
+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);
+
+/**
+ * @typedef {PromiseSpaceOf<{
+ *   auctionUpgradeNewInstance: Instance;
+ *   auctionUpgradeNewGovCreator: any;
+ *   newContractGovBundleId: string;
+ * }>} interlockPowers
+ */
+
+/**
+ * @param {import('./econ-behaviors.js').EconomyBootstrapPowers &
+ *   interlockPowers} powers
+ * @param {{
+ *   options: {
+ *     contractGovernorRef: { bundleID: string };
+ *     contractGovernorInstallation: Installation;
+ *   };
+ * }} options
+ */
+export const addAuction = async (
+  {
+    consume: {
+      agoricNamesAdmin,
+      auctioneerKit: legacyKitP,
+      board,
+      chainStorage,
+      chainTimerService,
+      economicCommitteeCreatorFacet: electorateCreatorFacet,
+      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 },
+    },
+  },
+  {
+    options: {
+      contractGovernorRef: contractGovernorBundle,
+      contractGovernorInstallation,
+    },
+  },
+) => {
+  trace('addAuction start');
+  const STORAGE_PATH = 'auction';
+
+  const poserInvitationP = E(electorateCreatorFacet).getPoserInvitation();
+  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:
+  // 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,
+    priceAuthority8400,
+    reservePublicFacet,
+    {
+      ...params,
+      ElectorateInvitationAmount: electorateInvitationAmount,
+      TimerBrand: timerBrand,
+    },
+  );
+
+  const governorTerms = await deeplyFulfilledObject(
+    harden({
+      timer: chainTimerService,
+      governedContractInstallation: auctioneerInstallation,
+      governed: {
+        terms: auctionTerms,
+        issuerKeywordRecord: { Bid: stableIssuer },
+        storageNode,
+        marshaller,
+        label: 'auctioneer',
+      },
+    }),
+  );
+
+  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,
+    governorTerms,
+    harden({
+      electorateCreatorFacet,
+      governed: {
+        initialPoserInvitation,
+        storageNode,
+        marshaller,
+      },
+    }),
+    'auctioneer.governor',
+  );
+
+  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;
+  await Promise.all(
+    Object.keys(auctionIssuers).map(kwd =>
+      E(governedCreatorFacet).addBrand(
+        /** @type {Issuer<'nat'>} */ (auctionIssuers[kwd]),
+        kwd,
+      ),
+    ),
+  );
+
+  const kit = harden({
+    label: 'auctioneer',
+    creatorFacet: governedCreatorFacet,
+    adminFacet: governedAdminFacet,
+    publicFacet: governedPublicFacet,
+    instance: governedInstance,
+
+    governor: governorStartResult.instance,
+    governorCreatorFacet: governorStartResult.creatorFacet,
+    governorAdminFacet: governorStartResult.adminFacet,
+  });
+  produceAuctioneerKit.reset();
+  produceAuctioneerKit.resolve(kit);
+
+  auctionInstance.reset();
+  await auctionInstance.resolve(governedInstance);
+  // belt and suspenders; the above is supposed to also do this
+  await E(E(agoricNamesAdmin).lookupAdmin('instance')).update(
+    'auctioneer',
+    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({
+  [addAuction.name]: {
+    consume: {
+      agoricNamesAdmin: true,
+      auctioneerKit: true,
+      board: true,
+      chainStorage: true,
+      chainTimerService: true,
+      econCharterKit: true,
+      economicCommitteeCreatorFacet: 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, auctioneer: true },
+    },
+    issuer: {
+      consume: { [Stable.symbol]: true },
+    },
+  },
+});
+
+/**
+ * Add a new auction to a chain that already has one.
+ *
+ * @param {object} utils
+ * @param {any} utils.restoreRef
+ * @param {any} addAuctionOptions
+ */
+export const getManifestForAddAuction = async (
+  { restoreRef },
+  { auctioneerRef, contractGovernorRef },
+) => {
+  const contractGovernorInstallation = restoreRef(contractGovernorRef);
+  return {
+    manifest: ADD_AUCTION_MANIFEST,
+    // 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

@@ -0,0 +1,173 @@
+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 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: {
+        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":";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"}