fixup! refactor amountMath vs helpers

Author: erights

packages/ERTP/src/amountMath.js

@@ -1,17 +1,17 @@
 import { q, Fail } from '@endo/errors';
-import { assertRemotable, assertRecord } from '@endo/pass-style';
-import { isKey, kindOf, mustMatch } from '@endo/patterns';
+import { assertRemotable, assertRecord, assertChecker } from '@endo/pass-style';
+import { containerHasSplit, kindOf, mustMatch } from '@endo/patterns';
 
 import { natMathHelpers } from './mathHelpers/natMathHelpers.js';
 import { setMathHelpers } from './mathHelpers/setMathHelpers.js';
 import { copySetMathHelpers } from './mathHelpers/copySetMathHelpers.js';
 import { copyBagMathHelpers } from './mathHelpers/copyBagMathHelpers.js';
-import { AmountBoundShape, AmountShape } from './typeGuards.js';
+import { AmountShape } from './typeGuards.js';
 
 /**
  * @import {Passable} from '@endo/pass-style'
  * @import {Key, CopyBag, CopySet} from '@endo/patterns';
- * @import {Amount, AmountBound, AmountValue, AssetValueForKind, Brand, CopyBagAmount, CopySetAmount, MathHelpers, NatAmount, NatValue, SetAmount, SetValue} from './types.js';
+ * @import {Amount, AmountBound, AmountHasBound, AmountValue, AssetValueForKind, Brand, CopyBagAmount, CopySetAmount, MathHelpers, NatAmount, NatValue, SetAmount, SetValue} from './types.js';
  */
 
 // NB: AssetKind is both a constant for enumerated values and a type for those values.
