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

package/src/proposals/replace-fee-distributor.js

@@ -0,0 +1,195 @@
+import { deeplyFulfilledObject, makeTracer } from '@agoric/internal';
+import { Stable } from '@agoric/internal/src/tokens.js';
+import { makeScalarBigMapStore } from '@agoric/vat-data';
+import { getInterfaceOf, E } from '@endo/far';
+
+const trace = makeTracer('ReplaceFeeDistributer', true);
+
+/**
+ * Start the reward distributor.
+ *
+ * @param {import('./econ-behaviors').EconomyBootstrapPowers} powers
+ * @param {{
+ *   options: {
+ *     keywordShares: Record<string, bigint>;
+ *     collectionInterval: bigint;
+ *   };
+ * }} options
+ */
+export const replaceFeeDistributor = async (
+  {
+    consume: {
+      chainTimerService,
+      bankManager,
+      vaultFactoryKit,
+      periodicFeeCollectors,
+      reserveKit,
+      zoe,
+      contractKits: contractKitsP,
+    },
+    produce: {
+      feeDistributorKit,
+      periodicFeeCollectors: periodicFeeCollectorsP,
+    },
+    instance: {
+      produce: { feeDistributor: feeDistributorP },
+    },
+    installation: {
+      consume: { feeDistributor },
+    },
+    issuer: {
+      consume: { [Stable.symbol]: centralIssuerP },
+    },
+    brand: {
+      consume: { [Stable.symbol]: centralBrandP },
+    },
+  },
+  { options },
+) => {
+  trace('replaceFeeDistributer', options);
+
+  const { keywordShares, collectionInterval } = options;
+
+  const feeDistributorTerms = await deeplyFulfilledObject(
+    harden({
+      timerService: chainTimerService,
+      collectionInterval,
+      keywordShares,
+    }),
+  );
+  trace('feeDistributorTerms', feeDistributorTerms);
+
+  const [centralIssuer, centralBrand, contractKits] = await Promise.all([
+    centralIssuerP,
+    centralBrandP,
+    contractKitsP,
+  ]);
+
+  const rewardDistributorDepositFacet = await E(bankManager)
+    .getRewardDistributorDepositFacet(Stable.denom, {
+      issuer: centralIssuer,
+      brand: centralBrand,
+    })
+    .catch(e => {
+      console.error('Cannot create fee collector deposit facet', e);
+      return undefined;
+    });
+
+  /**
+   * @type {StartedInstanceKit<
+   *   typeof import('@agoric/inter-protocol/src/feeDistributor.js').start
+   * >}
+   */
+  const instanceKit = await E(zoe).startInstance(
+    feeDistributor,
+    { Fee: centralIssuer },
+    feeDistributorTerms,
+    undefined,
+    'feeDistributor',
+  );
+  await E(instanceKit.creatorFacet).setDestinations({
+    ...(rewardDistributorDepositFacet && {
+      RewardDistributor: E(
+        instanceKit.creatorFacet,
+      ).makeDepositFacetDestination(rewardDistributorDepositFacet),
+    }),
+    Reserve: E(instanceKit.creatorFacet).makeOfferDestination(
+      zoe,
+      'Collateral',
+      E.get(reserveKit).publicFacet,
+      'makeAddCollateralInvitation',
+    ),
+  });
+
+  trace('Clearing the old instance from bootstrap powers...');
+  feeDistributorKit.reset();
+  feeDistributorP.reset();
+
+  trace('Now introduce the new instance');
+  feeDistributorKit.resolve(
+    harden({ ...instanceKit, label: 'feeDistributor' }),
+  );
+  feeDistributorP.resolve(instanceKit.instance);
+
+  const periodicCollectors = await periodicFeeCollectors;
+  trace(
+    `Stop periodicCollectors of the old instance. Number of collectors: ${periodicCollectors.getSize()}`,
+  );
+  for await (const [key, collector] of periodicCollectors.entries()) {
+    trace('Getting debugName', key);
+    // @ts-expect-error incomplete PeriodicFeeCollector type
+    const debugName = await E(collector).getDebugName();
+    trace(`Stopping ${debugName}...`);
+    await E(collector).stop();
+  }
+  periodicFeeCollectorsP.reset();
+
+  trace('Old collectors cleared. Start creating and setting new ones.');
+
+  const collectorKit = {
+    vaultFactory: E.get(vaultFactoryKit).creatorFacet,
+  };
+  const newCollectorStore = makeScalarBigMapStore('periodicCollectors', {
+    durable: true,
+  });
+  await Promise.all(
+    Object.entries(collectorKit).map(async ([debugName, collectorFacet]) => {
+      const collector = E(instanceKit.creatorFacet).makeContractFeeCollector(
+        zoe,
+        collectorFacet,
+      );
+      const periodicCollector = await E(
+        instanceKit.creatorFacet,
+      ).startPeriodicCollection(debugName, collector);
+      newCollectorStore.init(periodicCollectors.getSize(), periodicCollector);
+    }),
+  );
+
+  trace('Write newCollectorStore in periodicFeeCollectors');
+  periodicFeeCollectorsP.resolve(newCollectorStore);
+
+  trace('Write to contractKits');
+  const label = getInterfaceOf(instanceKit.instance);
+  const kit = harden({ ...instanceKit, label });
+  contractKits.init(kit.instance, kit);
+
+  trace('Done.');
+};
+harden(replaceFeeDistributor);
+
+const t = 'replaceFeeDistributor';
+export const getManifestForReplaceFeeDistributor = async (
+  _,
+  feeDistributorOptions,
+) => ({
+  manifest: {
+    [replaceFeeDistributor.name]: {
+      consume: {
+        chainTimerService: t,
+        bankManager: t,
+        vaultFactoryKit: t,
+        periodicFeeCollectors: t,
+        reserveKit: t,
+        zoe: t,
+        contractKits: t,
+      },
+      produce: {
+        feeDistributorKit: t,
+        periodicFeeCollectors: t,
+      },
+      instance: {
+        produce: { feeDistributor: t },
+      },
+      installation: {
+        consume: { feeDistributor: t },
+      },
+      issuer: {
+        consume: { [Stable.symbol]: t },
+      },
+      brand: {
+        consume: { [Stable.symbol]: t },
+      },
+    },
+  },
+  options: { ...feeDistributorOptions },
+});

