@agoric/fast-usdc 0.2.0-u18a.0 → 0.2.0-u19.1

package/src/exos/advancer.js

@@ -16,13 +16,14 @@ import { makeFeeTools } from '../utils/fees.js';
 
 /**
  * @import {HostInterface} from '@agoric/async-flow';
+ * @import {Amount, Brand} from '@agoric/ertp';
  * @import {TypedPattern} from '@agoric/internal'
  * @import {NatAmount} from '@agoric/ertp';
  * @import {ChainAddress, ChainHub, Denom, OrchestrationAccount} from '@agoric/orchestration';
  * @import {ZoeTools} from '@agoric/orchestration/src/utils/zoe-tools.js';
  * @import {VowTools} from '@agoric/vow';
  * @import {Zone} from '@agoric/zone';
- * @import {CctpTxEvidence, AddressHook, EvmHash, FeeConfig, LogFn, NobleAddress, EvidenceWithRisk} from '../types.js';
+ * @import {AddressHook, EvmHash, FeeConfig, LogFn, NobleAddress, EvidenceWithRisk} from '../types.js';
  * @import {StatusManager} from './status-manager.js';
  * @import {LiquidityPoolKit} from './liquidity-pool.js';
  */
@@ -31,12 +32,12 @@ import { makeFeeTools } from '../utils/fees.js';
  * @typedef {{
  *  chainHub: ChainHub;
  *  feeConfig: FeeConfig;
- *  localTransfer: ZoeTools['localTransfer'];
  *  log?: LogFn;
  *  statusManager: StatusManager;
  *  usdc: { brand: Brand<'nat'>; denom: Denom; };
  *  vowTools: VowTools;
  *  zcf: ZCF;
+ *  zoeTools: ZoeTools;
  * }} AdvancerKitPowers
  */
 
@@ -63,12 +64,21 @@ const AdvancerKitI = harden({
     onRejected: M.call(M.error(), AdvancerVowCtxShape).returns(),
   }),
   transferHandler: M.interface('TransferHandlerI', {
-    // TODO confirm undefined, and not bigint (sequence)
     onFulfilled: M.call(M.undefined(), AdvancerVowCtxShape).returns(
       M.undefined(),
     ),
     onRejected: M.call(M.error(), AdvancerVowCtxShape).returns(M.undefined()),
   }),
+  withdrawHandler: M.interface('WithdrawHandlerI', {
+    onFulfilled: M.call(M.undefined(), {
+      advanceAmount: AnyNatAmountShape,
+      tmpReturnSeat: M.remotable(),
+    }).returns(M.undefined()),
+    onRejected: M.call(M.error(), {
+      advanceAmount: AnyNatAmountShape,
+      tmpReturnSeat: M.remotable(),
+    }).returns(M.undefined()),
+  }),
 });
 
 /**
@@ -81,6 +91,14 @@ const AdvancerKitI = harden({
  * }} AdvancerVowCtx
  */
 
