@agoric/ertp 0.16.3-dev-57802f9.0 → 0.16.3-other-dev-70beeb7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/ertp",
-  "version": "0.16.3-dev-57802f9.0+57802f9",
+  "version": "0.16.3-other-dev-70beeb7.0+70beeb7",
   "description": "Electronic Rights Transfer Protocol (ERTP). A smart contract framework for exchanging electronic rights",
   "type": "module",
   "main": "src/index.js",
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "build": "exit 0",
-    "prepack": "echo \"export {}; \" | cat - src/types-ambient.js > src/types.js && tsc --build tsconfig.build.json",
+    "prepack": "echo \"export {}; \" | cat - src/types-ambient.js > src/types.js && tsc --build jsconfig.build.json",
     "postpack": "git clean -f '*.d.ts*' src/types.js",
     "test": "ava",
     "test:c8": "c8 $C8_OPTIONS ava",
@@ -19,7 +19,7 @@
     "lint-fix": "yarn lint:eslint --fix",
     "lint": "run-s --continue-on-error lint:*",
     "lint:eslint": "eslint .",
-    "lint:types": "tsc"
+    "lint:types": "tsc -p jsconfig.json"
   },
   "repository": {
     "type": "git",
@@ -39,22 +39,21 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-57802f9.0+57802f9",
-    "@agoric/notifier": "0.6.3-dev-57802f9.0+57802f9",
-    "@agoric/store": "0.9.3-dev-57802f9.0+57802f9",
-    "@agoric/vat-data": "0.5.3-dev-57802f9.0+57802f9",
-    "@endo/eventual-send": "^0.17.5",
-    "@endo/far": "^0.2.21",
-    "@endo/marshal": "^0.8.8",
-    "@endo/nat": "^4.1.30",
-    "@endo/patterns": "^0.2.5",
-    "@endo/promise-kit": "^0.2.59"
+    "@agoric/assert": "0.6.1-other-dev-70beeb7.0+70beeb7",
+    "@agoric/notifier": "0.6.3-other-dev-70beeb7.0+70beeb7",
+    "@agoric/store": "0.9.3-other-dev-70beeb7.0+70beeb7",
+    "@agoric/swingset-vat": "0.32.3-other-dev-70beeb7.0+70beeb7",
+    "@agoric/vat-data": "0.5.3-other-dev-70beeb7.0+70beeb7",
+    "@endo/eventual-send": "0.17.2",
+    "@endo/far": "0.2.18",
+    "@endo/marshal": "0.8.5",
+    "@endo/nat": "4.1.27",
+    "@endo/promise-kit": "0.2.56"
   },
   "devDependencies": {
-    "@agoric/swingset-vat": "0.32.3-dev-57802f9.0+57802f9",
-    "@endo/bundle-source": "^2.7.0",
-    "@fast-check/ava": "^1.1.5",
-    "ava": "^5.3.0",
+    "@endo/bundle-source": "2.5.2-upstream-rollup",
+    "@fast-check/ava": "^1.1.3",
+    "ava": "^5.2.0",
     "tsd": "^0.28.1"
   },
   "files": [
@@ -75,13 +74,10 @@
     "files": [
       "test/**/test-*.js"
     ],
-    "require": [
-      "@endo/init/debug.js"
-    ],
     "timeout": "5m"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "57802f970619d66d45608e819f443131e3bf6b66"
+  "gitHead": "70beeb7e476f24cfad30fa8cd5918f04746e8839"
 }

package/src/amountMath.d.ts