package/src/proposals/replace-scaledPriceAuthorities.d.ts

@@ -0,0 +1,30 @@
+export function replaceScaledPriceAuthority(powers: BootstrapPowers, { options }: {
+    options: object;
+}): Promise<void>;
+export function replaceScaledPriceAuthorities(powers: ChainBootstrapSpace & BootstrapPowers, { options }: {
+    options: {
+        scaledPARef: {
+            bundleID: string;
+        };
+    };
+}): Promise<void>;
+export function getManifestForReplaceScaledPriceAuthorities(_ign: any, upgradeSPAOptions: any): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNames: string;
+                priceAuthority: string;
+                startUpgradable: string;
+                zoe: string;
+                agoricNamesAdmin: string;
+                contractKits: string;
+                priceAuthorityAdmin: string;
+            };
+            instance: {
+                produce: string;
+            };
+        };
+    };
+    options: any;
+}>;
+//# sourceMappingURL=replace-scaledPriceAuthorities.d.ts.map

package/src/proposals/replace-scaledPriceAuthorities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-scaledPriceAuthorities.d.ts","sourceRoot":"","sources":["replace-scaledPriceAuthorities.js"],"names":[],"mappings":"AAaO,oDAJI,eAAe,eAEvB;IAAuB,OAAO,EAAtB,MAAM;CAChB,iBAeA;AAUM,sDAHI,mBAAmB,GAAG,eAAe,eACrC;IAAE,OAAO,EAAE;QAAE,WAAW,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAA;CAAE,iBA2D5D;AAGM;;;;;;;;;;;;;;;;;;GA0BL"}

package/src/proposals/replace-scaledPriceAuthorities.js

