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

package/src/provisionPoolKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provisionPoolKit.d.ts","sourceRoot":"","sources":["provisionPoolKit.js"],"names":[],"mappings":"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"}

package/src/provisionPoolKit.js

@@ -0,0 +1,463 @@
+// @ts-check
+import { AmountMath, BrandShape } from '@agoric/ertp';
+import { deeplyFulfilledObject } from '@agoric/internal';
+import { UnguardedHelperI } from '@agoric/internal/src/typeGuards.js';
+import {
+  observeIteration,
+  observeNotifier,
+  subscribeEach,
+} from '@agoric/notifier';
+import {
+  M,
+  makeScalarBigMapStore,
+  makeScalarBigSetStore,
+  prepareExoClassKit,
+} from '@agoric/vat-data';
+import { PowerFlags } from '@agoric/vats/src/walletFlags.js';
+import {
+  PublicTopicShape,
+  makeRecorderTopic,
+} from '@agoric/zoe/src/contractSupport/topics.js';
+import { InstanceHandleShape } from '@agoric/zoe/src/typeGuards.js';
+import { E } from '@endo/far';
+import { Far } from '@endo/marshal';
+
+const { details: X, quote: q, Fail } = assert;
+
+/**
+ * @import {ERef} from '@endo/far'
+ * @import {Amount} from '@agoric/ertp/src/types.js'
+ * @import {Bank, BankManager} from '@agoric/vats/src/vat-bank.js'
+ */
+
+/**
+ * @typedef {import('@agoric/zoe/src/zoeService/utils.js').Instance<
+ *   import('@agoric/inter-protocol/src/psm/psm.js').start
+ * >} PsmInstance
+ */
+
+/**
+ * @typedef {object} ProvisionPoolKitReferences
+ * @property {ERef<BankManager>} bankManager
+ * @property {ERef<import('@agoric/vats').NameAdmin>} namesByAddressAdmin
+ * @property {ERef<
+ *   import('@agoric/vats/src/core/startWalletFactory.js').WalletFactoryStartResult['creatorFacet']
+ * >} walletFactory
+ */
+
+/**
+ * @typedef {object} MetricsNotification Metrics naming scheme is that nouns are
+ *   present values and past-participles are accumulative.
+ * @property {bigint} walletsProvisioned count of new wallets provisioned
+ * @property {Amount<'nat'>} totalMintedProvided running sum of Minted provided
+ *   to new wallets
+ * @property {Amount<'nat'>} totalMintedConverted running sum of Minted ever
+ *   received by the contract from PSM
+ */
+
+/**
+ * Given attenuated access to the funding purse, handle requests to provision
+ * smart wallets.
+ *
+ * @param {(depositBank: ERef<Bank>) => Promise<void>} sendInitialPayment
+ * @param {() => void} onProvisioned
+ */
+export const makeBridgeProvisionTool = (sendInitialPayment, onProvisioned) => {
+  /** @param {ProvisionPoolKitReferences} refs */
+  const makeBridgeHandler = ({
+    bankManager,
+    namesByAddressAdmin,
+    walletFactory,
+  }) =>
+    Far('provisioningHandler', {
+      fromBridge: async obj => {
+        obj.type === 'PLEASE_PROVISION' ||
+          Fail`Unrecognized request ${obj.type}`;
+        console.info('PLEASE_PROVISION', obj);
+        const { address, powerFlags } = obj;
+        powerFlags.includes(PowerFlags.SMART_WALLET) ||
+          Fail`missing SMART_WALLET in powerFlags`;
+
+        const bank = E(bankManager).getBankForAddress(address);
+        // only proceed if we can provide funds
+        await sendInitialPayment(bank);
+
+        const [_, created] = await E(walletFactory).provideSmartWallet(
+          address,
+          bank,
+          namesByAddressAdmin,
+        );
+        if (created) {
+          onProvisioned();
+        }
+        console.info(created ? 'provisioned' : 're-provisioned', address);
+      },
+    });
+  return makeBridgeHandler;
+};
+
+/**
+ * @param {import('@agoric/vat-data').Baggage} baggage
+ * @param {{
+ *   makeRecorderKit: import('@agoric/zoe/src/contractSupport/recorder.js').MakeRecorderKit;
+ *   params: any;
+ *   poolBank: import('@endo/far').ERef<Bank>;
+ *   zcf: ZCF;
+ * }} powers
+ */
+export const prepareProvisionPoolKit = (
+  baggage,
+  { makeRecorderKit, params, poolBank, zcf },
+) => {
+  const zoe = zcf.getZoeService();
+
+  const makeProvisionPoolKitInternal = prepareExoClassKit(
+    baggage,
+    'ProvisionPoolKit',
+    {
+      machine: M.interface('ProvisionPoolKit machine', {
+        addRevivableAddresses: M.call(M.arrayOf(M.string())).returns(),
+        getWalletReviver: M.call().returns(
+          M.remotable('ProvisionPoolKit wallet reviver'),
+        ),
+        setReferences: M.callWhen({
+          bankManager: M.eref(M.remotable('bankManager')),
+          namesByAddressAdmin: M.eref(M.remotable('nameAdmin')),
+          walletFactory: M.eref(M.remotable('walletFactory')),
+        }).returns(),
+        makeHandler: M.call().returns(M.remotable('BridgeHandler')),
+        initPSM: M.call(BrandShape, InstanceHandleShape).returns(),
+      }),
+      walletReviver: M.interface('ProvisionPoolKit wallet reviver', {
+        reviveWallet: M.callWhen(M.string()).returns(
+          M.remotable('SmartWallet'),
+        ),
+        ackWallet: M.call(M.string()).returns(M.boolean()),
+      }),
+      helper: UnguardedHelperI,
+      public: M.interface('ProvisionPoolKit public', {
+        getPublicTopics: M.call().returns({ metrics: PublicTopicShape }),
+      }),
+    },
+    /**
+     * @param {object} opts
+     * @param {Purse<'nat'>} opts.fundPurse
+     * @param {Brand<'nat'>} opts.poolBrand
+     * @param {StorageNode} opts.metricsNode
+     */
+    ({ fundPurse, poolBrand, metricsNode }) => {
+      /** @type {import('@agoric/zoe/src/contractSupport/recorder.js').RecorderKit<MetricsNotification>} */
+      const metricsRecorderKit = makeRecorderKit(metricsNode);
+
+      /** @type {MapStore<Brand, PsmInstance>} */
+      const brandToPSM = makeScalarBigMapStore('brandToPSM', { durable: true });
+      const revivableAddresses = makeScalarBigSetStore('revivableAddresses', {
+        durable: true,
+        keyShape: M.string(),
+      });
+
+      /**
+       * to be set by `setReferences`
+       *
+       * @type {Partial<ProvisionPoolKitReferences>}
+       */
+      const references = {
+        bankManager: undefined,
+        namesByAddressAdmin: undefined,
+        walletFactory: undefined,
+      };
+
+      return {
+        brandToPSM,
+        fundPurse,
+        metricsRecorderKit,
+        poolBrand,
+        walletsProvisioned: 0n,
+        totalMintedProvided: AmountMath.makeEmpty(poolBrand),
+        totalMintedConverted: AmountMath.makeEmpty(poolBrand),
+        revivableAddresses,
+        ...references,
+      };
+    },
+    {
+      // aka "limitedCreatorFacet"
+      machine: {
+        /** @param {string[]} oldAddresses */
+        addRevivableAddresses(oldAddresses) {
+          console.log('revivableAddresses count', oldAddresses.length);
+          this.state.revivableAddresses.addAll(oldAddresses);
+        },
+        getWalletReviver() {
+          return this.facets.walletReviver;
+        },
+        /** @param {ProvisionPoolKitReferences} erefs */
+        async setReferences(erefs) {
+          const { bankManager, namesByAddressAdmin, walletFactory } = erefs;
+          const obj = harden({
+            bankManager,
+            namesByAddressAdmin,
+            walletFactory,
+          });
+          const refs = await deeplyFulfilledObject(obj);
+          Object.assign(this.state, refs);
+        },
+        makeHandler() {
+          const { bankManager, namesByAddressAdmin, walletFactory } =
+            this.state;
+          if (!bankManager || !namesByAddressAdmin || !walletFactory) {
+            throw Fail`must set references before handling requests`;
+          }
+          const { helper } = this.facets;
+          // a bit obtuse but leave for backwards compatibility with tests
+          const innerMaker = makeBridgeProvisionTool(
+            bank => helper.sendInitialPayment(bank),
+            () => helper.onProvisioned(),
+          );
+          return innerMaker({
+            bankManager,
+            namesByAddressAdmin,
+            walletFactory,
+          });
+        },
+        /**
+         * @param {Brand} brand
+         * @param {PsmInstance} instance
+         */
+        initPSM(brand, instance) {
+          const { brandToPSM } = this.state;
+          brandToPSM.init(brand, instance);
+        },
+      },
+      walletReviver: {
+        /** @param {string} address */
+        async reviveWallet(address) {
+          const {
+            revivableAddresses,
+            bankManager,
+            namesByAddressAdmin,
+            walletFactory,
+          } = this.state;
+          if (!bankManager || !namesByAddressAdmin || !walletFactory) {
+            throw Fail`must set references before handling requests`;
+          }
+          revivableAddresses.has(address) ||
+            Fail`non-revivable address ${address}`;
+          const bank = E(bankManager).getBankForAddress(address);
+          const [wallet, _created] = await E(walletFactory).provideSmartWallet(
+            address,
+            bank,
+            namesByAddressAdmin,
+          );
+          return wallet;
+        },
+        /**
+         * @param {string} address
+         * @returns {boolean} isRevive
+         */
+        ackWallet(address) {
+          const { revivableAddresses } = this.state;
+          if (!revivableAddresses.has(address)) {
+            return false;
+          }
+          revivableAddresses.delete(address);
+          return true;
+        },
+      },
+      helper: {
+        publishMetrics() {
+          const {
+            metricsRecorderKit,
+            walletsProvisioned,
+            totalMintedConverted,
+            totalMintedProvided,
+          } = this.state;
+          void metricsRecorderKit.recorder.write(
+            harden({
+              walletsProvisioned,
+              totalMintedProvided,
+              totalMintedConverted,
+            }),
+          );
+        },
+        onTrade(converted) {
+          const { state, facets } = this;
+          state.totalMintedConverted = AmountMath.add(
+            state.totalMintedConverted,
+            converted,
+          );
+          facets.helper.publishMetrics();
+        },
+        onSendFunds(provided) {
+          const { state, facets } = this;
+          state.totalMintedProvided = AmountMath.add(
+            state.totalMintedProvided,
+            provided,
+          );
+          facets.helper.publishMetrics();
+        },
+        onProvisioned() {
+          const { state, facets } = this;
+          state.walletsProvisioned += 1n;
+          facets.helper.publishMetrics();
+        },
+        /** @param {ERef<Bank>} destBank */
+        async sendInitialPayment(destBank) {
+          const {
+            facets: { helper },
+            state: { fundPurse, poolBrand },
+          } = this;
+          const perAccountInitialAmount = /** @type {Amount<'nat'>} */ (
+            params.getPerAccountInitialAmount()
+          );
+          const initialPmt = await E(fundPurse).withdraw(
+            perAccountInitialAmount,
+          );
+
+          const destPurse = E(destBank).getPurse(poolBrand);
+          return E(destPurse)
+            .deposit(initialPmt)
+            .then(amt => {
+              helper.onSendFunds(perAccountInitialAmount);
+              console.log('provisionPool sent', amt);
+            })
+            .catch(reason => {
+              console.error(X`initial deposit failed: ${q(reason)}`);
+              void E(fundPurse).deposit(initialPmt);
+              throw reason;
+            });
+        },
+        /**
+         * @param {object} [options]
+         * @param {MetricsNotification} [options.metrics]
+         */
+        start({ metrics } = {}) {
+          const {
+            state: { brandToPSM, poolBrand },
+            facets: { helper },
+          } = this;
+
+          // Must match. poolBrand is from durable state and the param is from
+          // the contract, so it technically can change between incarnations.
+          // That would be a severe bug.
+          AmountMath.coerce(poolBrand, params.getPerAccountInitialAmount());
+
+          void observeIteration(
+            subscribeEach(E(poolBank).getAssetSubscription()),
+            {
+              updateState: async desc => {
+                console.log('provisionPool notified of new asset', desc.brand);
+                await zcf.saveIssuer(desc.issuer, desc.issuerName);
+                /** @type {ERef<Purse>} */
+                const exchangePurse = E(poolBank).getPurse(desc.brand);
+                void observeNotifier(
+                  E(exchangePurse).getCurrentAmountNotifier(),
+                  {
+                    updateState: async amount => {
+                      console.log('provisionPool balance update', amount);
+                      if (
+                        AmountMath.isEmpty(amount) ||
+                        amount.brand === poolBrand
+                      ) {
+                        return;
+                      }
+                      if (!brandToPSM.has(desc.brand)) {
+                        console.error(
+                          'funds arrived but no PSM instance',
+                          desc.brand,
+                        );
+                        return;
+                      }
+                      const instance = brandToPSM.get(desc.brand);
+                      const payment = E(exchangePurse).withdraw(amount);
+                      await helper
+                        .swap(payment, amount, instance)
+                        .catch(async reason => {
+                          console.error(X`swap failed: ${reason}`);
+                          const resolvedPayment = await payment;
+                          return E(exchangePurse).deposit(resolvedPayment);
+                        });
+                    },
+                    fail: reason => console.error(reason),
+                  },
+                );
+              },
+            },
+          );
+
+          if (metrics) {
+            // Restore state.
+            // we publishMetrics() below
+            const {
+              walletsProvisioned,
+              totalMintedProvided,
+              totalMintedConverted,
+            } = metrics;
+            assert.typeof(walletsProvisioned, 'bigint');
+            AmountMath.coerce(poolBrand, totalMintedProvided);
+            AmountMath.coerce(poolBrand, totalMintedConverted);
+            Object.assign(this.state, {
+              walletsProvisioned,
+              totalMintedProvided,
+              totalMintedConverted,
+            });
+            helper.publishMetrics();
+          }
+        },
+        /**
+         * @param {ERef<Payment>} payIn
+         * @param {Amount} amount
+         * @param {PsmInstance} instance
+         */
+        async swap(payIn, amount, instance) {
+          const {
+            facets: { helper },
+            state: { fundPurse },
+          } = this;
+          const psmPub = E(zoe).getPublicFacet(instance);
+          const proposal = harden({ give: { In: amount } });
+          const invitation = E(psmPub).makeWantMintedInvitation();
+          const seat = E(zoe).offer(invitation, proposal, { In: payIn });
+          const payout = await E(seat).getPayout('Out');
+          const rxd = await E(fundPurse).deposit(payout);
+          helper.onTrade(rxd);
+          return rxd;
+        },
+      },
+      public: {
+        getPublicTopics() {
+          return {
+            metrics: makeRecorderTopic(
+              'Provision Pool metrics',
+              this.state.metricsRecorderKit,
+            ),
+          };
+        },
+      },
+    },
+    {
+      finish: ({ facets }) => {
+        facets.helper.publishMetrics();
+      },
+    },
+  );
+
+  /**
+   * Prepare synchronous values before passing to real Exo maker
+   *
+   * @param {object} opts
+   * @param {Brand<'nat'>} opts.poolBrand
+   * @param {ERef<StorageNode>} opts.storageNode
+   */
+  const makeProvisionPoolKit = async ({ poolBrand, storageNode }) => {
+    const fundPurse = await E(poolBank).getPurse(poolBrand);
+    const metricsNode = await E(storageNode).makeChildNode('metrics');
+
+    return makeProvisionPoolKitInternal({
+      fundPurse,
+      poolBrand,
+      metricsNode,
+    });
+  };
+
+  return makeProvisionPoolKit;
+};

