fixup! mustBeKey

Author: erights

packages/ERTP/src/purse.js

@@ -116,7 +116,7 @@ export const preparePurseKind = (
           const balanceStore = makeAmountStore(state, 'currentBalance');
           let amount;
           if (kindOf(amountBound) === 'match:containerHas') {
-            throw Fail`TODO handle match:containerHas`;
+            throw Fail`TODO: purse withdraw does not yet support amount patterns`;
           } else {
             amount = amountBound;
           }

packages/store/test/borrow-guards.js

@@ -19,8 +19,27 @@ export const AmountShape = harden({
   value: AmountValueShape,
 });
 
+/**
+ * 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);
+
+/** @see {AmountBound} */
+export const AmountBoundShape = harden({
+  brand: BrandShape,
+  value: AmountValueBoundShape,
+});
+
 const AmountKeywordRecordShape = M.recordOf(M.string(), AmountShape);
-const AmountPatternKeywordRecordShape = M.recordOf(M.string(), M.pattern());
+const AmountBoundKeywordRecordShape = M.recordOf(M.string(), AmountBoundShape);
 
 const TimerBrandShape = M.remotable('TimerBrand');
 const TimestampValueShape = M.nat();
@@ -31,7 +50,7 @@ const TimestampRecordShape = harden({
 const TimestampShape = M.or(TimestampRecordShape, TimestampValueShape);
 
 export const FullProposalShape = harden({
-  want: AmountPatternKeywordRecordShape,
+  want: AmountBoundKeywordRecordShape,
   give: AmountKeywordRecordShape,
   // To accept only one, we could use M.or rather than M.partial,
   // but the error messages would have been worse. Rather,

packages/zoe/src/contractFacet/reallocate.js

@@ -3,6 +3,7 @@ import { makeScalarMapStore } from '@agoric/vat-data';
 
 import { assertRightsConserved } from './rightsConservation.js';
 import { addToAllocation, subtractFromAllocation } from './allocationMath.js';
+import { mustBeKey } from '../contractSupport/zoeHelpers.js';
 
 /**
  * @import {MapStore} from '@agoric/swingset-liveslots';
@@ -47,11 +48,15 @@ export const makeAllocationMap = transfers => {
     allocations.set(seat, [newIncr, decr]);
   };
 
-  for (const [fromSeat, toSeat, fromAmounts, toAmounts] of transfers) {
+  for (const [fromSeat, toSeat, fromAmountBounds, toAmounts] of transfers) {
     if (fromSeat) {
-      if (!fromAmounts) {
+      if (!fromAmountBounds) {
         throw Fail`Transfer from ${fromSeat} must say how much`;
       }
+      const fromAmounts = mustBeKey(
+        fromAmountBounds,
+        'TODO: atomicRearange does not yet support AmountBounds',
+      );
       decrementAllocation(fromSeat, fromAmounts);
       if (toSeat) {
         // Conserved transfer between seats
@@ -74,8 +79,8 @@ export const makeAllocationMap = transfers => {
     } else {
       toSeat || Fail`Transfer must have at least one of fromSeat or toSeat`;
       // Transfer only to toSeat
-      !fromAmounts ||
-        Fail`Transfer without fromSeat cannot have fromAmounts ${fromAmounts}`;
+      !fromAmountBounds ||
+        Fail`Transfer without fromSeat cannot have fromAmountBounds ${fromAmountBounds}`;
       toAmounts || Fail`Transfer to ${toSeat} must say how much`;
       incrementAllocation(toSeat, toAmounts);
     }

packages/zoe/src/contractFacet/types.ts

@@ -14,6 +14,7 @@ import type { Passable } from '@endo/pass-style';
 import type { Key, Pattern } from '@endo/patterns';
 import type {
   AmountKeywordRecord,
+  AmountBoundKeywordRecord,
   ExitRule,
   FeeMintAccess,
   InvitationDetails,
@@ -120,7 +121,7 @@ export type ZCF<CT = Record<string, unknown>> = {
 export type TransferPart = [
   fromSeat?: ZCFSeat,
   toSeat?: ZCFSeat,
-  fromAmounts?: AmountKeywordRecord,
+  fromAmounts?: AmountBoundKeywordRecord,
   toAmounts?: AmountKeywordRecord,
 ];
 

packages/zoe/src/contractSupport/atomicTransfer.js

@@ -1,12 +1,20 @@
 import { M } from '@agoric/store';
-import { AmountKeywordRecordShape, SeatShape } from '../typeGuards.js';
+import {
+  AmountKeywordRecordShape,
+  AmountBoundKeywordRecordShape,
+  SeatShape,
+} from '../typeGuards.js';
 
 /**
- * @import {TransferPart, ZCF, ZCFSeat} from '@agoric/zoe';
+ * @import {TransferPart, ZCF, ZCFSeat, AmountBoundKeywordRecord} from '@agoric/zoe';
  */
 
 export const TransferPartShape = M.splitArray(
-  harden([M.opt(SeatShape), M.opt(SeatShape), M.opt(AmountKeywordRecordShape)]),
+  harden([
+    M.opt(SeatShape),
+    M.opt(SeatShape),
+    M.opt(AmountBoundKeywordRecordShape),
+  ]),
   harden([M.opt(AmountKeywordRecordShape)]),
 );
 
@@ -62,11 +70,11 @@ export const atomicRearrange = (zcf, transfers) => {
  * `fromOnly` are non-optional, as otherwise it doesn't make much sense.
  *
  * @param {ZCFSeat} fromSeat
- * @param {AmountKeywordRecord} fromAmounts
+ * @param {AmountBoundKeywordRecord} fromAmountBounds
  * @returns {TransferPart}
  */
-export const fromOnly = (fromSeat, fromAmounts) =>
-  harden([fromSeat, undefined, fromAmounts]);
+export const fromOnly = (fromSeat, fromAmountBounds) =>
+  harden([fromSeat, undefined, fromAmountBounds]);
 
 /**
  * Sometimes a TransferPart in an atomicRearrange only expresses what amounts

packages/zoe/src/contractSupport/zoeHelpers.js

@@ -1,15 +1,15 @@
-import { Fail } from '@endo/errors';
+import { Fail, b } from '@endo/errors';
 import { E } from '@endo/eventual-send';
 import { makePromiseKit } from '@endo/promise-kit';
-import { mustMatch, keyEQ } from '@agoric/store';
+import { mustMatch, keyEQ, isKey, isPattern } from '@endo/patterns';
 import { AssetKind } from '@agoric/ertp';
 import { fromUniqueEntries } from '@agoric/internal';
 import { satisfiesWant } from '../contractFacet/offerSafety.js';
 import { atomicTransfer, fromOnly, toOnly } from './atomicTransfer.js';
 
 /**
  * @import {Pattern} from '@endo/patterns';
- * @import {ContractMeta, Invitation, Proposal, ZCF, ZCFSeat} from '@agoric/zoe';
+ * @import {Invitation, Proposal, ZCF, ZCFSeat, AmountBoundKeywordRecord} from '@agoric/zoe';
  */
 
 export const defaultAcceptanceMsg = `The offer has been accepted. Once the contract has been completed, please check your payout`;
@@ -73,16 +73,42 @@ export const swap = (zcf, leftSeat, rightSeat) => {
   return defaultAcceptanceMsg;
 };
 
+/**
+ * @param {AmountBoundKeywordRecord} want
+ * @param {string} complaint
+ * @returns {AmountKeywordRecord}
+ */
+export const mustBeKey = (want, complaint) => {
+  if (isKey(want)) {
+    return want;
+  }
+  if (isPattern(want)) {
+    throw Fail`${b(complaint)}: ${want}`;
+  }
+  throw Fail`Must be key: ${want}`;
+};
+harden(mustBeKey);
+
 /** @type {SwapExact} */
 export const swapExact = (zcf, leftSeat, rightSeat) => {
   try {
+    const { give: rightGive, want: rightWantBound } = rightSeat.getProposal();
+    const { give: leftGive, want: leftWantBound } = leftSeat.getProposal();
+    const rightWant = mustBeKey(
+      rightWantBound,
+      'TODO: swapExact does not yet support want patterns',
+    );
+    const leftWant = mustBeKey(
+      leftWantBound,
+      'TODO: swapExact does not yet support want patterns',
+    );
     zcf.atomicRearrange(
       harden([
-        fromOnly(rightSeat, rightSeat.getProposal().give),
-        fromOnly(leftSeat, leftSeat.getProposal().give),
+        fromOnly(rightSeat, rightGive),
+        fromOnly(leftSeat, leftGive),
 
-        toOnly(leftSeat, leftSeat.getProposal().want),
-        toOnly(rightSeat, rightSeat.getProposal().want),
+        toOnly(leftSeat, leftWant),
+        toOnly(rightSeat, rightWant),
       ]),
     );
   } catch (err) {

packages/zoe/src/typeGuards.js

@@ -1,6 +1,7 @@
 // @jessie-check
 
 import {
+  AmountBoundShape,
   AmountShape,
   AssetKindShape,
   BrandShape,
@@ -31,9 +32,9 @@ export const InstallationShape = M.remotable('Installation');
 export const SeatShape = M.remotable('Seat');
 
 export const AmountKeywordRecordShape = M.recordOf(KeywordShape, AmountShape);
-export const AmountPatternKeywordRecordShape = M.recordOf(
+export const AmountBoundKeywordRecordShape = M.recordOf(
   KeywordShape,
-  M.pattern(),
+  AmountBoundShape,
 );
 export const PaymentPKeywordRecordShape = M.recordOf(
   KeywordShape,
@@ -80,7 +81,7 @@ export const TimerShape = makeHandleShape('timer');
  * @see {ProposalRecord} type
  */
 export const FullProposalShape = {
-  want: AmountPatternKeywordRecordShape,
+  want: AmountBoundKeywordRecordShape,
   give: AmountKeywordRecordShape,
   // To accept only one, we could use M.or rather than M.splitRecord,
   // but the error messages would have been worse. Rather,