@agoric/ertp 0.16.3-dev-e141f05.0 → 0.16.3-dev-9c9e5cf.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/ertp",
-  "version": "0.16.3-dev-e141f05.0+e141f05",
+  "version": "0.16.3-dev-9c9e5cf.0+9c9e5cf",
   "description": "Electronic Rights Transfer Protocol (ERTP). A smart contract framework for exchanging electronic rights",
   "type": "module",
   "main": "src/index.js",
@@ -39,10 +39,10 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/notifier": "0.6.3-dev-e141f05.0+e141f05",
-    "@agoric/store": "0.9.3-dev-e141f05.0+e141f05",
-    "@agoric/vat-data": "0.5.3-dev-e141f05.0+e141f05",
-    "@agoric/zone": "0.2.3-dev-e141f05.0+e141f05",
+    "@agoric/notifier": "0.6.3-dev-9c9e5cf.0+9c9e5cf",
+    "@agoric/store": "0.9.3-dev-9c9e5cf.0+9c9e5cf",
+    "@agoric/vat-data": "0.5.3-dev-9c9e5cf.0+9c9e5cf",
+    "@agoric/zone": "0.2.3-dev-9c9e5cf.0+9c9e5cf",
     "@endo/errors": "^1.2.4",
     "@endo/eventual-send": "^1.2.4",
     "@endo/far": "^1.1.4",
@@ -52,7 +52,7 @@
     "@endo/promise-kit": "^1.1.4"
   },
   "devDependencies": {
-    "@agoric/swingset-vat": "0.32.3-dev-e141f05.0+e141f05",
+    "@agoric/swingset-vat": "0.32.3-dev-9c9e5cf.0+9c9e5cf",
     "@endo/bundle-source": "^3.3.0",
     "@fast-check/ava": "^1.1.5",
     "ava": "^5.3.0",
@@ -88,5 +88,5 @@
   "typeCoverage": {
     "atLeast": 91.23
   },
-  "gitHead": "e141f05e1bf9f41b7c9a1afd74be18f0569ac469"
+  "gitHead": "9c9e5cf884e5f48554300d91ff7629773256f628"
 }

package/src/typeGuards.d.ts

@@ -10,6 +10,18 @@ export namespace AmountShape {
     export { BrandShape as brand };
     export { AmountValueShape as value };
 }
+/**
+ * To be used to guard an amount pattern argument, i.e., an argument which is a
+ * pattern that can be used to test amounts. Since amounts are keys, anywhere an
+ * amount pattern is expected, an amount can be provided and will match only
+ * that concrete amount, i.e., amounts that are `keyEQ` to that amount.
+ *
+ * The `AmountShape` guard above is an amount pattern. But not all amount
+ * patterns are like `AmountShape`. For example, `M.any()` is a valid amount
+ * pattern that will admit any amount, but is does not resemble the
+ * `AmountShape` pattern above.
+ */
+export const AmountPatternShape: import("@endo/patterns").Matcher;
 export namespace RatioShape {
     export { AmountShape as numerator };
     export { AmountShape as denominator };

package/src/typeGuards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAGA,wGAAwG;AAExG,0DAA+C;AAC/C,2DAAiD;AACjD,4DAAmD;AACnD,0DAA+C;AAC/C,iEAA6D;AAC7D,6DAAqD;AACrD,yDAA6C;;;;;;;;;AA+EtC,kCAHI,WAAW,GACT,KAAK,IAAI,OAAO,YAAY,EAAE,QAAQ,CAEa;AASzD,sCAHI,WAAW,GACT,KAAK,IAAI,OAAO,CAE2C;AAYjE,kCAHI,WAAW,GACT,KAAK,IAAI,QAAQ,CAEkC;AASzD,sCAHI,WAAW,GACT,KAAK,IAAI,OAAO,CAE2C;AAIxE,8CAA+C;AAE/C,8DAAuE;AAEvE,gEAaE;;;;;;;;AAYF;;;;;GAKG;AAOI,kDAJI,OAAO,mBACP,OAAO,gBACP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkEjB;AAlKD,iEAKE;iCArEuF,YAAY"}
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAGA,wGAAwG;AAExG,0DAA+C;AAC/C,2DAAiD;AACjD,4DAAmD;AACnD,0DAA+C;AAC/C,iEAA6D;AAC7D,6DAAqD;AACrD,yDAA6C;;;;;AAoE7C;;;;;;;;;;GAUG;AACH,kEAA8C;;;;;AAavC,kCAHI,WAAW,GACT,KAAK,IAAI,OAAO,YAAY,EAAE,QAAQ,CAEa;AASzD,sCAHI,WAAW,GACT,KAAK,IAAI,OAAO,CAE2C;AAYjE,kCAHI,WAAW,GACT,KAAK,IAAI,QAAQ,CAEkC;AASzD,sCAHI,WAAW,GACT,KAAK,IAAI,OAAO,CAE2C;AAIxE,8CAA+C;AAE/C,8DAAuE;AAEvE,gEAaE;;;;;;;;AAYF;;;;;GAKG;AAOI,kDAJI,OAAO,mBACP,OAAO,gBACP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoEjB;AAjLD,iEAKE;iCArEuF,YAAY"}

package/src/typeGuards.js

@@ -77,6 +77,19 @@ export const AmountShape = harden({
   value: AmountValueShape,
 });
 
+/**
+ * To be used to guard an amount pattern argument, i.e., an argument which is a
+ * pattern that can be used to test amounts. Since amounts are keys, anywhere an
+ * amount pattern is expected, an amount can be provided and will match only
+ * that concrete amount, i.e., amounts that are `keyEQ` to that amount.
+ *
+ * The `AmountShape` guard above is an amount pattern. But not all amount
+ * patterns are like `AmountShape`. For example, `M.any()` is a valid amount
+ * pattern that will admit any amount, but is does not resemble the
+ * `AmountShape` pattern above.
+ */
+export const AmountPatternShape = M.pattern();
+
 export const RatioShape = harden({
   numerator: AmountShape,
   denominator: AmountShape,
@@ -178,7 +191,7 @@ export const makeIssuerInterfaces = (
     isLive: M.callWhen(M.await(PaymentShape)).returns(M.boolean()),
     getAmountOf: M.callWhen(M.await(PaymentShape)).returns(amountShape),
     burn: M.callWhen(M.await(PaymentShape))
-      .optional(M.pattern())
+      .optional(AmountPatternShape)
       .returns(amountShape),
   });
 
@@ -205,7 +218,9 @@ export const makeIssuerInterfaces = (
     // `srcPayment` is a remotable, leaving it
     // to this raw method to validate that this remotable is actually
     // a live payment of the correct brand with sufficient funds.
-    deposit: M.call(PaymentShape).optional(M.pattern()).returns(amountShape),
+    deposit: M.call(PaymentShape)
+      .optional(AmountPatternShape)
+      .returns(amountShape),
     getDepositFacet: M.call().returns(DepositFacetShape),
     withdraw: M.call(amountShape).returns(PaymentShape),
     getRecoverySet: M.call().returns(M.setOf(PaymentShape)),