@@ -0,0 +1,124 @@
+import { makeTracer } from '@agoric/internal';
+import { E } from '@endo/far';
+
+import { startScaledPriceAuthority } from './addAssetToVault.js';
+import { scaledPriceFeedName } from './utils.js';
+
+const trace = makeTracer('replaceScaledPA', true);
+
+/**
+ * @param {BootstrapPowers} powers
+ * @param {object} config
+ * @param {object} config.options
+ */
+export const replaceScaledPriceAuthority = async (powers, { options }) => {
+  const {
+    instance: { produce: produceInstance },
+  } = powers;
+  const { issuerName } = options.interchainAssetOptions;
+
+  const spaKit = await startScaledPriceAuthority(powers, { options });
+
+  const label = scaledPriceFeedName(issuerName);
+  produceInstance[label].reset();
+
+  // publish into agoricNames. This must stay after registerPriceAuthority,
+  // which is called by startScaledPriceAuthority()
+  produceInstance[label].resolve(spaKit.instance);
+};
+
+/**
+ * Look up the existing assets known to auctions, and replace the corresponding
+ * scaledPriceAuthorities. The existing contracts will be left behind to be
+ * cleaned up later.
+ *
+ * @param {ChainBootstrapSpace & BootstrapPowers} powers
+ * @param {{ options: { scaledPARef: { bundleID: string } } }} options
+ */
+export const replaceScaledPriceAuthorities = async (powers, { options }) => {
+  trace('start');
+  const {
+    consume: {
+      agoricNamesAdmin,
+      agoricNames,
+      contractKits: contractKitsP,
+      zoe,
+    },
+  } = powers;
+
+  const { scaledPARef } = options;
+
+  const installationsAdmin = E(agoricNamesAdmin).lookupAdmin('installation');
+  const [spaInstallation, contractKits] = await Promise.all([
+    E(E(installationsAdmin).readonly()).lookup('scaledPriceAuthority'),
+    contractKitsP,
+  ]);
+
+  const bundleID = scaledPARef.bundleID;
+  if (scaledPARef && bundleID) {
+    await E.when(
+      E(zoe).installBundleID(bundleID),
+      installation =>
+        E(installationsAdmin).update('scaledPriceAuthority', installation),
+      err =>
+        console.error(
+          `🚨 failed to update scaledPriceAuthority installation`,
+          err,
+        ),
+    );
+    trace('installed scaledPriceAuthority bundle', bundleID);
+  }
+
+  // Ask Zoe for the installation for each kit's instance, and return all the
+  // kits where that matches the given installation.
+  async function maybeSPAKit(kit) {
+    const installation = await E(zoe).getInstallationForInstance(kit.instance);
+    return spaInstallation === installation ? [kit] : [];
+  }
+  const scaledPAKits = (
+    await Promise.all([...contractKits.values()].map(maybeSPAKit))
+  ).flat();
+
+  const namedBrands = await E(E(agoricNames).lookup('brand')).entries();
+
+  for (const kitEntry of scaledPAKits) {
+    const { instance } = kitEntry;
+    const terms = await E(powers.consume.zoe).getTerms(instance);
+    const { brand } = terms.scaleIn.denominator;
+    const entry = namedBrands.find(([_k, v]) => v === brand);
+    assert(entry, 'unable to find issuerName for ', brand);
+    const issuerName = entry[0];
+    await replaceScaledPriceAuthority(powers, {
+      options: { interchainAssetOptions: { issuerName } },
+    });
+  }
+};
+
+const t = 'replaceScaledPriceAuthority';
+export const getManifestForReplaceScaledPriceAuthorities = async (
+  _ign,
+  upgradeSPAOptions,
+) => ({
+  manifest: {
+    [replaceScaledPriceAuthorities.name]: {
+      consume: {
+        // //// Widely known  ////
+        agoricNames: t,
+        priceAuthority: t,
+        startUpgradable: t,
+        zoe: t,
+
+        // //// closely held, powerful ////
+        agoricNamesAdmin: t,
+        contractKits: t,
+        priceAuthorityAdmin: t,
+      },
+      instance: {
+        // This is a right to add/replace any instance. That we update only the
+        // relevant ones must be verified by inspection.
+        produce: t,
+      },
+    },
+  },
+  options: { ...upgradeSPAOptions },
+});

package/src/proposals/replaceElectorate.d.ts

@@ -0,0 +1,55 @@
+export function replaceAllElectorates(permittedPowers: EconomyBootstrapPowers & interlockPowers, config: {
+    options: {
+        committeeName: string;
+        voterAddresses: Record<string, string>;
+        highPrioritySendersConfig: {
+            addressesToAdd: string[];
+            addressesToRemove: string[];
+        };
+    };
+}): Promise<void>;
+export function getManifestForReplaceAllElectorates({ economicCommitteeRef: _economicCommitteeRef }: {
+    economicCommitteeRef: any;
+}, options: any): Promise<{
+    manifest: {
+        [x: string]: {
+            consume: {
+                auctionUpgradeNewGovCreator: boolean;
+                auctionUpgradeNewInstance: boolean;
+                psmKit: boolean;
+                governedContractKits: boolean;
+                chainStorage: boolean;
+                highPrioritySendersManager: boolean;
+                namesByAddressAdmin: boolean;
+                board: boolean;
+                startUpgradable: boolean;
+            };
+            produce: {
+                econCharterKit: boolean;
+                economicCommitteeKit: boolean;
+                economicCommitteeCreatorFacet: boolean;
+                auctionUpgradeNewGovCreator: boolean;
+            };
+            installation: {
+                consume: {
+                    committee: boolean;
+                    binaryVoteCounter: boolean;
+                    econCommitteeCharter: boolean;
+                };
+            };
+            instance: {
+                produce: {
+                    economicCommittee: boolean;
+                    econCommitteeCharter: boolean;
+                };
+            };
+        };
+    };
+    options: any;
+}>;
+export type interlockPowers = PromiseSpaceOf<{
+    auctionUpgradeNewInstance: Instance;
+    auctionUpgradeNewGovCreator: any;
+}>;
+import type { EconomyBootstrapPowers } from './econ-behaviors.js';
+//# sourceMappingURL=replaceElectorate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replaceElectorate.d.ts","sourceRoot":"","sources":["replaceElectorate.js"],"names":[],"mappings":"AAwZO,uDAlBI,sBAAsB,GAAG,eAAe,UAGxC;IACN,OAAO,EAAE;QACP,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACvC,yBAAyB,EAAE;YACzB,cAAc,EAAE,MAAM,EAAE,CAAC;YACzB,iBAAiB,EAAE,MAAM,EAAE,CAAC;SAC7B,CAAC;KACH,CAAC;CACH,GAGS,OAAO,CAAC,IAAI,CAAC,CAuEzB;AAIM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCL;8BApNW,cAAc,CAAC;IACvB,yBAAyB,EAAE,QAAQ,CAAC;IACpC,2BAA2B,EAAE,GAAG,CAAC;CAClC,CAAC;4CApSqC,qBAAqB"}