@agoric/ertp 0.16.3-dev-857e650.0 → 0.16.3-dev-fb922d3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/ertp",
-  "version": "0.16.3-dev-857e650.0+857e650",
+  "version": "0.16.3-dev-fb922d3.0+fb922d3",
   "description": "Electronic Rights Transfer Protocol (ERTP). A smart contract framework for exchanging electronic rights",
   "type": "module",
   "main": "src/index.js",
@@ -39,11 +39,11 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-857e650.0+857e650",
-    "@agoric/notifier": "0.6.3-dev-857e650.0+857e650",
-    "@agoric/store": "0.9.3-dev-857e650.0+857e650",
-    "@agoric/swingset-vat": "0.32.3-dev-857e650.0+857e650",
-    "@agoric/vat-data": "0.5.3-dev-857e650.0+857e650",
+    "@agoric/assert": "0.6.1-dev-fb922d3.0+fb922d3",
+    "@agoric/notifier": "0.6.3-dev-fb922d3.0+fb922d3",
+    "@agoric/store": "0.9.3-dev-fb922d3.0+fb922d3",
+    "@agoric/swingset-vat": "0.32.3-dev-fb922d3.0+fb922d3",
+    "@agoric/vat-data": "0.5.3-dev-fb922d3.0+fb922d3",
     "@endo/eventual-send": "^0.17.3",
     "@endo/far": "^0.2.19",
     "@endo/marshal": "^0.8.6",
@@ -79,5 +79,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "857e6508f673ffb20e5efc409a3397616e31093d"
+  "gitHead": "fb922d3aeddd390919a015a76d5f4e035e6f0240"
 }

package/src/amountMath.d.ts