package/src/psm/psm.d.ts

@@ -0,0 +1,122 @@
+/**
+ * @file The Parity Stability Module supports efficiently minting/burning a
+ *   stable token at a specified fixed ratio to a reference stable token, which
+ *   thereby acts as an anchor to provide additional stability. For flexible
+ *   economic policies, the fee percentage for trading into and out of the
+ *   stable token are specified separately.
+ */
+/**
+ * @typedef {object} MetricsNotification Metrics naming scheme is that nouns are
+ *   present values and past-participles are accumulative.
+ * @property {Amount<'nat'>} anchorPoolBalance amount of Anchor token available
+ *   to be swapped
+ * @property {Amount<'nat'>} mintedPoolBalance amount of Minted token
+ *   outstanding (the amount minted minus the amount burned).
+ * @property {Amount<'nat'>} feePoolBalance amount of Minted token fees
+ *   available to be collected
+ * @property {Amount<'nat'>} totalAnchorProvided running sum of Anchor ever
+ *   given by this contract
+ * @property {Amount<'nat'>} totalMintedProvided running sum of Minted ever
+ *   given by this contract
+ */
+/** @import {Baggage} from '@agoric/vat-data' */
+/** @type {ContractMeta} */
+export const meta: ContractMeta;
+export function start(zcf: ZCF<GovernanceTerms<{
+    GiveMintedFee: "ratio";
+    WantMintedFee: "ratio";
+    MintLimit: "amount";
+}> & {
+    anchorBrand: Brand<"nat">;
+    anchorPerMinted: Ratio;
+}>, privateArgs: {
+    feeMintAccess: FeeMintAccess;
+    initialPoserInvitation: Invitation;
+    storageNode: StorageNode;
+    marshaller: Marshaller;
+}, baggage: Baggage): Promise<{
+    creatorFacet: import("@endo/exo").Guarded<{
+        getParamMgrRetriever: () => {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                GiveMintedFee: "ratio";
+                MintLimit: "amount";
+                WantMintedFee: "ratio";
+            } & {
+                Electorate: "invitation";
+            }>;
+        } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+            get: () => import("@agoric/governance/src/contractGovernance/typedParamManager.js").TypedParamManager<{
+                GiveMintedFee: "ratio";
+                MintLimit: "amount";
+                WantMintedFee: "ratio";
+            } & {
+                Electorate: "invitation";
+            }>;
+        }>;
+        getInvitation: (name: any) => Promise<Invitation<unknown, undefined>>;
+        getLimitedCreatorFacet: () => import("@endo/exo").Guarded<{
+            getRewardAllocation(): Allocation;
+            makeCollectFeesInvitation(): Promise<Invitation<string, undefined>>;
+            makeRestoreMetricsInvitation(): Promise<Invitation<void, Omit<MetricsNotification, "anchorPoolBalance">>>;
+        }>;
+        getGovernedApis: () => globalThis.GovernedApis;
+        getGovernedApiNames: () => string[];
+        setOfferFilter: (strings: any) => Promise<void>;
+    }>;
+    publicFacet: import("@endo/exo").Guarded<{
+        getAmount: (name: string) => globalThis.Amount;
+        getBrand: (name: string) => globalThis.Brand;
+        getInstance: (name: string) => Instance;
+        getInstallation: (name: string) => Installation<any>;
+        getInvitationAmount: (name: string) => import("@agoric/ertp/src/types.js").SetAmount<InvitationDetails>;
+        getNat: (name: string) => bigint;
+        getRatio: (name: string) => Ratio;
+        getString: (name: string) => string;
+        getTimestamp: (name: string) => import("@agoric/time").TimestampRecord;
+        getRelativeTime: (name: string) => import("@agoric/time").RelativeTimeRecord;
+        getUnknown: (name: string) => any;
+        getSubscription: () => globalThis.StoredSubscription<globalThis.GovernanceSubscriptionState>;
+        getGovernedParams: () => globalThis.ERef<globalThis.ParamStateRecord>;
+        getMetrics(): globalThis.Subscriber<MetricsNotification>;
+        getPoolBalance(): import("@agoric/ertp/src/types.js").NatAmount;
+        getPublicTopics(): {
+            metrics: import("@agoric/zoe/src/contractSupport/topics.js").PublicTopic<MetricsNotification>;
+        };
+        makeWantMintedInvitation(): Promise<Invitation<void, undefined>>;
+        makeGiveMintedInvitation(): Promise<Invitation<void, undefined>>;
+    }>;
+}>;
+/**
+ * Metrics naming scheme is that nouns are
+ *   present values and past-participles are accumulative.
+ */
+export type MetricsNotification = {
+    /**
+     * amount of Anchor token available
+     * to be swapped
+     */
+    anchorPoolBalance: Amount<"nat">;
+    /**
+     * amount of Minted token
+     * outstanding (the amount minted minus the amount burned).
+     */
+    mintedPoolBalance: Amount<"nat">;
+    /**
+     * amount of Minted token fees
+     * available to be collected
+     */
+    feePoolBalance: Amount<"nat">;
+    /**
+     * running sum of Anchor ever
+     * given by this contract
+     */
+    totalAnchorProvided: Amount<"nat">;
+    /**
+     * running sum of Minted ever
+     * given by this contract
+     */
+    totalMintedProvided: Amount<"nat">;
+};
+export type PsmPublicFacet = Awaited<ReturnType<typeof start>>["publicFacet"];
+import type { Baggage } from '@agoric/vat-data';
+//# sourceMappingURL=psm.d.ts.map

