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

package/src/exos/liquidity-pool.js

@@ -1,13 +1,15 @@
-import { AmountMath, AmountShape } 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, 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
@@ -84,11 +78,8 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
     'Liquidity Pool',
     {
       borrower: M.interface('borrower', {
-        getBalance: M.call().returns(AmountShape),
-        borrow: M.call(
-          SeatShape,
-          harden({ USDC: makeNatAmountShape(USDC, 1n) }),
-        ).returns(),
+        borrow: M.call(SeatShape, makeNatAmountShape(USDC, 1n)).returns(),
+        returnToPool: M.call(SeatShape, makeNatAmountShape(USDC, 1n)).returns(),
       }),
       repayer: M.interface('repayer', {
         repay: M.call(
@@ -109,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
@@ -122,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(
@@ -152,38 +150,52 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
     },
     {
       borrower: {
-        getBalance() {
-          const { poolSeat } = this.state;
-          return poolSeat.getAmountAllocated('USDC', USDC);
-        },
         /**
          * @param {ZCFSeat} toSeat
-         * @param {{ USDC: Amount<'nat'>}} amountKWR
+         * @param {Amount<'nat'>} amount
          */
-        borrow(toSeat, amountKWR) {
+        borrow(toSeat, amount) {
           const { encumberedBalance, poolSeat, poolStats } = this.state;
 
           // Validate amount is available in pool
           const post = borrowCalc(
-            amountKWR.USDC,
+            amount,
             poolSeat.getAmountAllocated('USDC', USDC),
             encumberedBalance,
             poolStats,
           );
 
           // COMMIT POINT
-          try {
-            zcf.atomicRearrange(harden([[poolSeat, toSeat, amountKWR]]));
-          } catch (cause) {
-            const reason = Error('🚨 cannot commit borrow', { cause });
-            console.error(reason.message, cause);
-            zcf.shutdownWithFailure(reason);
-          }
+          // UNTIL #10684: ability to terminate an incarnation w/o terminating the contract
+          zcf.atomicRearrange(harden([[poolSeat, toSeat, { USDC: amount }]]));
 
           Object.assign(this.state, post);
           this.facets.external.publishPoolMetrics();
         },
-        // TODO method to repay failed `LOA.deposit()`
+        /**
+         * If something fails during advance, return funds to the pool.
+         *
+         * @param {ZCFSeat} borrowSeat
+         * @param {Amount<'nat'>} amount
+         */
+        returnToPool(borrowSeat, amount) {
+          const { zcfSeat: repaySeat } = zcf.makeEmptySeatKit();
+          const returnAmounts = harden({
+            Principal: amount,
+            PoolFee: makeEmpty(USDC),
+            ContractFee: makeEmpty(USDC),
+          });
+          const borrowSeatAllocation = borrowSeat.getCurrentAllocation();
+          isGTE(borrowSeatAllocation.USDC, amount) ||
+            Fail`⚠️ borrowSeatAllocation ${q(borrowSeatAllocation)} less than amountKWR ${q(amount)}`;
+          // arrange payments in a format repay is expecting
+          zcf.atomicRearrange(
+            harden([[borrowSeat, repaySeat, { USDC: amount }, returnAmounts]]),
+          );
+          this.facets.repayer.repay(repaySeat, returnAmounts);
+          borrowSeat.exit();
+          repaySeat.exit();
+        },
       },
       repayer: {
         /**
@@ -198,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
@@ -213,23 +229,18 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
           const { ContractFee, ...rest } = amounts;
 
           // COMMIT POINT
-          try {
-            zcf.atomicRearrange(
-              harden([
-                [
-                  fromSeat,
-                  poolSeat,
-                  rest,
-                  { USDC: add(amounts.PoolFee, amounts.Principal) },
-                ],
-                [fromSeat, feeSeat, { ContractFee }, { USDC: ContractFee }],
-              ]),
-            );
-          } catch (cause) {
-            const reason = Error('🚨 cannot commit repay', { cause });
-            console.error(reason.message, cause);
-            zcf.shutdownWithFailure(reason);
-          }
+          // UNTIL #10684: ability to terminate an incarnation w/o terminating the contract
+          zcf.atomicRearrange(
+            harden([
+              [
+                fromSeat,
+                poolSeat,
+                rest,
+                { USDC: add(amounts.PoolFee, amounts.Principal) },
+              ],
+              [fromSeat, feeSeat, { ContractFee }, { USDC: ContractFee }],
+            ]),
+          );
 
           Object.assign(this.state, post);
           this.facets.external.publishPoolMetrics();
@@ -260,13 +271,16 @@ 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
-
+          const mint = shareMint.mintGains(post.payouts);
           try {
-            const mint = shareMint.mintGains(post.payouts);
             this.state.shareWorth = post.shareWorth;
             zcf.atomicRearrange(
               harden([
@@ -276,12 +290,12 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
                 [mint, lp, post.payouts],
               ]),
             );
+          } catch (cause) {
+            // UNTIL #10684: ability to terminate an incarnation w/o terminating the contract
+            throw new Error('🚨 cannot commit deposit', { cause });
+          } finally {
             lp.exit();
             mint.exit();
-          } catch (cause) {
-            const reason = Error('🚨 cannot commit deposit', { cause });
-            console.error(reason.message, cause);
-            zcf.shutdownWithFailure(reason);
           }
           external.publishPoolMetrics();
         },
@@ -297,11 +311,14 @@ 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 {
             this.state.shareWorth = post.shareWorth;
             zcf.atomicRearrange(
@@ -313,16 +330,31 @@ export const prepareLiquidityPoolKit = (zone, zcf, USDC, tools) => {
               ]),
             );
             shareMint.burnLosses(proposal.give, burn);
+          } catch (cause) {
+            // UNTIL #10684: ability to terminate an incarnation w/o terminating the contract
+            throw new Error('🚨 cannot commit withdraw', { cause });
+          } finally {
             lp.exit();
             burn.exit();
-          } catch (cause) {
-            const reason = Error('🚨 cannot commit withdraw', { cause });
-            console.error(reason.message, cause);
-            zcf.shutdownWithFailure(reason);
           }
           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(
@@ -350,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

@@ -1,18 +1,18 @@
 import { makeTracer } from '@agoric/internal';
 import { Fail } from '@endo/errors';
 import { M } from '@endo/patterns';
-import { CctpTxEvidenceShape } from '../type-guards.js';
+import { CctpTxEvidenceShape, RiskAssessmentShape } from '../type-guards.js';
 
 const trace = makeTracer('TxOperator');
 
 /**
  * @import {Zone} from '@agoric/zone';
- * @import {CctpTxEvidence} from '../types.js';
+ * @import {CctpTxEvidence, RiskAssessment} from '../types.js';
  */
 
 /**
  * @typedef {object} OperatorPowers
- * @property {(evidence: CctpTxEvidence, operatorKit: OperatorKit) => void} submitEvidence
+ * @property {(evidence: CctpTxEvidence, riskAssessment: RiskAssessment, operatorId: string) => void} attest
  */
 
 /**
@@ -31,11 +31,15 @@ const OperatorKitI = {
   }),
 
   invitationMakers: M.interface('InvitationMakers', {
-    SubmitEvidence: M.call(CctpTxEvidenceShape).returns(M.promise()),
+    SubmitEvidence: M.call(CctpTxEvidenceShape)
+      .optional(RiskAssessmentShape)
+      .returns(M.promise()),
   }),
 
   operator: M.interface('Operator', {
-    submitEvidence: M.call(CctpTxEvidenceShape).returns(M.promise()),
+    submitEvidence: M.call(CctpTxEvidenceShape)
+      .optional(RiskAssessmentShape)
+      .returns(),
     getStatus: M.call().returns(M.record()),
   }),
 };
@@ -81,13 +85,12 @@ export const prepareOperatorKit = (zone, staticPowers) =>
          * fluxAggregator contract used for price oracles.
          *
          * @param {CctpTxEvidence} evidence
+         * @param {RiskAssessment} [riskAssessment]
          * @returns {Promise<Invitation>}
          */
-        async SubmitEvidence(evidence) {
+        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
-          await operator.submitEvidence(evidence);
+          operator.submitEvidence(evidence, riskAssessment);
           return staticPowers.makeInertInvitation(
             'evidence was pushed in the invitation maker call',
           );
@@ -98,12 +101,13 @@ export const prepareOperatorKit = (zone, staticPowers) =>
          * submit evidence from this operator
          *
          * @param {CctpTxEvidence} evidence
+         * @param {RiskAssessment} [riskAssessment]
+         * @returns {void}
          */
-        async submitEvidence(evidence) {
+        submitEvidence(evidence, riskAssessment = {}) {
           const { state } = this;
           !state.disabled || Fail`submitEvidence for disabled operator`;
-          const result = state.powers.submitEvidence(evidence, this.facets);
-          return result;
+          state.powers.attest(evidence, riskAssessment, state.operatorId);
         },
         /** @returns {OperatorStatus} */
         getStatus() {