+export const stateShape = harden({
+  notifier: M.remotable(),
+  borrower: M.remotable(),
+  poolAccount: M.remotable(),
+  intermediateRecipient: M.opt(ChainAddressShape),
+  settlementAddress: M.opt(ChainAddressShape),
+});
+
 /**
  * @param {Zone} zone
  * @param {AdvancerKitPowers} caps
@@ -90,12 +108,12 @@ export const prepareAdvancerKit = (
   {
     chainHub,
     feeConfig,
-    localTransfer,
     log = makeTracer('Advancer', true),
     statusManager,
     usdc,
     vowTools: { watch, when },
     zcf,
+    zoeTools: { localTransfer, withdrawToSeat },
   },
 ) => {
   assertAllDefined({
@@ -114,8 +132,8 @@ export const prepareAdvancerKit = (
     AdvancerKitI,
     /**
      * @param {{
-     *   notifyFacet: import('./settler.js').SettlerKit['notify'];
-     *   borrowerFacet: LiquidityPoolKit['borrower'];
+     *   notifier: import('./settler.js').SettlerKit['notifier'];
+     *   borrower: LiquidityPoolKit['borrower'];
      *   poolAccount: HostInterface<OrchestrationAccount<{chainId: 'agoric'}>>;
      *   settlementAddress: ChainAddress;
      *   intermediateRecipient?: ChainAddress;
@@ -152,9 +170,7 @@ export const prepareAdvancerKit = (
               statusManager.skipAdvance(evidence, risk.risksIdentified);
               return;
             }
-
-            const { borrowerFacet, poolAccount, settlementAddress } =
-              this.state;
+            const { settlementAddress } = this.state;
             const { recipientAddress } = evidence.aux;
             const decoded = decodeAddressHook(recipientAddress);
             mustMatch(decoded, AddressHookShape);
@@ -167,12 +183,20 @@ export const prepareAdvancerKit = (
             const destination = chainHub.makeChainAddress(EUD);
 
             const fullAmount = toAmount(evidence.tx.amount);
+            const { borrower, notifier, poolAccount } = this.state;
+            // do not advance if we've already received a mint/settlement
+            const mintedEarly = notifier.checkMintedEarly(
+              evidence,
+              destination,
+            );
+            if (mintedEarly) return;
+
             // throws if requested does not exceed fees
             const advanceAmount = feeTools.calculateAdvance(fullAmount);
 
             const { zcfSeat: tmpSeat } = zcf.makeEmptySeatKit();
             // throws if the pool has insufficient funds
-            borrowerFacet.borrow(tmpSeat, advanceAmount);
+            borrower.borrow(tmpSeat, advanceAmount);
 
             // this cannot throw since `.isSeen()` is called in the same turn
             statusManager.advance(evidence);
@@ -193,7 +217,7 @@ export const prepareAdvancerKit = (
             });
           } catch (error) {
             log('Advancer error:', error);
-            statusManager.observe(evidence);
+            statusManager.skipAdvance(evidence, [error.message]);
           }
         },
         /** @param {ChainAddress} intermediateRecipient */