@@ -3,7 +3,7 @@ export namespace AmountMath {
     export function make<K extends AssetKind>(brand: Brand<K>, allegedValue: AssetValueForKind<K>): Amount<K>;
     export function coerce<K extends AssetKind>(brand: Brand<K>, allegedAmount: Amount<K>): Amount<K>;
     export function getValue<K extends AssetKind>(brand: Brand<K>, amount: Amount<K>): AssetValueForKind<K>;
-    export let makeEmpty: {
+    export const makeEmpty: {
         (brand: Brand<AssetKind>): Amount<"nat">;
         <K extends AssetKind>(brand: Brand<AssetKind>, assetKind: K): Amount<K>;
     };
@@ -19,12 +19,7 @@ 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';
@@ -32,16 +27,20 @@ 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":"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"}
+{"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"}

package/src/amountMath.js

@@ -11,12 +11,7 @@ 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',
@@ -26,7 +21,9 @@ 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)}`;
@@ -34,37 +31,42 @@ 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 = {
@@ -135,7 +137,7 @@ const optionalBrandCheck = (allegedBrand, brand) => {
  * @param {Amount<K>} leftAmount
  * @param {Amount<K>} rightAmount
  * @param {Brand<K> | undefined} brand
- * @returns {MathHelpers<any>}
+ * @returns {MathHelpers<*>}
  */
 const checkLRAndGetHelpers = (leftAmount, rightAmount, brand = undefined) => {
   assertRecord(leftAmount, 'leftAmount');
@@ -170,11 +172,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
@@ -192,8 +194,9 @@ 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 = {
   /**
@@ -212,8 +215,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
@@ -239,8 +242,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'>;
@@ -254,8 +257,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
@@ -286,8 +289,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
@@ -303,8 +306,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
@@ -318,11 +321,12 @@ 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
@@ -370,7 +374,9 @@ const AmountMath = {
 };
 harden(AmountMath);
 
-/** @param {Amount} amount */
+/**
+ * @param {Amount} amount
+ */
 const getAssetKind = amount => {
   assertRecord(amount, 'amount');
   const { value } = amount;

package/src/issuerKit.d.ts

@@ -1,6 +1,6 @@
-export function prepareIssuerKit<K extends AssetKind>(issuerBaggage: any, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined): IssuerKit<K>;
-export function hasIssuer(baggage: any): any;
-export function makeDurableIssuerKit<K extends AssetKind>(issuerBaggage: any, name: string, assetKind?: K | undefined, displayInfo?: AdditionalDisplayInfo | undefined, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined, { elementShape }?: Partial<{
+export function prepareIssuerKit<K extends AssetKind>(issuerBaggage: MapStore<string, unknown>, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined): IssuerKit<K>;
+export function hasIssuer(baggage: MapStore<string, unknown>): any;
+export function makeDurableIssuerKit<K extends AssetKind>(issuerBaggage: MapStore<string, unknown>, name: string, assetKind?: K | undefined, displayInfo?: AdditionalDisplayInfo | undefined, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined, { elementShape }?: Partial<{
     elementShape: Pattern;
 }> | undefined): IssuerKit<K>;
 export function makeIssuerKit<K extends AssetKind = "nat">(name: string, assetKind?: K | undefined, displayInfo?: AdditionalDisplayInfo | undefined, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined, { elementShape }?: Partial<{

package/src/issuerKit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"issuerKit.d.ts","sourceRoot":"","sources":["issuerKit.js"],"names":[],"mappings":"AA2FO,iLAMN;AASM,6CAAsD;AA+BtD,oFAbI,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"}
+{"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"}

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,39 +99,43 @@ 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.
+ * 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.
  *
- *   `displayInfo` gives information to the UI on how to display the amount.
  * @param {Baggage} issuerBaggage
  * @param {string} name
- * @param {K} [assetKind]
- * @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 {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 {IssuerOptionsRecord} [options]
  * @returns {IssuerKit<K>}
  */
@@ -151,28 +155,30 @@ 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.
+ * @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.
  *
- *   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.
  *
- *   `displayInfo` gives information to the UI on how to display the amount.
  * @param {string} name
- * @param {K} [assetKind]
- * @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 {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 {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":"AA6BO,0HAHI,OAAO,uBAYjB;AAiBM,gIAHI,OAAO,uBA2BjB;AAgBM,2JAUN;AAgBM,oIAFM,QAAQ,OAAO,EAAE,CAAC,CAoB9B"}
+{"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"}

package/src/legacy-payment-helpers.js

@@ -7,17 +7,19 @@ 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`.
  */
 
 /**
@@ -41,11 +43,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
@@ -82,10 +84,11 @@ 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
@@ -108,10 +111,12 @@ 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,3 +1,5 @@
-/** @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,mCAAmC;AACnC,iCADW,YAAY,OAAO,CAAC,CAY5B"}
+{"version":3,"file":"copyBagMathHelpers.d.ts","sourceRoot":"","sources":["copyBagMathHelpers.js"],"names":[],"mappings":"AAiBA;;GAEG;AACH,iCAFU,YAAY,OAAO,CAAC,CAa3B"}

package/src/mathHelpers/copyBagMathHelpers.js

@@ -15,7 +15,9 @@ 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');