package/src/psm/psm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psm.d.ts","sourceRoot":"","sources":["psm.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AAEH;;;;;;;;;;;;;GAaG;AAEH,gDAAgD;AAEhD,2BAA2B;AAC3B,mBADW,YAAY,CAkCrB;AAsBK,2BAlBI,GAAG,CACb,eAAmB,CAAC;IACpB,aAAmB,EAAE,OAAO,CAAC;IAC7B,aAAmB,EAAE,OAAO,CAAC;IAC7B,SAAe,EAAE,QAAQ,CAAC;CACrB,CAAC,GAAG;IACT,WAAiB,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IAChC,eAAqB,EAAE,KAAK,CAAC;CACxB,CACF,eACO;IACV,aAAiB,EAAE,aAAa,CAAC;IACjC,sBAA0B,EAAE,UAAU,CAAC;IACvC,WAAe,EAAE,WAAW,CAAC;IAC7B,UAAc,EAAE,UAAU,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuUH;;;;;;;;;;uBA1Ya,MAAM,CAAC,KAAK,CAAC;;;;;uBAEb,MAAM,CAAC,KAAK,CAAC;;;;;oBAEb,MAAM,CAAC,KAAK,CAAC;;;;;yBAEb,MAAM,CAAC,KAAK,CAAC;;;;;yBAEb,MAAM,CAAC,KAAK,CAAC;;6BAqYb,OAAO,CAAC,UAAU,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,aAAa,CAAC;6BAjYnC,kBAAkB"}