@@ -19,7 +19,12 @@ export namespace AmountMath {
 /**
  * Constants for the kinds of assets we support.
  *
- * @type {{ NAT: 'nat', SET: 'set', COPY_SET: 'copySet', COPY_BAG: 'copyBag' }}
+ * @type {{
+ *   NAT: 'nat';
+ *   SET: 'set';
+ *   COPY_SET: 'copySet';
+ *   COPY_BAG: 'copyBag';
+ * }}
  */
 export const AssetKind: {
     NAT: 'nat';
@@ -27,20 +32,16 @@ export const AssetKind: {
     COPY_SET: 'copySet';
     COPY_BAG: 'copyBag';
 };
-/**
- * @param {Amount} amount
- */
+/** @param {Amount} amount */
 export function getAssetKind(amount: Amount): AssetKindForValue<V>;
-/**
- * @param {AssetKind} allegedAK
- */
+/** @param {AssetKind} allegedAK */
 export function assertAssetKind(allegedAK: AssetKind): void;
 /**
- * Returns true if the leftAmount is greater than or equal to the
- * rightAmount. The notion of "greater than or equal to" depends
- * on the kind of amount, as defined by the MathHelpers. For example,
- * whether rectangle A is greater than rectangle B depends on whether rectangle
- * A includes rectangle B as defined by the logic in MathHelpers.
+ * Returns true if the leftAmount is greater than or equal to the rightAmount.
+ * The notion of "greater than or equal to" depends on the kind of amount, as
+ * defined by the MathHelpers. For example, whether rectangle A is greater than
+ * rectangle B depends on whether rectangle A includes rectangle B as defined by
+ * the logic in MathHelpers.
  *
  * @template {AssetKind} K
  * @param {Amount<K>} leftAmount

package/src/amountMath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"amountMath.d.ts","sourceRoot":"","sources":["amountMath.js"],"names":[],"mappings":"AAuHO,uFAEkC;;IAyFjC,0GAKL;IAUO,kGAQP;IASS,wGAAyD;;;;;IAwB9C,uFAOpB;IAQQ,kGAOR;;IAYQ,mIAGR;IAcI,iIAIJ;IAeS,sIAIT;IAUI,8GAMqC;IAUrC,8GAMqC;;AA1W5C;;;;GAIG;AACH,wBAFU;IAAE,GAAG,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,SAAS,CAAA;CAAE,CAO3E;AAoWH;;GAEG;AACH,qCAFW,MAAM,wBAOhB;AAzWD;;GAEG;AACH,2CAFW,SAAS,QAKnB;AAgJD;;;;;;;;;;;;GAYG;AACH,0HAFa,OAAO,CAKnB"}
+{"version":3,"file":"amountMath.d.ts","sourceRoot":"","sources":["amountMath.js"],"names":[],"mappings":"AAqHO,uFAEkC;;IAwFjC,0GAKL;IAUO,kGAQP;IASS,wGAAyD;;;;;IAwB9C,uFAOpB;IAQQ,kGAOR;;IAYQ,mIAGR;IAcI,iIAIJ;IAcS,sIAIT;IAUI,8GAMqC;IAUrC,8GAMqC;;AAtW5C;;;;;;;;;GASG;AACH,wBAPU;IACT,GAAO,EAAE,KAAK,CAAC;IACf,GAAO,EAAE,KAAK,CAAC;IACf,QAAY,EAAE,SAAS,CAAC;IACxB,QAAY,EAAE,SAAS,CAAC;CACrB,CAOD;AA2VH,6BAA6B;AAC7B,qCADY,MAAM,wBAMjB;AA9VD,mCAAmC;AACnC,2CADY,SAAS,QAIpB;AA2ID;;;;;;;;;;;;GAYG;AACH,0HAFa,OAAO,CAKnB"}

package/src/amountMath.js

@@ -11,7 +11,12 @@ const { quote: q, Fail } = assert;
 /**
  * Constants for the kinds of assets we support.
  *
- * @type {{ NAT: 'nat', SET: 'set', COPY_SET: 'copySet', COPY_BAG: 'copyBag' }}
+ * @type {{
+ *   NAT: 'nat';
+ *   SET: 'set';
+ *   COPY_SET: 'copySet';
+ *   COPY_BAG: 'copyBag';
+ * }}
  */
 const AssetKind = harden({
   NAT: 'nat',
@@ -21,9 +26,7 @@ const AssetKind = harden({
 });
 const assetKindNames = harden(Object.values(AssetKind).sort());
 
-/**
- * @param {AssetKind} allegedAK
- */
+/** @param {AssetKind} allegedAK */
 const assertAssetKind = allegedAK => {
   assetKindNames.includes(allegedAK) ||
     Fail`The assetKind ${allegedAK} must be one of ${q(assetKindNames)}`;
@@ -31,42 +34,37 @@ const assertAssetKind = allegedAK => {
 harden(assertAssetKind);
 
 /**
- * Amounts describe digital assets. From an amount, you can learn the
- * brand of digital asset as well as "how much" or "how many". Amounts
- * have two parts: a brand (loosely speaking, the type of digital
- * asset) and the value (the answer to "how much"). For example, in
- * the phrase "5 bucks", "bucks" takes the role of the brand and the
- * value is 5. Amounts can describe fungible and non-fungible digital
- * assets. Amounts are pass-by-copy and can be made by and sent to
- * anyone.
+ * Amounts describe digital assets. From an amount, you can learn the brand of
+ * digital asset as well as "how much" or "how many". Amounts have two parts: a
+ * brand (loosely speaking, the type of digital asset) and the value (the answer
+ * to "how much"). For example, in the phrase "5 bucks", "bucks" takes the role
+ * of the brand and the value is 5. Amounts can describe fungible and
+ * non-fungible digital assets. Amounts are pass-by-copy and can be made by and
+ * sent to anyone.
  *
- * The issuer is the authoritative source of the amount in payments
- * and purses. The issuer must be able to do things such as add
- * digital assets to a purse and withdraw digital assets from a purse.
- * To do so, it must know how to add and subtract digital assets.
- * Rather than hard-coding a particular solution, we chose to
- * parameterize the issuer with a collection of polymorphic functions,
- * which we call `AmountMath`. These math functions include concepts
+ * The issuer is the authoritative source of the amount in payments and purses.
+ * The issuer must be able to do things such as add digital assets to a purse
+ * and withdraw digital assets from a purse. To do so, it must know how to add
+ * and subtract digital assets. Rather than hard-coding a particular solution,
+ * we chose to parameterize the issuer with a collection of polymorphic
+ * functions, which we call `AmountMath`. These math functions include concepts
  * like addition, subtraction, and greater than or equal to.
  *
- * We also want to make sure there is no confusion as to what kind of
- * asset we are using. Thus, AmountMath includes checks of the
- * `brand`, the unique identifier for the type of digital asset. If
- * the wrong brand is used in AmountMath, an error is thrown and the
- * operation does not succeed.
+ * We also want to make sure there is no confusion as to what kind of asset we
+ * are using. Thus, AmountMath includes checks of the `brand`, the unique
+ * identifier for the type of digital asset. If the wrong brand is used in
+ * AmountMath, an error is thrown and the operation does not succeed.
  *
- * AmountMath uses mathHelpers to do most of the work, but then adds
- * the brand to the result. The function `value` gets the value from
- * the amount by removing the brand (amount -> value), and the
- * function `make` adds the brand to produce an amount (value ->
- * amount). The function `coerce` takes an amount and checks it,
- * returning an amount (amount -> amount).
+ * AmountMath uses mathHelpers to do most of the work, but then adds the brand
+ * to the result. The function `value` gets the value from the amount by
+ * removing the brand (amount -> value), and the function `make` adds the brand
+ * to produce an amount (value -> amount). The function `coerce` takes an amount
+ * and checks it, returning an amount (amount -> amount).
  *
- * Each issuer of digital assets has an associated brand in a
- * one-to-one mapping. In untrusted contexts, such as in analyzing
- * payments and amounts, we can get the brand and find the issuer
- * which matches the brand. The issuer and the brand mutually validate
- * each other.
+ * Each issuer of digital assets has an associated brand in a one-to-one
+ * mapping. In untrusted contexts, such as in analyzing payments and amounts, we
+ * can get the brand and find the issuer which matches the brand. The issuer and
+ * the brand mutually validate each other.
  */
 
 const helpers = {
@@ -137,7 +135,7 @@ const optionalBrandCheck = (allegedBrand, brand) => {
  * @param {Amount<K>} leftAmount
  * @param {Amount<K>} rightAmount
  * @param {Brand<K> | undefined} brand
- * @returns {MathHelpers<*>}
+ * @returns {MathHelpers<any>}
  */
 const checkLRAndGetHelpers = (leftAmount, rightAmount, brand = undefined) => {
   assertRecord(leftAmount, 'leftAmount');
@@ -172,11 +170,11 @@ const coerceLR = (h, leftAmount, rightAmount) => {
 };
 
 /**
- * Returns true if the leftAmount is greater than or equal to the
- * rightAmount. The notion of "greater than or equal to" depends
- * on the kind of amount, as defined by the MathHelpers. For example,
- * whether rectangle A is greater than rectangle B depends on whether rectangle
- * A includes rectangle B as defined by the logic in MathHelpers.
+ * Returns true if the leftAmount is greater than or equal to the rightAmount.
+ * The notion of "greater than or equal to" depends on the kind of amount, as
+ * defined by the MathHelpers. For example, whether rectangle A is greater than
+ * rectangle B depends on whether rectangle A includes rectangle B as defined by
+ * the logic in MathHelpers.
  *
  * @template {AssetKind} K
  * @param {Amount<K>} leftAmount
@@ -194,9 +192,8 @@ const isGTE = (leftAmount, rightAmount, brand = undefined) => {
  *
  * Amounts are the canonical description of tradable goods. They are manipulated
  * by issuers and mints, and represent the goods and currency carried by purses
- * and
- * payments. They can be used to represent things like currency, stock, and the
- * abstract right to participate in a particular exchange.
+ * and payments. They can be used to represent things like currency, stock, and
+ * the abstract right to participate in a particular exchange.
  */
 const AmountMath = {
   /**
@@ -215,8 +212,8 @@ const AmountMath = {
     return harden({ brand, value });
   },
   /**
-   * Make sure this amount is valid enough, and return a corresponding
-   * valid amount if so.
+   * Make sure this amount is valid enough, and return a corresponding valid
+   * amount if so.
    *
    * @template {AssetKind} K
    * @param {Brand<K>} brand
@@ -242,8 +239,8 @@ const AmountMath = {
    */
   getValue: (brand, amount) => AmountMath.coerce(brand, amount).value,
   /**
-   * Return the amount representing an empty amount. This is the
-   * identity element for MathHelpers.add and MatHelpers.subtract.
+   * Return the amount representing an empty amount. This is the identity
+   * element for MathHelpers.add and MatHelpers.subtract.
    *
    * @type {{
    *   (brand: Brand): Amount<'nat'>;
@@ -257,8 +254,8 @@ const AmountMath = {
     return harden({ brand, value });
   },
   /**
-   * Return the amount representing an empty amount, using another
-   * amount as the template for the brand and assetKind.
+   * Return the amount representing an empty amount, using another amount as the
+   * template for the brand and assetKind.
    *
    * @template {AssetKind} K
    * @param {Amount<K>} amount
@@ -289,8 +286,8 @@ const AmountMath = {
   },
   isGTE,
   /**
-   * Returns true if the leftAmount equals the rightAmount. We assume
-   * that if isGTE is true in both directions, isEqual is also true
+   * Returns true if the leftAmount equals the rightAmount. We assume that if
+   * isGTE is true in both directions, isEqual is also true
    *
    * @template {AssetKind} K
    * @param {Amount<K>} leftAmount
@@ -306,8 +303,8 @@ const AmountMath = {
    * Returns a new amount that is the union of both leftAmount and rightAmount.
    *
    * For fungible amount this means adding the values. For other kinds of
-   * amount, it usually means including all of the elements from both
-   * left and right.
+   * amount, it usually means including all of the elements from both left and
+   * right.
    *
    * @template {AssetKind} K
    * @param {Amount<K>} leftAmount
@@ -321,12 +318,11 @@ const AmountMath = {
     return harden({ brand: leftAmount.brand, value });
   },
   /**
-   * Returns a new amount that is the leftAmount minus the rightAmount
-   * (i.e. everything in the leftAmount that is not in the
-   * rightAmount). If leftAmount doesn't include rightAmount
-   * (subtraction results in a negative), throw  an error. Because the
-   * left amount must include the right amount, this is NOT equivalent
-   * to set subtraction.
+   * Returns a new amount that is the leftAmount minus the rightAmount (i.e.
+   * everything in the leftAmount that is not in the rightAmount). If leftAmount
+   * doesn't include rightAmount (subtraction results in a negative), throw an
+   * error. Because the left amount must include the right amount, this is NOT
+   * equivalent to set subtraction.
    *
    * @template {AssetKind} K
    * @param {Amount<K>} leftAmount
@@ -374,9 +370,7 @@ const AmountMath = {
 };
 harden(AmountMath);
 
-/**
- * @param {Amount} amount
- */
+/** @param {Amount} amount */
 const getAssetKind = amount => {
   assertRecord(amount, 'amount');
   const { value } = amount;

package/src/issuerKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"issuerKit.d.ts","sourceRoot":"","sources":["issuerKit.js"],"names":[],"mappings":"AA2FO,uMAMN;AASM,mEAAsD;AAmCtD,0GAbI,MAAM;kBAnBmB,OAAO;8BA4C1C;AA+BM,iEAbI,MAAM;kBA9DmB,OAAO;8BA0FxC;sBA3LW,OAAO,kBAAkB,EAAE,OAAO;;UAKlC,MAAM;eACN,CAAC;iBACD,qBAAqB;kBACrB,OAAO;;kCAyFR,QAAQ;IAAC,YAAY,EAAE,OAAO,CAAA;CAAC,CAAC"}
+{"version":3,"file":"issuerKit.d.ts","sourceRoot":"","sources":["issuerKit.js"],"names":[],"mappings":"AA2FO,uMAMN;AASM,mEAAsD;AA+BtD,0GAbI,MAAM;kBAhBqB,OAAO;8BAyC5C;AA6BM,iEAbI,MAAM;kBAzDqB,OAAO;8BAqF1C;sBArLW,OAAO,kBAAkB,EAAE,OAAO;;UAKlC,MAAM;eACN,CAAC;iBACD,qBAAqB;kBACrB,OAAO;;kCAwFP,QAAQ;IAAE,YAAY,EAAE,OAAO,CAAA;CAAE,CAAC"}

package/src/issuerKit.js

@@ -25,13 +25,13 @@ import './types-ambient.js';
  * @template {AssetKind} K
  * @param {IssuerRecord<K>} issuerRecord
  * @param {Baggage} issuerBaggage
- * @param {ShutdownWithFailure} [optShutdownWithFailure] If this issuer fails
- * in the middle of an atomic action (which btw should never happen), it
- * potentially leaves its ledger in a corrupted state. If this function was
- * provided, then the failed atomic action will call it, so that some
- * larger unit of computation, like the enclosing vat, can be shutdown
- * before anything else is corrupted by that corrupted state.
- * See https://github.com/Agoric/agoric-sdk/issues/3434
+ * @param {ShutdownWithFailure} [optShutdownWithFailure] If this issuer fails in
+ *   the middle of an atomic action (which btw should never happen), it
+ *   potentially leaves its ledger in a corrupted state. If this function was
+ *   provided, then the failed atomic action will call it, so that some larger
+ *   unit of computation, like the enclosing vat, can be shutdown before
+ *   anything else is corrupted by that corrupted state. See
+ *   https://github.com/Agoric/agoric-sdk/issues/3434
  * @returns {IssuerKit<K>}
  */
 const setupIssuerKit = (
@@ -80,13 +80,13 @@ const INSTANCE_KEY = 'issuer';
 /**
  * @template {AssetKind} K
  * @param {Baggage} issuerBaggage
- * @param {ShutdownWithFailure} [optShutdownWithFailure] If this issuer fails
- * in the middle of an atomic action (which btw should never happen), it
- * potentially leaves its ledger in a corrupted state. If this function was
- * provided, then the failed atomic action will call it, so that some
- * larger unit of computation, like the enclosing vat, can be shutdown
- * before anything else is corrupted by that corrupted state.
- * See https://github.com/Agoric/agoric-sdk/issues/3434
+ * @param {ShutdownWithFailure} [optShutdownWithFailure] If this issuer fails in
+ *   the middle of an atomic action (which btw should never happen), it
+ *   potentially leaves its ledger in a corrupted state. If this function was
+ *   provided, then the failed atomic action will call it, so that some larger
+ *   unit of computation, like the enclosing vat, can be shutdown before
+ *   anything else is corrupted by that corrupted state. See
+ *   https://github.com/Agoric/agoric-sdk/issues/3434
  * @returns {IssuerKit<K>}
  */
 export const prepareIssuerKit = (
@@ -99,43 +99,39 @@ export const prepareIssuerKit = (
 harden(prepareIssuerKit);
 
 /**
- * Does baggage already have an issuer from prepareIssuerKit()?
- * That is: does it have the relevant keys defined?
+ * Does baggage already have an issuer from prepareIssuerKit()? That is: does it
+ * have the relevant keys defined?
  *
  * @param {Baggage} baggage
  */
 export const hasIssuer = baggage => baggage.has(INSTANCE_KEY);
 
-/**
- * @typedef {Partial<{elementShape: Pattern}>} IssuerOptionsRecord
- */
+/** @typedef {Partial<{ elementShape: Pattern }>} IssuerOptionsRecord */
 
 /**
- * @template {AssetKind} K
- * The name becomes part of the brand in asset descriptions.
- * The name is useful for debugging and double-checking
- * assumptions, but should not be trusted wrt any external namespace.
- * For example, anyone could create a new issuer kit with name 'BTC', but
- * it is not bitcoin or even related. It is only the name according
- * to that issuer and brand.
+ * @template {AssetKind} K The name becomes part of the brand in asset
+ *   descriptions. The name is useful for debugging and double-checking
+ *   assumptions, but should not be trusted wrt any external namespace. For
+ *   example, anyone could create a new issuer kit with name 'BTC', but it is
+ *   not bitcoin or even related. It is only the name according to that issuer
+ *   and brand.
  *
- * The assetKind will be used to import a specific mathHelpers
- * from the mathHelpers library. For example, natMathHelpers, the
- * default, is used for basic fungible tokens.
- *
- *  `displayInfo` gives information to the UI on how to display the amount.
+ *   The assetKind will be used to import a specific mathHelpers from the
+ *   mathHelpers library. For example, natMathHelpers, the default, is used for
+ *   basic fungible tokens.
  *
+ *   `displayInfo` gives information to the UI on how to display the amount.
  * @param {Baggage} issuerBaggage
  * @param {string} name
  * @param {K} [assetKind=AssetKind.NAT]
  * @param {AdditionalDisplayInfo} [displayInfo={}]
- * @param {ShutdownWithFailure} [optShutdownWithFailure] If this issuer fails
- * in the middle of an atomic action (which btw should never happen), it
- * potentially leaves its ledger in a corrupted state. If this function was
- * provided, then the failed atomic action will call it, so that some
- * larger unit of computation, like the enclosing vat, can be shutdown
- * before anything else is corrupted by that corrupted state.
- * See https://github.com/Agoric/agoric-sdk/issues/3434
+ * @param {ShutdownWithFailure} [optShutdownWithFailure] If this issuer fails in
+ *   the middle of an atomic action (which btw should never happen), it
+ *   potentially leaves its ledger in a corrupted state. If this function was
+ *   provided, then the failed atomic action will call it, so that some larger
+ *   unit of computation, like the enclosing vat, can be shutdown before
+ *   anything else is corrupted by that corrupted state. See
+ *   https://github.com/Agoric/agoric-sdk/issues/3434
  * @param {IssuerOptionsRecord} [options]
  * @returns {IssuerKit<K>}
  */
@@ -155,30 +151,28 @@ export const makeDurableIssuerKit = (
 harden(makeDurableIssuerKit);
 
 /**
- * @template {AssetKind} [K='nat']
- * The name becomes part of the brand in asset descriptions.
- * The name is useful for debugging and double-checking
- * assumptions, but should not be trusted wrt any external namespace.
- * For example, anyone could create a new issuer kit with name 'BTC', but
- * it is not bitcoin or even related. It is only the name according
- * to that issuer and brand.
- *
- * The assetKind will be used to import a specific mathHelpers
- * from the mathHelpers library. For example, natMathHelpers, the
- * default, is used for basic fungible tokens.
+ * @template {AssetKind} [K='nat'] The name becomes part of the brand in asset
+ *   descriptions. The name is useful for debugging and double-checking
+ *   assumptions, but should not be trusted wrt any external namespace. For
+ *   example, anyone could create a new issuer kit with name 'BTC', but it is
+ *   not bitcoin or even related. It is only the name according to that issuer
+ *   and brand.
  *
- *  `displayInfo` gives information to the UI on how to display the amount.
+ *   The assetKind will be used to import a specific mathHelpers from the
+ *   mathHelpers library. For example, natMathHelpers, the default, is used for
+ *   basic fungible tokens.
  *
+ *   `displayInfo` gives information to the UI on how to display the amount.
  * @param {string} name
  * @param {K} [assetKind='nat']
  * @param {AdditionalDisplayInfo} [displayInfo={}]
- * @param {ShutdownWithFailure} [optShutdownWithFailure] If this issuer fails
- * in the middle of an atomic action (which btw should never happen), it
- * potentially leaves its ledger in a corrupted state. If this function was
- * provided, then the failed atomic action will call it, so that some
- * larger unit of computation, like the enclosing vat, can be shutdown
- * before anything else is corrupted by that corrupted state.
- * See https://github.com/Agoric/agoric-sdk/issues/3434
+ * @param {ShutdownWithFailure} [optShutdownWithFailure] If this issuer fails in
+ *   the middle of an atomic action (which btw should never happen), it
+ *   potentially leaves its ledger in a corrupted state. If this function was
+ *   provided, then the failed atomic action will call it, so that some larger
+ *   unit of computation, like the enclosing vat, can be shutdown before
+ *   anything else is corrupted by that corrupted state. See
+ *   https://github.com/Agoric/agoric-sdk/issues/3434
  * @param {IssuerOptionsRecord} [options]
  * @returns {IssuerKit<K>}
  */

package/src/legacy-payment-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"legacy-payment-helpers.d.ts","sourceRoot":"","sources":["legacy-payment-helpers.js"],"names":[],"mappings":"AA+BO,0HAHI,OAAO,uBAYjB;AAiBM,gIAHI,OAAO,uBA2BjB;AAiBM,2JAUN;AAkBM,oIAFM,QAAQ,OAAO,EAAE,CAAC,CAoB9B"}
+{"version":3,"file":"legacy-payment-helpers.d.ts","sourceRoot":"","sources":["legacy-payment-helpers.js"],"names":[],"mappings":"AA6BO,0HAHI,OAAO,uBAYjB;AAiBM,gIAHI,OAAO,uBA2BjB;AAgBM,2JAUN;AAgBM,oIAFM,QAAQ,OAAO,EAAE,CAAC,CAoB9B"}

package/src/legacy-payment-helpers.js

@@ -7,19 +7,17 @@ import { AmountMath } from './amountMath.js';
 const { Fail } = assert;
 
 /**
- * @file
- * This file contains safer helper function alternatives to the
- * similarly named methods on issuer.
- * These are parameterized by a purse used for recovering lost payments, which
- * we call a `recoveryPurse`. Any payments created by these
- * helper functions are in the recovery set of that `recoveryPurse` until
- * otherwise used up.
+ * @file This file contains safer helper function alternatives to the similarly
+ *   named methods on issuer. These are parameterized by a purse used for
+ *   recovering lost payments, which we call a `recoveryPurse`. Any payments
+ *   created by these helper functions are in the recovery set of that
+ *   `recoveryPurse` until otherwise used up.
  *
- * One of these helper functions is less safe in one way:
- * `combine` is not failure atomic. If the `combine` helper function
- * fails, some of the input payments may have been used up. However, even
- * in that case, no assets would be lost. The assets from the used up payments
- * will be in the argument `recoveryPurse`.
+ *   One of these helper functions is less safe in one way: `combine` is not
+ *   failure atomic. If the `combine` helper function fails, some of the input
+ *   payments may have been used up. However, even in that case, no assets would
+ *   be lost. The assets from the used up payments will be in the argument
+ *   `recoveryPurse`.
  */
 
 /**
@@ -43,11 +41,11 @@ harden(claim);
 
 /**
  * Note: Not failure atomic. But as long as you don't lose the argument
- * `recoveryPurse`, no assets are lost.
- * If any of the deposits fail, or the total does not
- * match optTotalAmount, some payments may still have been deposited. Those
- * assets will be in the argument `recoveryPurse`. All undeposited payments
- * will still be in the recovery sets of their purses of origin.
+ * `recoveryPurse`, no assets are lost. If any of the deposits fail, or the
+ * total does not match optTotalAmount, some payments may still have been
+ * deposited. Those assets will be in the argument `recoveryPurse`. All
+ * undeposited payments will still be in the recovery sets of their purses of
+ * origin.
  *
  * @template {AssetKind} K
  * @param {ERef<Purse<K>>} recoveryPurse
@@ -84,11 +82,10 @@ harden(combine);
 
 /**
  * Note: Not failure atomic. But as long as you don't lose the argument
- * `recoveryPurse`, no assets are lost.
- * If the amount in `srcPaymentP` is not >= `paymentAmountA`, the payment may
- * still be deposited anyway, before failing in the subsequent subtract.
- * In that case, those
- * assets will be in the argument `recoveryPurse`.
+ * `recoveryPurse`, no assets are lost. If the amount in `srcPaymentP` is not >=
+ * `paymentAmountA`, the payment may still be deposited anyway, before failing
+ * in the subsequent subtract. In that case, those assets will be in the
+ * argument `recoveryPurse`.
  *
  * @template {AssetKind} K
  * @param {ERef<Purse<K>>} recoveryPurse
@@ -111,12 +108,10 @@ harden(split);
 
 /**
  * Note: Not failure atomic. But as long as you don't lose the argument
- * `recoveryPurse`, no assets are lost.
- * If the amount in `srcPaymentP` is exactly the sum of the amounts,
- * the payment may
- * still be deposited anyway, before failing in the subsequent equality check.
- * In that case, those
- * assets will be in the argument `recoveryPurse`.
+ * `recoveryPurse`, no assets are lost. If the amount in `srcPaymentP` is
+ * exactly the sum of the amounts, the payment may still be deposited anyway,
+ * before failing in the subsequent equality check. In that case, those assets
+ * will be in the argument `recoveryPurse`.
  *
  * @template {AssetKind} K
  * @param {ERef<Purse<K>>} recoveryPurse

package/src/mathHelpers/copyBagMathHelpers.d.ts

@@ -1,5 +1,3 @@
-/**
- * @type {MathHelpers<CopyBag>}
- */
+/** @type {MathHelpers<CopyBag>} */
 export const copyBagMathHelpers: MathHelpers<CopyBag>;
 //# sourceMappingURL=copyBagMathHelpers.d.ts.map

package/src/mathHelpers/copyBagMathHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copyBagMathHelpers.d.ts","sourceRoot":"","sources":["copyBagMathHelpers.js"],"names":[],"mappings":"AAiBA;;GAEG;AACH,iCAFU,YAAY,OAAO,CAAC,CAa3B"}
+{"version":3,"file":"copyBagMathHelpers.d.ts","sourceRoot":"","sources":["copyBagMathHelpers.js"],"names":[],"mappings":"AAiBA,mCAAmC;AACnC,iCADW,YAAY,OAAO,CAAC,CAY5B"}

package/src/mathHelpers/copyBagMathHelpers.js

@@ -15,9 +15,7 @@ import '../types-ambient.js';
 /** @type {CopyBag} */
 const empty = makeCopyBag([]);
 
-/**
- * @type {MathHelpers<CopyBag>}
- */
+/** @type {MathHelpers<CopyBag>} */
 export const copyBagMathHelpers = harden({
   doCoerce: bag => {
     mustMatch(bag, M.bag(), 'bag of amount');

package/src/mathHelpers/copySetMathHelpers.d.ts

@@ -1,5 +1,3 @@
-/**
- * @type {MathHelpers<CopySet>}
- */
+/** @type {MathHelpers<CopySet>} */
 export const copySetMathHelpers: MathHelpers<CopySet>;
 //# sourceMappingURL=copySetMathHelpers.d.ts.map

package/src/mathHelpers/copySetMathHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"copySetMathHelpers.d.ts","sourceRoot":"","sources":["copySetMathHelpers.js"],"names":[],"mappings":"AAiBA;;GAEG;AACH,iCAFU,YAAY,OAAO,CAAC,CAa3B"}
+{"version":3,"file":"copySetMathHelpers.d.ts","sourceRoot":"","sources":["copySetMathHelpers.js"],"names":[],"mappings":"AAiBA,mCAAmC;AACnC,iCADW,YAAY,OAAO,CAAC,CAY5B"}

package/src/mathHelpers/copySetMathHelpers.js

@@ -15,9 +15,7 @@ import '../types-ambient.js';
 /** @type {CopySet} */
 const empty = makeCopySet([]);
 
-/**
- * @type {MathHelpers<CopySet>}
- */
+/** @type {MathHelpers<CopySet>} */
 export const copySetMathHelpers = harden({
   doCoerce: set => {
     mustMatch(set, M.set(), 'set of amount');

package/src/mathHelpers/natMathHelpers.d.ts

@@ -1,12 +1,11 @@
 /**
- * Fungible digital assets use the natMathHelpers to manage balances -
- * the operations are merely arithmetic on natural, non-negative
- * numbers.
+ * Fungible digital assets use the natMathHelpers to manage balances - the
+ * operations are merely arithmetic on natural, non-negative numbers.
  *
- * Natural numbers are used for fungible erights such as money because
- * rounding issues make floats problematic. All operations should be
- * done with the smallest whole unit such that the `natMathHelpers` never
- * deals with fractional parts.
+ * Natural numbers are used for fungible erights such as money because rounding
+ * issues make floats problematic. All operations should be done with the
+ * smallest whole unit such that the `natMathHelpers` never deals with
+ * fractional parts.
  *
  * @type {MathHelpers<NatValue>}
  */

package/src/mathHelpers/natMathHelpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"natMathHelpers.d.ts","sourceRoot":"","sources":["natMathHelpers.js"],"names":[],"mappings":"AASA;;;;;;;;;;;GAWG;AACH,6BAFU,YAAY,QAAQ,CAAC,CAgB5B"}
+{"version":3,"file":"natMathHelpers.d.ts","sourceRoot":"","sources":["natMathHelpers.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH,6BAFU,YAAY,QAAQ,CAAC,CAgB5B"}