@agoric/fast-usdc 0.1.1-other-dev-3eb1a1d.0 → 0.1.1-upgrade-19-dev-c605745.0

package/src/fast-usdc.contract.js

@@ -1,41 +1,44 @@
 import { AssetKind } from '@agoric/ertp';
-import {
-  assertAllDefined,
-  deeplyFulfilledObject,
-  makeTracer,
-} from '@agoric/internal';
+import { makeTracer } from '@agoric/internal';
 import { observeIteration, subscribeEach } from '@agoric/notifier';
 import {
+  CosmosChainInfoShape,
+  DenomDetailShape,
+  DenomShape,
   OrchestrationPowersShape,
+  registerChainsAndAssets,
   withOrchestration,
 } from '@agoric/orchestration';
+import { makeZoeTools } from '@agoric/orchestration/src/utils/zoe-tools.js';
 import { provideSingleton } from '@agoric/zoe/src/contractSupport/durability.js';
 import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
-import { makeZoeTools } from '@agoric/orchestration/src/utils/zoe-tools.js';
-import { depositToSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js';
+import { Fail } from '@endo/errors';
 import { E } from '@endo/far';
-import { M, objectMap } from '@endo/patterns';
+import { M } from '@endo/patterns';
 import { prepareAdvancer } from './exos/advancer.js';
 import { prepareLiquidityPoolKit } from './exos/liquidity-pool.js';
 import { prepareSettler } from './exos/settler.js';
 import { prepareStatusManager } from './exos/status-manager.js';
 import { prepareTransactionFeedKit } from './exos/transaction-feed.js';
-import { defineInertInvitation } from './utils/zoe.js';
-import { FastUSDCTermsShape, FeeConfigShape } from './type-guards.js';
 import * as flows from './fast-usdc.flows.js';
+import { FastUSDCTermsShape, FeeConfigShape } from './type-guards.js';
 
 const trace = makeTracer('FastUsdc');
 
+const TXNS_NODE = 'txns';
+const FEE_NODE = 'feeConfig';
+const ADDRESSES_BAGGAGE_KEY = 'addresses';
+
 /**
- * @import {Denom} from '@agoric/orchestration';
  * @import {HostInterface} from '@agoric/async-flow';
- * @import {OrchestrationAccount} from '@agoric/orchestration';
+ * @import {ChainAddress, CosmosChainInfo, Denom, DenomDetail, OrchestrationAccount} from '@agoric/orchestration';
  * @import {OrchestrationPowers, OrchestrationTools} from '@agoric/orchestration/src/utils/start-helper.js';
- * @import {Vow} from '@agoric/vow';
+ * @import {Remote} from '@agoric/internal';
+ * @import {Marshaller, StorageNode} from '@agoric/internal/src/lib-chainStorage.js'
  * @import {Zone} from '@agoric/zone';
+ * @import {OperatorOfferResult} from './exos/transaction-feed.js';
  * @import {OperatorKit} from './exos/operator-kit.js';
- * @import {CctpTxEvidence, FeeConfig} from './types.js';
- * @import {RepayAmountKWR, RepayPaymentKWR} from './exos/liquidity-pool.js';
+ * @import {CctpTxEvidence, ContractRecord, FeeConfig} from './types.js';
  */
 
 /**
@@ -51,17 +54,43 @@ export const meta = {
   privateArgsShape: {
     // @ts-expect-error TypedPattern not recognized as record
     ...OrchestrationPowersShape,
+    assetInfo: M.arrayOf([DenomShape, DenomDetailShape]),
+    chainInfo: M.recordOf(M.string(), CosmosChainInfoShape),
     feeConfig: FeeConfigShape,
     marshaller: M.remotable(),
+    poolMetricsNode: M.remotable(),
   },
 };
 harden(meta);
 
+/**
+ * @param {Remote<StorageNode>} node
+ * @param {ERef<Marshaller>} marshaller
+ * @param {FeeConfig} feeConfig
+ */
+const publishFeeConfig = async (node, marshaller, feeConfig) => {
+  const feeNode = E(node).makeChildNode(FEE_NODE);
+  const value = await E(marshaller).toCapData(feeConfig);
+  return E(feeNode).setValue(JSON.stringify(value));
+};
+
+/**
+ * @param {Remote<StorageNode>} contractNode
+ * @param {ContractRecord} addresses
+ */
+const publishAddresses = (contractNode, addresses) => {
+  return E(contractNode).setValue(JSON.stringify(addresses));
+};
+
 /**
  * @param {ZCF<FastUsdcTerms>} zcf
  * @param {OrchestrationPowers & {
- *   marshaller: Marshaller;
+ *   assetInfo: [Denom, DenomDetail & { brandKey?: string}][];
+ *   chainInfo: Record<string, CosmosChainInfo>;
  *   feeConfig: FeeConfig;
+ *   marshaller: Marshaller;
+ *   poolMetricsNode: Remote<StorageNode>;
+ *   storageNode: Remote<StorageNode>;
  * }} privateArgs
  * @param {Zone} zone
  * @param {OrchestrationTools} tools
@@ -71,19 +100,36 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
   const terms = zcf.getTerms();
   assert('USDC' in terms.brands, 'no USDC brand');
   assert('usdcDenom' in terms, 'no usdcDenom');
-  const { feeConfig, marshaller } = privateArgs;
+
+  const { feeConfig, marshaller, storageNode } = privateArgs;
   const { makeRecorderKit } = prepareRecorderKitMakers(
     zone.mapStore('vstorage'),
     marshaller,
   );
-  const statusManager = prepareStatusManager(zone);
-  const makeSettler = prepareSettler(zone, { statusManager });
-  const { chainHub, orchestrateAll, vowTools } = tools;
-  const { localTransfer } = makeZoeTools(zcf, vowTools);
+
+  const statusManager = prepareStatusManager(
+    zone,
+    E(storageNode).makeChildNode(TXNS_NODE),
+    { marshaller },
+  );
+
+  const { USDC } = terms.brands;
+  const { withdrawToSeat } = tools.zoeTools;
+  const { baggage, chainHub, orchestrateAll, vowTools } = tools;
+  const makeSettler = prepareSettler(zone, {
+    statusManager,
+    USDC,
+    withdrawToSeat,
+    feeConfig,
+    vowTools: tools.vowTools,
+    zcf,
+    chainHub,
+  });
+
+  const zoeTools = makeZoeTools(zcf, vowTools);
   const makeAdvancer = prepareAdvancer(zone, {
     chainHub,
     feeConfig,
-    localTransfer,
     usdc: harden({
       brand: terms.brands.USDC,
       denom: terms.usdcDenom,
@@ -91,9 +137,11 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
     statusManager,
     vowTools,
     zcf,
+    zoeTools,
   });
+
   const makeFeedKit = prepareTransactionFeedKit(zone, zcf);
-  assertAllDefined({ makeFeedKit, makeAdvancer, makeSettler, statusManager });
+
   const makeLiquidityPoolKit = prepareLiquidityPoolKit(
     zone,
     zcf,
@@ -101,66 +149,57 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
     { makeRecorderKit },
   );
 
-  const makeTestInvitation = defineInertInvitation(
-    zcf,
-    'test of forcing evidence',
-  );
-
-  const { makeLocalAccount } = orchestrateAll(flows, {});
+  const { makeLocalAccount, makeNobleAccount } = orchestrateAll(flows, {});
 
   const creatorFacet = zone.exo('Fast USDC Creator', undefined, {
-    /** @type {(operatorId: string) => Promise<Invitation<OperatorKit>>} */
+    /** @type {(operatorId: string) => Promise<Invitation<OperatorOfferResult>>} */
     async makeOperatorInvitation(operatorId) {
-      // eslint-disable-next-line no-use-before-define
       return feedKit.creator.makeOperatorInvitation(operatorId);
     },
-    /**
-     * @param {{ USDC: Amount<'nat'>}} amounts
-     */
-    testBorrow(amounts) {
-      console.log('🚧🚧 UNTIL: borrow is integrated (#10388) 🚧🚧', amounts);
-      const { zcfSeat: tmpAssetManagerSeat } = zcf.makeEmptySeatKit();
-      poolKit.borrower.borrow(tmpAssetManagerSeat, amounts);
-      return tmpAssetManagerSeat.getCurrentAllocation();
+    /** @type {(operatorId: string) => void} */
+    removeOperator(operatorId) {
+      return feedKit.creator.removeOperator(operatorId);
+    },
+    async getContractFeeBalance() {
+      return poolKit.feeRecipient.getContractFeeBalance();
+    },
+    /** @type {() => Promise<Invitation<unknown>>} */
+    async makeWithdrawFeesInvitation() {
+      return poolKit.feeRecipient.makeWithdrawFeesInvitation();
     },
-    /**
-     *
-     * @param {RepayAmountKWR} amounts
-     * @param {RepayPaymentKWR} payments
-     * @returns {Promise<AmountKeywordRecord>}
-     */
-    async testRepay(amounts, payments) {
-      console.log('🚧🚧 UNTIL: repay is integrated (#10388) 🚧🚧', amounts);
-      const { zcfSeat: tmpAssetManagerSeat } = zcf.makeEmptySeatKit();
-      await depositToSeat(
-        zcf,
-        tmpAssetManagerSeat,
-        await deeplyFulfilledObject(
-          objectMap(payments, pmt => E(terms.issuers.USDC).getAmountOf(pmt)),
-        ),
-        payments,
+    async connectToNoble() {
+      return vowTools.when(nobleAccountV, nobleAccount => {
+        trace('nobleAccount', nobleAccount);
+        return vowTools.when(
+          E(nobleAccount).getAddress(),
+          intermediateRecipient => {
+            trace('intermediateRecipient', intermediateRecipient);
+            advancer.setIntermediateRecipient(intermediateRecipient);
+            settlerKit.creator.setIntermediateRecipient(intermediateRecipient);
+            return intermediateRecipient;
+          },
+        );
+      });
+    },
+    async publishAddresses() {
+      !baggage.has(ADDRESSES_BAGGAGE_KEY) || Fail`Addresses already published`;
+      const [poolAccountAddress] = await vowTools.when(
+        vowTools.all([E(poolAccount).getAddress()]),
       );
-      poolKit.repayer.repay(tmpAssetManagerSeat, amounts);
-      return tmpAssetManagerSeat.getCurrentAllocation();
+      const addresses = harden({
+        poolAccount: poolAccountAddress.value,
+        settlementAccount: settlementAddress.value,
+      });
+      baggage.init(ADDRESSES_BAGGAGE_KEY, addresses);
+      await publishAddresses(storageNode, addresses);
+      return addresses;
+    },
+    deleteCompletedTxs() {
+      return statusManager.deleteCompletedTxs();
     },
   });
 
   const publicFacet = zone.exo('Fast USDC Public', undefined, {
-    // XXX to be removed before production
-    /**
-     * NB: Any caller with access to this invitation maker has the ability to
-     * force handling of evidence.
-     *
-     * Provide an API call in the form of an invitation maker, so that the
-     * capability is available in the smart-wallet bridge during UI testing.
-     *
-     * @param {CctpTxEvidence} evidence
-     */
-    makeTestPushInvitation(evidence) {
-      // eslint-disable-next-line no-use-before-define
-      void advancer.handleTransactionEvent(evidence);
-      return makeTestInvitation();
-    },
     makeDepositInvitation() {
       return poolKit.public.makeDepositInvitation();
     },
@@ -170,6 +209,13 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
     getPublicTopics() {
       return poolKit.public.getPublicTopics();
     },
+    getStaticInfo() {
+      baggage.has(ADDRESSES_BAGGAGE_KEY) ||
+        Fail`no addresses. creator must 'publishAddresses' first`;
+      return harden({
+        [ADDRESSES_BAGGAGE_KEY]: baggage.get(ADDRESSES_BAGGAGE_KEY),
+      });
+    },
   });
 
   // ^^^ Define all kinds above this line. Keep remote calls below. vvv
@@ -185,6 +231,8 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
   // So we use zone.exoClassKit above to define the liquidity pool kind
   // and pass the shareMint into the maker / init function.
 
+  void publishFeeConfig(storageNode, marshaller, feeConfig);
+
   const shareMint = await provideSingleton(
     zone.mapStore('mint'),
     'PoolShare',
@@ -195,37 +243,70 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
   );
 
   const poolKit = zone.makeOnce('Liquidity Pool kit', () =>
-    makeLiquidityPoolKit(shareMint, privateArgs.storageNode),
+    makeLiquidityPoolKit(shareMint, privateArgs.poolMetricsNode),
   );
 
+  /** Chain, connection, and asset info can only be registered once */
+  const firstIncarnationKey = 'firstIncarnationKey';
+  if (!baggage.has(firstIncarnationKey)) {
+    baggage.init(firstIncarnationKey, true);
+    registerChainsAndAssets(
+      chainHub,
+      terms.brands,
+      privateArgs.chainInfo,
+      privateArgs.assetInfo,
+    );
+  }
+
+  const nobleAccountV = zone.makeOnce('NobleAccount', () => makeNobleAccount());
+
   const feedKit = zone.makeOnce('Feed Kit', () => makeFeedKit());
 
-  const poolAccountV =
-    // cast to HostInterface
-    /** @type { Vow<HostInterface<OrchestrationAccount<{chainId: 'agoric';}>>>} */ (
-      /** @type {unknown}*/ (
-        zone.makeOnce('Pool Local Orch Account', () => makeLocalAccount())
-      )
-    );
-  const poolAccount = await vowTools.when(poolAccountV);
+  const poolAccountV = zone.makeOnce('PoolAccount', () => makeLocalAccount());
+  const settleAccountV = zone.makeOnce('SettleAccount', () =>
+    makeLocalAccount(),
+  );
+  // when() is OK here since this clearly resolves promptly.
+  /** @type {[HostInterface<OrchestrationAccount<{chainId: 'agoric-3';}>>, HostInterface<OrchestrationAccount<{chainId: 'agoric-3';}>>]} */
+  const [poolAccount, settlementAccount] = await vowTools.when(
+    vowTools.all([poolAccountV, settleAccountV]),
+  );
+  trace('settlementAccount', settlementAccount);
+  trace('poolAccount', poolAccount);
+  const settlementAddress = await E(settlementAccount).getAddress();
+  trace('settlementAddress', settlementAddress);
+
+  const [_agoric, _noble, agToNoble] = await vowTools.when(
+    chainHub.getChainsAndConnection('agoric', 'noble'),
+  );
+  const settlerKit = makeSettler({
+    repayer: poolKit.repayer,
+    sourceChannel: agToNoble.transferChannel.counterPartyChannelId,
+    remoteDenom: 'uusdc',
+    settlementAccount,
+  });
 
   const advancer = zone.makeOnce('Advancer', () =>
     makeAdvancer({
-      borrowerFacet: poolKit.borrower,
+      borrower: poolKit.borrower,
+      notifier: settlerKit.notifier,
       poolAccount,
+      settlementAddress,
     }),
   );
   // Connect evidence stream to advancer
   void observeIteration(subscribeEach(feedKit.public.getEvidenceSubscriber()), {
-    updateState(evidence) {
+    updateState(evidenceWithRisk) {
       try {
-        void advancer.handleTransactionEvent(evidence);
+        void advancer.handleTransactionEvent(evidenceWithRisk);
       } catch (err) {
         trace('🚨 Error handling transaction event', err);
       }
     },
   });
 
+  await settlerKit.creator.monitorMintingDeposits();
+
   return harden({ creatorFacet, publicFacet });
 };
 harden(contract);

package/src/fast-usdc.flows.js

@@ -11,3 +11,13 @@ export const makeLocalAccount = async orch => {
   return agoricChain.makeAccount();
 };
 harden(makeLocalAccount);
+
+/**
+ * @satisfies {OrchestrationFlow}
+ * @param {Orchestrator} orch
+ */
+export const makeNobleAccount = async orch => {
+  const nobleChain = await orch.getChain('noble');
+  return nobleChain.makeAccount();
+};
+harden(makeNobleAccount);

package/src/main.js

@@ -0,0 +1 @@
+export * from './types.js';

package/src/pool-share-math.js

@@ -7,9 +7,11 @@ import {
 } from '@agoric/zoe/src/contractSupport/ratio.js';
 import { Fail, q } from '@endo/errors';
 
-const { getValue, add, isEmpty, isEqual, isGTE, subtract } = AmountMath;
+const { keys } = Object;
+const { add, isEmpty, isEqual, isGTE, make, makeEmpty, subtract } = AmountMath;
 
 /**
+ * @import {Amount, Brand, DepositFacet, NatValue, Payment} from '@agoric/ertp';
  * @import {PoolStats} from './types';
  * @import {RepayAmountKWR} from './exos/liquidity-pool';
  */
@@ -17,8 +19,7 @@ const { getValue, add, isEmpty, isEqual, isGTE, subtract } = AmountMath;
 /**
  * Invariant: shareWorth is the pool balance divided by shares outstanding.
  *
- * Use `makeParity(make(USDC, epsilon), PoolShares)` for an initial
- * value, for some negligible `epsilon` such as 1n.
+ * Use `makeParity(USDC, PoolShares)` for an initial value.
  *
  * @typedef {Ratio} ShareWorth
  */
@@ -26,23 +27,26 @@ const { getValue, add, isEmpty, isEqual, isGTE, subtract } = AmountMath;
 /**
  * Make a 1-to-1 ratio between amounts of 2 brands.
  *
- * @param {Amount<'nat'>} numerator
+ * @param {Brand<'nat'>} numeratorBrand
  * @param {Brand<'nat'>} denominatorBrand
  */
-export const makeParity = (numerator, denominatorBrand) => {
-  const value = getValue(numerator.brand, numerator);
-  return makeRatio(value, numerator.brand, value, denominatorBrand);
+export const makeParity = (numeratorBrand, denominatorBrand) => {
+  const dust = 1n;
+  return makeRatio(dust, numeratorBrand, dust, denominatorBrand);
 };
 
 /**
  * @typedef {{
  *   deposit: {
  *     give: { USDC: Amount<'nat'> },
- *     want?: { PoolShare: Amount<'nat'> }
+ *     want: { PoolShare: Amount<'nat'> }
  *   },
  *   withdraw: {
  *     give: { PoolShare: Amount<'nat'> }
  *     want: { USDC: Amount<'nat'> },
+ *   },
+ *   withdrawFees: {
+ *     want: { USDC: Amount<'nat'> }
  *   }
  * }} USDCProposalShapes
  */
@@ -91,14 +95,54 @@ export const depositCalc = (shareWorth, { give, want }) => {
   });
 };
 
+/**
+ * Verifies that the total pool balance (unencumbered + encumbered) matches the
+ * shareWorth numerator. The total pool balance consists of:
+ * 1. unencumbered balance - USDC available in the pool for borrowing
+ * 2. encumbered balance - USDC currently lent out
+ *
+ * A negligible `dust` amount is used to initialize shareWorth with a non-zero
+ * denominator. It must remain in the pool at all times.
+ *
+ * @param {Allocation} poolAlloc
+ * @param {ShareWorth} shareWorth
+ * @param {Amount<'nat'>} encumberedBalance
+ */
+export const checkPoolBalance = (poolAlloc, shareWorth, encumberedBalance) => {
+  const { brand: usdcBrand } = encumberedBalance;
+  const unencumberedBalance = poolAlloc.USDC || makeEmpty(usdcBrand);
+  const kwds = keys(poolAlloc);
+  kwds.length === 0 ||
+    (kwds.length === 1 && kwds[0] === 'USDC') ||
+    Fail`unexpected pool allocations: ${poolAlloc}`;
+  const dust = make(usdcBrand, 1n);
+  const grossBalance = add(add(unencumberedBalance, dust), encumberedBalance);
+  isEqual(grossBalance, shareWorth.numerator) ||
+    Fail`🚨 pool balance ${q(unencumberedBalance)} and encumbered balance ${q(encumberedBalance)} inconsistent with shareWorth ${q(shareWorth)}`;
+  return harden({ unencumberedBalance, grossBalance });
+};
+
 /**
  * Compute payout from a withdraw proposal, along with updated shareWorth
  *
  * @param {ShareWorth} shareWorth
  * @param {USDCProposalShapes['withdraw']} proposal
+ * @param {Allocation} poolAlloc
+ * @param {Amount<'nat'>} [encumberedBalance]
  * @returns {{ shareWorth: ShareWorth, payouts: { USDC: Amount<'nat'> }}}
  */
-export const withdrawCalc = (shareWorth, { give, want }) => {
+export const withdrawCalc = (
+  shareWorth,
+  { give, want },
+  poolAlloc,
+  encumberedBalance = makeEmpty(shareWorth.numerator.brand),
+) => {
+  const { unencumberedBalance } = checkPoolBalance(
+    poolAlloc,
+    shareWorth,
+    encumberedBalance,
+  );
+
   assert(!isEmpty(give.PoolShare));
   assert(!isEmpty(want.USDC));
 
@@ -108,6 +152,8 @@ export const withdrawCalc = (shareWorth, { give, want }) => {
   const { denominator: sharesOutstanding, numerator: poolBalance } = shareWorth;
   !isGTE(want.USDC, poolBalance) ||
     Fail`cannot withdraw ${q(want.USDC)}; only ${q(poolBalance)} in pool`;
+  isGTE(unencumberedBalance, want.USDC) ||
+    Fail`cannot withdraw ${q(want.USDC)}; ${q(encumberedBalance)} is in use; stand by for pool to return to ${q(poolBalance)}`;
   const balancePost = subtract(poolBalance, payout);
   // giving more shares than are outstanding is impossible,
   // so it's not worth a custom diagnostic. subtract will fail