@@ -207,14 +231,21 @@ export const prepareAdvancerKit = (
          * @param {AdvancerVowCtx & { tmpSeat: ZCFSeat }} ctx
          */
         onFulfilled(result, ctx) {
-          const { poolAccount, intermediateRecipient } = this.state;
-          const { destination, advanceAmount, ...detail } = ctx;
-          const transferV = E(poolAccount).transfer(
-            destination,
-            { denom: usdc.denom, value: advanceAmount.value },
-            { forwardOpts: { intermediateRecipient } },
-          );
-          return watch(transferV, this.facets.transferHandler, {
+          const { poolAccount, intermediateRecipient, settlementAddress } =
+            this.state;
+          const { destination, advanceAmount, tmpSeat, ...detail } = ctx;
+          tmpSeat.exit();
+          const amount = harden({
+            denom: usdc.denom,
+            value: advanceAmount.value,
+          });
+          const transferOrSendV =
+            destination.chainId === settlementAddress.chainId
+              ? E(poolAccount).send(destination, amount)
+              : E(poolAccount).transfer(destination, amount, {
+                  forwardOpts: { intermediateRecipient },
+                });
+          return watch(transferOrSendV, this.facets.transferHandler, {
             destination,
             advanceAmount,
             ...detail,
@@ -237,9 +268,10 @@ export const prepareAdvancerKit = (
             error,
           );
           try {
-            const { borrowerFacet, notifyFacet } = this.state;
-            notifyFacet.notifyAdvancingResult(restCtx, false);
-            borrowerFacet.returnToPool(tmpSeat, advanceAmount);
+            const { borrower, notifier } = this.state;
+            notifier.notifyAdvancingResult(restCtx, false);
+            borrower.returnToPool(tmpSeat, advanceAmount);
+            tmpSeat.exit();
           } catch (e) {
             log('🚨 deposit to localOrchAccount failure recovery failed', e);
           }
@@ -247,44 +279,80 @@ export const prepareAdvancerKit = (
       },
       transferHandler: {
         /**
-         * @param {unknown} result TODO confirm this is not a bigint (sequence)
+         * @param {undefined} result
          * @param {AdvancerVowCtx} ctx
          */
         onFulfilled(result, ctx) {
-          const { notifyFacet } = this.state;
+          const { notifier } = this.state;
           const { advanceAmount, destination, ...detail } = ctx;
-          log('Advance transfer fulfilled', {
-            advanceAmount,
-            destination,
-            result,
-          });
+          log('Advance succeeded', { advanceAmount, destination });
           // During development, due to a bug, this call threw.
           // The failure was silent (no diagnostics) due to:
           //  - #10576 Vows do not report unhandled rejections
           // For now, the advancer kit relies on consistency between
-          // notifyFacet, statusManager, and callers of handleTransactionEvent().
+          // notify, statusManager, and callers of handleTransactionEvent().
           // TODO: revisit #10576 during #10510
-          notifyFacet.notifyAdvancingResult({ destination, ...detail }, true);
+          notifier.notifyAdvancingResult({ destination, ...detail }, true);
         },
         /**
          * @param {Error} error
          * @param {AdvancerVowCtx} ctx
          */
         onRejected(error, ctx) {
-          const { notifyFacet } = this.state;
-          log('Advance transfer rejected', error);
-          notifyFacet.notifyAdvancingResult(ctx, false);
+          const { notifier, poolAccount } = this.state;
+          log('Advance failed', error);
+          const { advanceAmount, ...restCtx } = ctx;
+          notifier.notifyAdvancingResult(restCtx, false);
+          const { zcfSeat: tmpReturnSeat } = zcf.makeEmptySeatKit();
+          const withdrawV = withdrawToSeat(
+            // @ts-expect-error LocalAccountMethods vs OrchestrationAccount
+            poolAccount,
+            tmpReturnSeat,
+            harden({ USDC: advanceAmount }),
+          );
+          void watch(withdrawV, this.facets.withdrawHandler, {
+            advanceAmount,
+            tmpReturnSeat,
+          });
+        },
+      },
+      withdrawHandler: {
+        /**
+         *
+         * @param {undefined} result
+         * @param {{ advanceAmount: Amount<'nat'>; tmpReturnSeat: ZCFSeat; }} ctx
+         */
+        onFulfilled(result, { advanceAmount, tmpReturnSeat }) {
+          const { borrower } = this.state;
+          try {
+            borrower.returnToPool(tmpReturnSeat, advanceAmount);
+          } catch (e) {
+            // If we reach here, the unused advance funds will remain in `tmpReturnSeat`
+            // and must be retrieved from recovery sets.
+            log(
+              `🚨 return ${q(advanceAmount)} to pool failed. funds remain on "tmpReturnSeat"`,
+              e,
+            );
+          }
+          tmpReturnSeat.exit();
+        },
+        /**
+         * @param {Error} error
+         * @param {{ advanceAmount: Amount<'nat'>; tmpReturnSeat: ZCFSeat; }} ctx
+         */
+        onRejected(error, { advanceAmount, tmpReturnSeat }) {
+          log(
+            `🚨 withdraw ${q(advanceAmount)} from "poolAccount" to return to pool failed`,
+            error,
+          );
+          // If we reach here, the unused advance funds will remain in the `poolAccount`.
+          // A contract update will be required to return them to the LiquidityPool.
+          tmpReturnSeat.exit();
         },
       },
     },
     {
-      stateShape: harden({
-        notifyFacet: M.remotable(),
-        borrowerFacet: M.remotable(),
-        poolAccount: M.remotable(),
-        intermediateRecipient: M.opt(ChainAddressShape),
-        settlementAddress: M.opt(ChainAddressShape),
-      }),
+      stateShape,
     },
   );
 };

package/src/exos/liquidity-pool.js

@@ -1,13 +1,15 @@
-import { AmountMath } from '@agoric/ertp';
+import { AmountMath, AmountShape, RatioShape } from '@agoric/ertp';
 import {
   makeRecorderTopic,
+  RecorderKitShape,
   TopicsRecordShape,
-} from '@agoric/zoe/src/contractSupport/topics.js';
+} from '@agoric/zoe/src/contractSupport/index.js';
 import { SeatShape } from '@agoric/zoe/src/typeGuards.js';
 import { M } from '@endo/patterns';
 import { Fail, q } from '@endo/errors';
 import {
   borrowCalc,
+  checkPoolBalance,
   depositCalc,
   makeParity,
   repayCalc,
@@ -20,6 +22,7 @@ import {
 } from '../type-guards.js';
 
 /**
+ * @import {Amount, Brand, Payment} from '@agoric/ertp';
  * @import {Zone} from '@agoric/zone';
  * @import {Remote} from '@agoric/internal'
  * @import {StorageNode} from '@agoric/internal/src/lib-chainStorage.js'
@@ -28,32 +31,7 @@ import {
  * @import {PoolStats} from '../types.js';
  */
 
-const { add, isEqual, isGTE, makeEmpty } = AmountMath;
-
-/** @param {Brand} brand */
-const makeDust = brand => AmountMath.make(brand, 1n);
-
-/**
- * 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 {ZCFSeat} poolSeat
- * @param {ShareWorth} shareWorth
- * @param {Brand} USDC
- * @param {Amount<'nat'>} encumberedBalance
- */
-const checkPoolBalance = (poolSeat, shareWorth, USDC, encumberedBalance) => {
-  const unencumberedBalance = poolSeat.getAmountAllocated('USDC', USDC);
-  const dust = makeDust(USDC);
-  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)}`;
-};
+const { add, isGTE, makeEmpty } = AmountMath;
 
 /**
  * @typedef {{
@@ -71,6 +49,22 @@ const checkPoolBalance = (poolSeat, shareWorth, USDC, encumberedBalance) => {
  * }} RepayPaymentKWR
  */
 
+export const stateShape = harden({
+  encumberedBalance: AmountShape,
+  feeSeat: M.remotable(),
+  poolStats: M.record(),
+  poolMetricsRecorderKit: RecorderKitShape,
+  poolSeat: M.remotable(),
+  PoolShares: M.remotable(),
+  proposalShapes: {
+    deposit: M.pattern(),
+    withdraw: M.pattern(),
+    withdrawFees: M.pattern(),
+  },
+  shareMint: M.remotable(),
+  shareWorth: RatioShape,
+});
+
 /**
  * @param {Zone} zone
  * @param {ZCF} zcf
@@ -106,11 +100,18 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
       withdrawHandler: M.interface('withdrawHandler', {
         handle: M.call(SeatShape, M.any()).returns(M.promise()),
       }),
+      withdrawFeesHandler: M.interface('withdrawFeesHandler', {
+        handle: M.call(SeatShape, M.any()).returns(M.promise()),
+      }),
       public: M.interface('public', {
         makeDepositInvitation: M.call().returns(M.promise()),
         makeWithdrawInvitation: M.call().returns(M.promise()),
         getPublicTopics: M.call().returns(TopicsRecordShape),
       }),
+      feeRecipient: M.interface('feeRecipient', {
+        getContractFeeBalance: M.call().returns(AmountShape),
+        makeWithdrawFeesInvitation: M.call().returns(M.promise()),
+      }),
     },
     /**
      * @param {ZCFMint<'nat'>} shareMint
@@ -119,7 +120,7 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
     (shareMint, node) => {
       const { brand: PoolShares } = shareMint.getIssuerRecord();
       const proposalShapes = makeProposalShapes({ USDC, PoolShares });
-      const shareWorth = makeParity(makeDust(USDC), PoolShares);
+      const shareWorth = makeParity(USDC, PoolShares);
       const { zcfSeat: poolSeat } = zcf.makeEmptySeatKit();
       const { zcfSeat: feeSeat } = zcf.makeEmptySeatKit();
       const poolMetricsRecorderKit = tools.makeRecorderKit(
@@ -191,7 +192,9 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           zcf.atomicRearrange(
             harden([[borrowSeat, repaySeat, { USDC: amount }, returnAmounts]]),
           );
-          return this.facets.repayer.repay(repaySeat, returnAmounts);
+          this.facets.repayer.repay(repaySeat, returnAmounts);
+          borrowSeat.exit();
+          repaySeat.exit();
         },
       },
       repayer: {
@@ -207,7 +210,11 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
             poolStats,
             shareWorth,
           } = this.state;
-          checkPoolBalance(poolSeat, shareWorth, USDC, encumberedBalance);
+          checkPoolBalance(
+            poolSeat.getCurrentAllocation(),
+            shareWorth,
+            encumberedBalance,
+          );
 
           const fromSeatAllocation = fromSeat.getCurrentAllocation();
           // Validate allocation equals amounts and Principal <= encumberedBalance
@@ -264,7 +271,11 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           /** @type {USDCProposalShapes['deposit']} */
           // @ts-expect-error ensured by proposalShape
           const proposal = lp.getProposal();
-          checkPoolBalance(poolSeat, shareWorth, USDC, encumberedBalance);
+          checkPoolBalance(
+            poolSeat.getCurrentAllocation(),
+            shareWorth,
+            encumberedBalance,
+          );
           const post = depositCalc(shareWorth, proposal);
 
           // COMMIT POINT
@@ -300,8 +311,12 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           // @ts-expect-error ensured by proposalShape
           const proposal = lp.getProposal();
           const { zcfSeat: burn } = zcf.makeEmptySeatKit();
-          checkPoolBalance(poolSeat, shareWorth, USDC, encumberedBalance);
-          const post = withdrawCalc(shareWorth, proposal);
+          const post = withdrawCalc(
+            shareWorth,
+            proposal,
+            poolSeat.getCurrentAllocation(),
+            encumberedBalance,
+          );
 
           // COMMIT POINT
           try {
@@ -325,6 +340,21 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           external.publishPoolMetrics();
         },
       },
+      withdrawFeesHandler: {
+        /** @param {ZCFSeat} seat */
+        async handle(seat) {
+          const { feeSeat } = this.state;
+
+          const { want } = seat.getProposal();
+          const available = feeSeat.getAmountAllocated('USDC', want.USDC.brand);
+          isGTE(available, want.USDC) ||
+            Fail`cannot withdraw ${want.USDC}; only ${available} available`;
+
+          // COMMIT POINT
+          zcf.atomicRearrange(harden([[feeSeat, seat, want]]));
+          seat.exit();
+        },
+      },
       public: {
         makeDepositInvitation() {
           return zcf.makeInvitation(
@@ -352,11 +382,28 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           };
         },
       },
+      feeRecipient: {
+        getContractFeeBalance() {
+          const { feeSeat } = this.state;
+          /** @type {Amount<'nat'>} */
+          const balance = feeSeat.getCurrentAllocation().USDC;
+          return balance;
+        },
+        makeWithdrawFeesInvitation() {
+          return zcf.makeInvitation(
+            this.facets.withdrawFeesHandler,
+            'Withdraw Fees',
+            undefined,
+            this.state.proposalShapes.withdrawFees,
+          );
+        },
+      },
     },
     {
       finish: ({ facets: { external } }) => {
         void external.publishPoolMetrics();
       },
+      stateShape,
     },
   );
 };

package/src/exos/operator-kit.js

@@ -90,8 +90,6 @@ export const prepareOperatorKit = (zone, staticPowers) =>
          */
         async SubmitEvidence(evidence, riskAssessment) {
           const { operator } = this.facets;
-          // TODO(bootstrap integration): cause this call to throw and confirm that it
-          // shows up in the the smart-wallet UpdateRecord `error` property
           operator.submitEvidence(evidence, riskAssessment);
           return staticPowers.makeInertInvitation(
             'evidence was pushed in the invitation maker call',