@@ -183,13 +183,13 @@ const coerceLR = (h, leftAmount, rightAmount) => {
  * For non-fungible or sem-fungible amounts, the right operand can also be an
  * `AmountBound` which can a normal concrete `Amount` or a specialized pattern:
  * A `RecordPattern` of a normal concrete `brand: Brand` and a `value:
- * AmountValueHasBound`, as made by `M.has(elementPattern)` or
- * `M.has(elementPattern, bigint)`. This represents those elements of the value
- * collection that match the elementPattern, if that number is exactly the same
- * as the bigint argument. If the second argument of `M.has` is omitted, it
- * defaults to `1n`. IOW, the left operand is `>=` such a bound if the total
- * number of elements in the left operand that match the element pattern is `>=`
- * the bigint argument in the `M.has` pattern.
+ * HasBound`, as made by `M.containerHas(elementPattern)` or
+ * `M.containerHas(elementPattern, bigint)`. This represents those elements of
+ * the value collection that match the elementPattern, if that number is exactly
+ * the same as the bigint argument. If the second argument of `M.containerHas`
+ * is omitted, it defaults to `1n`. IOW, the left operand is `>=` such a bound
+ * if the total number of elements in the left operand that match the element
+ * pattern is `>=` the bigint argument in the `M.containerHas` pattern.
  *
  * @template {AssetKind} K
  * @param {Amount<K>} leftAmount
@@ -198,26 +198,33 @@ const coerceLR = (h, leftAmount, rightAmount) => {
  * @returns {boolean}
  */
 const isGTE = (leftAmount, rightAmountBound, brand = undefined) => {
-  if (isKey(rightAmountBound)) {
-    const rightAmount = /** @type {Amount<K>} */ (rightAmountBound);
-    const h = checkLRAndGetHelpers(leftAmount, rightAmount, brand);
-    // @ts-expect-error cast?
-    return h.doIsGTE(...coerceLR(h, leftAmount, rightAmount));
+  if (kindOf(rightAmountBound) === 'match:containerHas') {
+    mustMatch(leftAmount, AmountShape, 'left amount');
+    const { brand: leftBrand, value: leftValue } = leftAmount;
+    const {
+      brand: rightBrand,
+      value: {
+        payload: [elementPatt, bound],
+      },
+    } = /** @type {AmountHasBound} */ (rightAmountBound);
+    optionalBrandCheck(leftBrand, brand);
+    optionalBrandCheck(rightBrand, brand);
+    leftBrand === rightBrand ||
+      Fail`Brands in left ${q(leftBrand)} and right ${q(
+        rightBrand,
+      )} should match but do not`;
+    const leftKind = assertValueGetAssetKind(leftValue);
+    leftKind !== 'nat' ||
+      Fail`can only use M.containerHas on container assets, not nat: ${leftValue}`;
+    const h = helpers[leftKind];
+    // @ts-expect-error param type of doCoerce should not be never
+    const lv = h.doCoerce(leftValue);
+    return !!containerHasSplit(lv, elementPatt, bound);
   }
-  mustMatch(leftAmount, AmountShape, 'left amount');
-  mustMatch(rightAmountBound, AmountBoundShape, 'right amount bound');
-  const { brand: leftBrand, value: leftValue } = leftAmount;
-  const { brand: rightBrand, value: rightValueHasBound } = rightAmountBound;
-  optionalBrandCheck(leftBrand, brand);
-  optionalBrandCheck(rightBrand, brand);
-  leftBrand === rightBrand ||
-    Fail`Brands in left ${q(leftBrand)} and right ${q(
-      rightBrand,
-    )} should match but do not`;
-  const leftKind = assertValueGetAssetKind(leftValue);
-  const h = helpers[leftKind];
+  const rightAmount = /** @type {Amount<K>} */ (rightAmountBound);
+  const h = checkLRAndGetHelpers(leftAmount, rightAmount, brand);
   // @ts-expect-error cast?
-  return h.doIsGTE(h.doCoerce(leftValue), rightValueHasBound);
+  return h.doIsGTE(...coerceLR(h, leftAmount, rightAmount));
 };
 
 /**
@@ -385,30 +392,48 @@ export const AmountMath = {
    * @returns {L}
    */
   subtract: (leftAmount, rightAmountBound, brand = undefined) => {
-    if (isKey(rightAmountBound)) {
-      const rightAmount = /** @type {Amount<K>} */ (rightAmountBound);
-      const h = checkLRAndGetHelpers(leftAmount, rightAmount, brand);
+    if (kindOf(rightAmountBound) === 'match:containerHas') {
+      mustMatch(leftAmount, AmountShape, 'left amount');
+      const { brand: leftBrand, value: leftValue } = leftAmount;
+      const {
+        brand: rightBrand,
+        value: {
+          payload: [elementPatt, bound],
+        },
+      } = /** @type {AmountHasBound} */ (rightAmountBound);
+      optionalBrandCheck(leftBrand, brand);
+      optionalBrandCheck(rightBrand, brand);
+      leftBrand === rightBrand ||
+        Fail`Brands in left ${q(leftBrand)} and right ${q(
+          rightBrand,
+        )} should match but do not`;
+      const leftKind = assertValueGetAssetKind(leftValue);
+      leftKind !== 'nat' ||
+        Fail`can only use M.containerHas on container assets, not nat: ${leftValue}`;
+      const h = helpers[leftKind];
+      // @ts-expect-error param type of doCoerce should not be never
+      const lv = h.doCoerce(leftValue);
+      // Passing in `assertChecker` as the `check` argument should guarantee
+      // that `value` is not `undefined`. It would have thrown first.
+      const [_, value] = containerHasSplit(
+        lv,
+        elementPatt,
+        bound,
+        false,
+        true,
+        assertChecker,
+      );
       // @ts-expect-error cast?
-      const value = h.doSubtract(...coerceLR(h, leftAmount, rightAmount));
-      // @ts-expect-error different subtype
-      return harden({ brand: leftAmount.brand, value });
+      return harden({ brand: leftBrand, value });
     }
-    mustMatch(leftAmount, AmountShape, 'left amount');
-    mustMatch(rightAmountBound, AmountBoundShape, 'right amount bound');
-    const { brand: leftBrand, value: leftValue } = leftAmount;
-    const { brand: rightBrand, value: rightValueHasBound } = rightAmountBound;
-    optionalBrandCheck(leftBrand, brand);
-    optionalBrandCheck(rightBrand, brand);
-    leftBrand === rightBrand ||
-      Fail`Brands in left ${q(leftBrand)} and right ${q(
-        rightBrand,
-      )} should match but do not`;
-    const leftKind = assertValueGetAssetKind(leftValue);
-    const h = helpers[leftKind];
-    // @ts-expect-error cast?
-    const value = h.doSubtract(h.doCoerce(leftValue), rightValueHasBound);
+    // @ts-expect-error I don't know why TS complains here but not in
+    // the identical case in isGTE
+    const rightAmount = /** @type {Amount<K>} */ (rightAmountBound);
+    const h = checkLRAndGetHelpers(leftAmount, rightAmount, brand);
     // @ts-expect-error cast?
-    return harden({ brand: leftBrand, value });
+    const value = h.doSubtract(...coerceLR(h, leftAmount, rightAmount));
+    // @ts-expect-error different subtype
+    return harden({ brand: leftAmount.brand, value });
   },
   /**
    * Returns the min value between x and y using isGTE

packages/ERTP/src/legacy-payment-helpers.js

@@ -40,6 +40,8 @@ export const claim = async (
 ) => {
   const srcPayment = await srcPaymentP;
   return E.when(E(recoveryPurse).deposit(srcPayment, optAmountShape), amount =>
+    // @ts-expect-error Why doesn't TS know that an Amount is a kind
+    // of AmountBound?
     E(recoveryPurse).withdraw(amount),
   );
 };
@@ -87,6 +89,8 @@ export const combine = async (
   if (optTotalAmount !== undefined) {
     mustMatch(total, optTotalAmount, 'amount');
   }
+  // @ts-expect-error Why doesn't TS know that an Amount is a kind
+  // of AmountBound?
   return E(recoveryPurse).withdraw(total);
 };
 harden(combine);
@@ -111,7 +115,11 @@ export const split = async (recoveryPurse, srcPaymentP, paymentAmountA) => {
   const srcAmount = await E(recoveryPurse).deposit(srcPayment);
   const paymentAmountB = AmountMath.subtract(srcAmount, paymentAmountA);
   return Promise.all([
+    // @ts-expect-error Why doesn't TS know that an Amount is a kind
+    // of AmountBound?
     E(recoveryPurse).withdraw(paymentAmountA),
+    // @ts-expect-error Why doesn't TS know that an Amount is a kind
+    // of AmountBound?
     E(recoveryPurse).withdraw(paymentAmountB),
   ]);
 };
@@ -147,6 +155,12 @@ export const splitMany = async (recoveryPurse, srcPaymentP, amounts) => {
   AmountMath.isEqual(srcAmount, total) ||
     Fail`rights were not conserved: ${total} vs ${srcAmount}`;
 
-  return Promise.all(amounts.map(amount => E(recoveryPurse).withdraw(amount)));
+  return Promise.all(
+    amounts.map(amount =>
+      // @ts-expect-error Why doesn't TS know that an Amount is a kind
+      // of AmountBound?
+      E(recoveryPurse).withdraw(amount),
+    ),
+  );
 };
 harden(splitMany);

packages/ERTP/src/mathHelpers/copySetMathHelpers.js

@@ -9,7 +9,7 @@ import {
   setIsSuperset,
   setDisjointUnion,
   setDisjointSubtract,
-} from '@agoric/store';
+} from '@endo/patterns';
 
 /**
  * @import {Key, CopySet} from '@endo/patterns'

packages/ERTP/src/mathHelpers/setMathHelpers.js

@@ -1,15 +1,14 @@
 // @jessie-check
 
-import { Fail } from '@endo/errors';
-import { passStyleOf, assertChecker } from '@endo/pass-style';
-import { isKey, assertKey, elementsHasSplit, kindOf } from '@endo/patterns';
+import { passStyleOf } from '@endo/pass-style';
 import {
+  assertKey,
   elementsIsSuperset,
   elementsDisjointUnion,
   elementsDisjointSubtract,
   coerceToElements,
   elementsCompare,
-} from '@agoric/store';
+} from '@endo/patterns';
 
 /**
  * @import {Key} from '@endo/patterns'
@@ -37,37 +36,8 @@ export const setMathHelpers = harden({
   },
   doMakeEmpty: () => empty,
   doIsEmpty: list => passStyleOf(list) === 'copyArray' && list.length === 0,
-  doIsGTE: (left, rightBound) => {
-    if (isKey(rightBound)) {
-      return elementsIsSuperset(left, rightBound);
-    }
-    kindOf(rightBound) === 'match:has' ||
-      Fail`rightBound must either be a key or an M.has pattern ${rightBound}`;
-    const {
-      payload: [elementPatt, bound],
-    } = rightBound;
-    return elementsHasSplit(left, elementPatt, bound);
-  },
+  doIsGTE: elementsIsSuperset,
   doIsEqual: (x, y) => elementsCompare(x, y) === 0,
   doAdd: elementsDisjointUnion,
-  doSubtract: (left, rightBound) => {
-    if (isKey(rightBound)) {
-      return elementsDisjointSubtract(left, rightBound);
-    }
-    kindOf(rightBound) === 'match:has' ||
-      Fail`rightBound must either be a key or an M.has pattern ${rightBound}`;
-    const {
-      payload: [elementPatt, bound],
-    } = rightBound;
-    const result = [];
-    elementsHasSplit(
-      left,
-      elementPatt,
-      bound,
-      undefined,
-      result,
-      assertChecker,
-    );
-    return harden(result);
-  },
+  doSubtract: elementsDisjointSubtract,
 });

packages/ERTP/src/paymentLedger.js

@@ -1,10 +1,8 @@
 // @jessie-check
 
-/// <reference types="@agoric/store/exported.js" />
-
 import { X, q, Fail, annotateError } from '@endo/errors';
 import { isPromise } from '@endo/promise-kit';
-import { mustMatch, M, keyEQ } from '@agoric/store';
+import { mustMatch, M, keyEQ } from '@endo/patterns';
 import { AmountMath } from './amountMath.js';
 import { preparePaymentKind } from './payment.js';
 import { preparePurseKind } from './purse.js';
@@ -13,7 +11,7 @@ import { BrandI, makeIssuerInterfaces } from './typeGuards.js';
 
 /**
  * @import {Key, Pattern} from '@endo/patterns';
- * @import {Amount, AssetKind, DisplayInfo, PaymentLedger, Payment, Brand, RecoverySetsOption, Purse, Issuer, Mint} from './types.js'
+ * @import {Amount, AssetKind, DisplayInfo, PaymentLedger, Payment, Brand, RecoverySetsOption, Purse, Issuer, Mint, AmountBound} from './types.js'
  * @import {ShutdownWithFailure} from '@agoric/swingset-vat'
  * @import {TypedPattern} from '@agoric/internal';
  */

packages/ERTP/src/purse.js

@@ -108,16 +108,16 @@ export const preparePurseKind = (
           updateBalance(purse, balanceStore.getAmount());
           return srcPaymentBalance;
         },
-        withdraw(amount) {
+        withdraw(amountBound) {
           const { state } = this;
           const { purse } = this.facets;
 
           const optRecoverySet = maybeRecoverySet(state);
           const balanceStore = makeAmountStore(state, 'currentBalance');
-          // Note COMMIT POINT within withdraw.
+          // Note COMMIT POINT within withdrawInternal.
           const payment = withdrawInternal(
             balanceStore,
-            amount,
+            amountBound,
             optRecoverySet,
           );
           updateBalance(purse, balanceStore.getAmount());

packages/ERTP/src/typeGuards.js

@@ -97,8 +97,15 @@ harden(AmountShape);
  */
 export const AmountPatternShape = M.pattern();
 
-/** @see {HasBound} */
-export const HasBoundShape = M.tagged('match:has');
+/**
+ * TODO: need a pattern to test `kindOf(specimen) === 'match:containerHas'` to
+ * to ensure that the pattern-level invariants are met.
+ *
+ * TODO: check all uses of M.tagged to see if they have the same weakness.
+ *
+ * @see {HasBound}
+ */
+export const HasBoundShape = M.tagged('match:containerHas');
 
 /** @see {AmountValueBound} */
 const AmountValueBoundShape = M.or(AmountValueShape, HasBoundShape);
@@ -110,6 +117,11 @@ export const AmountBoundShape = {
 };
 harden(AmountBoundShape);
 
+export const AmountHasBoundShape = {
+  brand: BrandShape,
+  value: HasBoundShape,
+};
+
 /** @type {TypedPattern<Ratio>} */
 export const RatioShape = { numerator: AmountShape, denominator: AmountShape };
 harden(RatioShape);
@@ -242,7 +254,7 @@ export const makeIssuerInterfaces = (
       .optional(AmountPatternShape)
       .returns(amountShape),
     getDepositFacet: M.call().returns(DepositFacetShape),
-    withdraw: M.call(amountShape).returns(PaymentShape),
+    withdraw: M.call(AmountBoundShape).returns(PaymentShape),
     getRecoverySet: M.call().returns(M.setOf(PaymentShape)),
     recoverAll: M.call().returns(amountShape),
   });