chore(fast-usdc): prune testBorrow, testRepay methods (#10607)

closes: #10388
refs: #10511

## Description

Prune `testBorrow`, `testRepay` methods along with contract tests that depend on them.

 - Several tests are largely covered by share-pool-math tests
   - 1 was not, so I made a pool-share-math test to cover _repay succeeds with no Pool or Contract Fee_.
 - Several tests basically checked the interface guards of `lp.borrower.borrow` / `lp.repayer.repay`.
    These are internal APIs with static types.
   - testing consistency between interface guards and static types
     might have some value, but, I suggest, not enough for the cost

### Scaling / Documentation / Upgrade Considerations

none

### Security / Testing Considerations

small loss in test coverage - mostly in test redundancy

`makeTestPushInvitation` remains on the public facet. Getting rid of it in due course remains critical.
I expect / hope we can get rid of it in #10606 (cc @samsiegart ) .

Ideally, the liquidity-pool exo would have unit test coverage. I looked into that but found that I would have to build substantial ZCF / Zoe test tooling. Since `liquidity-pool.js` is just 360 lines of straightforward Zoe API usage, I suggest we postpone that under...

 - #10558

Author: mergify[bot]

packages/fast-usdc/src/fast-usdc.contract.js

@@ -1,9 +1,5 @@
 import { AssetKind } from '@agoric/ertp';
-import {
-  assertAllDefined,
-  deeplyFulfilledObject,
-  makeTracer,
-} from '@agoric/internal';
+import { assertAllDefined, makeTracer } from '@agoric/internal';
 import { observeIteration, subscribeEach } from '@agoric/notifier';
 import {
   CosmosChainInfoShape,
@@ -12,20 +8,19 @@ import {
   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 { 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';
+import { defineInertInvitation } from './utils/zoe.js';
 
 const trace = makeTracer('FastUsdc');
 
@@ -151,35 +146,6 @@ export const contract = async (zcf, privateArgs, zone, tools) => {
     async makeOperatorInvitation(operatorId) {
       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();
-    },
-    /**
-     *
-     * @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,
-      );
-      poolKit.repayer.repay(tmpAssetManagerSeat, amounts);
-      return tmpAssetManagerSeat.getCurrentAllocation();
-    },
   });
 
   const publicFacet = zone.exo('Fast USDC Public', undefined, {

packages/fast-usdc/test/fast-usdc.contract.test.ts

@@ -317,235 +317,6 @@ const makeLP = async (
   return me;
 };
 
-test.skip('LP borrow - TODO: move to exo test', async t => {
-  const common = await commonSetup(t);
-  const {
-    brands: { usdc },
-    utils,
-  } = common;
-
-  const { instance, creatorFacet, zoe, metricsSub, terms } =
-    await startContract(common);
-
-  const usdcPurse = purseOf(terms.issuers.USDC, utils);
-  const lps = {
-    alice: makeLP('Alice', usdcPurse(100n), zoe, instance),
-  };
-  // seed pool with funds
-  await E(lps.alice).deposit(t, 100n);
-
-  const { value } = await E(metricsSub).getUpdateSince();
-  const { shareWorth, encumberedBalance } = value;
-  const poolSeatAllocation = subtract(
-    subtract(shareWorth.numerator, encumberedBalance),
-    usdc.make(1n),
-  );
-  t.log('Attempting to borrow entire pool seat allocation', poolSeatAllocation);
-  await t.throwsAsync(
-    E(creatorFacet).testBorrow({ USDC: poolSeatAllocation }),
-    {
-      message: /Cannot borrow/,
-    },
-    'borrow fails when requested equals pool seat allocation',
-  );
-
-  await t.throwsAsync(
-    E(creatorFacet).testBorrow({ USDC: usdc.make(200n) }),
-    {
-      message: /Cannot borrow/,
-    },
-    'borrow fails when requested exceeds pool seat allocation',
-  );
-
-  await t.throwsAsync(E(creatorFacet).testBorrow({ USDC: usdc.make(0n) }), {
-    message: /arg 1: USDC: value: "\[0n\]" - Must be >= "\[1n\]"/,
-  });
-
-  await t.throwsAsync(
-    E(creatorFacet).testBorrow(
-      // @ts-expect-error intentionally incorrect KW
-      { Fee: usdc.make(1n) },
-    ),
-    {
-      message: /Must have missing properties \["USDC"\]/,
-    },
-  );
-
-  // LPs can still withdraw (contract did not shutdown)
-  await E(lps.alice).withdraw(t, 0.5);
-
-  const amt = await E(creatorFacet).testBorrow({ USDC: usdc.make(30n) });
-  t.deepEqual(amt, { USDC: usdc.make(30n) }, 'borrow succeeds');
-
-  await eventLoopIteration();
-  t.like(await E(metricsSub).getUpdateSince(), {
-    value: {
-      encumberedBalance: {
-        value: 30n,
-      },
-      totalBorrows: {
-        value: 30n,
-      },
-      totalRepays: {
-        value: 0n,
-      },
-    },
-  });
-});
-
-test.skip('LP repay - TODO: move to exo test', async t => {
-  const common = await commonSetup(t);
-  const {
-    commonPrivateArgs,
-    brands: { usdc },
-    utils,
-  } = common;
-
-  const { instance, creatorFacet, zoe, metricsSub, terms } =
-    await startContract(common);
-  const usdcPurse = purseOf(terms.issuers.USDC, utils);
-  const lps = {
-    alice: makeLP('Alice', usdcPurse(100n), zoe, instance),
-  };
-  // seed pool with funds
-  await E(lps.alice).deposit(t, 100n);
-
-  // borrow funds from pool to increase encumbered balance
-  await E(creatorFacet).testBorrow({ USDC: usdc.make(50n) });
-  const feeTools = makeFeeTools(commonPrivateArgs.feeConfig);
-  {
-    t.log('cannot repay more than encumbered balance');
-    const repayAmounts = feeTools.calculateSplit(usdc.make(100n));
-    const repayPayments = await deeplyFulfilledObject(
-      objectMap(repayAmounts, utils.pourPayment),
-    );
-    await t.throwsAsync(
-      E(creatorFacet).testRepay(repayAmounts, repayPayments),
-      {
-        message: /Cannot repay. Principal .* exceeds encumberedBalance/,
-      },
-    );
-  }
-
-  {
-    const pmt = utils.pourPayment(usdc.make(50n));
-    await t.throwsAsync(
-      E(creatorFacet).testRepay(
-        // @ts-expect-error intentionally incorrect KWR
-        { USDC: usdc.make(50n) },
-        { USDC: pmt },
-      ),
-      {
-        message:
-          /Must have missing properties \["Principal","PoolFee","ContractFee"\]/,
-      },
-    );
-  }
-  {
-    const pmt = utils.pourPayment(usdc.make(50n));
-    await t.throwsAsync(
-      E(creatorFacet).testRepay(
-        // @ts-expect-error intentionally incorrect KWR
-        { Principal: usdc.make(50n) },
-        { Principal: pmt },
-      ),
-      {
-        message: /Must have missing properties \["PoolFee","ContractFee"\]/,
-      },
-    );
-  }
-  {
-    const amts = {
-      Principal: usdc.make(0n),
-      ContractFee: usdc.make(0n),
-      PoolFee: usdc.make(0n),
-    };
-    const pmts = await deeplyFulfilledObject(
-      objectMap(amts, utils.pourPayment),
-    );
-    await t.throwsAsync(E(creatorFacet).testRepay(amts, pmts), {
-      message: /arg 1: Principal: value: "\[0n\]" - Must be >= "\[1n\]"/,
-    });
-  }
-
-  {
-    t.log('repay fails when amounts do not match seat allocation');
-    const amts = {
-      Principal: usdc.make(25n),
-      ContractFee: usdc.make(1n),
-      PoolFee: usdc.make(2n),
-    };
-    const pmts = await deeplyFulfilledObject(
-      harden({
-        Principal: utils.pourPayment(usdc.make(24n)),
-        ContractFee: utils.pourPayment(usdc.make(1n)),
-        PoolFee: utils.pourPayment(usdc.make(2n)),
-      }),
-    );
-    await t.throwsAsync(E(creatorFacet).testRepay(amts, pmts), {
-      message: /Cannot repay. From seat allocation .* does not equal amounts/,
-    });
-  }
-
-  {
-    t.log('repay succeeds with no Pool or Contract Fee');
-    const amts = {
-      Principal: usdc.make(25n),
-      ContractFee: usdc.make(0n),
-      PoolFee: usdc.make(0n),
-    };
-    const pmts = await deeplyFulfilledObject(
-      objectMap(amts, utils.pourPayment),
-    );
-    const repayResult = await E(creatorFacet).testRepay(amts, pmts);
-
-    for (const r of Object.values(repayResult)) {
-      t.is(r.value, 0n, 'testRepay consumes all payments');
-    }
-  }
-
-  const amts = {
-    Principal: usdc.make(25n),
-    ContractFee: usdc.make(1n),
-    PoolFee: usdc.make(2n),
-  };
-  const pmts = await deeplyFulfilledObject(objectMap(amts, utils.pourPayment));
-  const repayResult = await E(creatorFacet).testRepay(amts, pmts);
-
-  for (const r of Object.values(repayResult)) {
-    t.is(r.value, 0n, 'testRepay consumes all payments');
-  }
-
-  await eventLoopIteration();
-  t.like(await E(metricsSub).getUpdateSince(), {
-    value: {
-      encumberedBalance: {
-        value: 0n,
-      },
-      totalBorrows: {
-        value: 50n,
-      },
-      totalRepays: {
-        value: 50n,
-      },
-      totalContractFees: {
-        value: 1n,
-      },
-      totalPoolFees: {
-        value: 2n,
-      },
-      shareWorth: {
-        numerator: {
-          value: 103n, // 100n (alice lp) + 1n (dust) + 2n (pool fees)
-        },
-      },
-    },
-  });
-
-  // LPs can still withdraw (contract did not shutdown)
-  await E(lps.alice).withdraw(t, 1);
-});
-
 const makeEVM = (template = MockCctpTxEvidences.AGORIC_PLUS_OSMO()) => {
   const [settleAddr] = template.aux.recipientAddress.split('?');
   let nonce = 0;

packages/fast-usdc/test/pool-share-math.test.ts

@@ -494,3 +494,33 @@ test('repay fails when seat allocation does not equal amounts', t => {
     },
   );
 });
+
+test('repay succeeds with no Pool or Contract Fee', t => {
+  const { USDC } = brands;
+  const encumberedBalance = make(USDC, 100n);
+  const shareWorth = makeParity(make(USDC, 1n), brands.PoolShares);
+
+  const amounts = {
+    Principal: make(USDC, 25n),
+    ContractFee: make(USDC, 0n),
+    PoolFee: make(USDC, 0n),
+  };
+  const poolStats = {
+    ...makeInitialPoolStats(),
+    totalBorrows: make(USDC, 100n),
+  };
+  const fromSeatAllocation = amounts;
+  const actual = repayCalc(
+    shareWorth,
+    fromSeatAllocation,
+    amounts,
+    encumberedBalance,
+    poolStats,
+  );
+  t.like(actual, {
+    shareWorth,
+    encumberedBalance: {
+      value: 75n,
+    },
+  });
+});