@agoric/ertp 0.16.3-dev-22cbeb1.0 → 0.16.3-dev-284e2db.0

package/src/mathHelpers/natMathHelpers.js

@@ -8,14 +8,13 @@ const { Fail } = assert;
 const empty = 0n;
 
 /**
- * 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/paymentLedger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paymentLedger.d.ts","sourceRoot":"","sources":["paymentLedger.js"],"names":[],"mappings":"AAoFO,0GAPI,MAAM,2DAGN,OAAO,6GA+UjB;sBA9Ya,OAAO,kBAAkB,EAAE,OAAO"}
+{"version":3,"file":"paymentLedger.d.ts","sourceRoot":"","sources":["paymentLedger.js"],"names":[],"mappings":"AAoFO,0GAPI,MAAM,2DAGN,OAAO,6GA2UjB;sBA1Ya,OAAO,kBAAkB,EAAE,OAAO"}

package/src/paymentLedger.js

@@ -70,8 +70,8 @@ const amountShapeFromElementShape = (brand, assetKind, elementShape) => {
 };
 
 /**
- * Make the paymentLedger, the source of truth for the balances of
- * payments. All minting and transfer authority originates here.
+ * Make the paymentLedger, the source of truth for the balances of payments. All
+ * minting and transfer authority originates here.
  *
  * @template {AssetKind} K
  * @param {Baggage} issuerBaggage
@@ -146,22 +146,21 @@ export const preparePaymentLedger = (
   );
 
   /**
-   * A withdrawn live payment is associated with the recovery set of
-   * the purse it was withdrawn from. Let's call these "recoverable"
-   * payments. All recoverable payments are live, but not all live
-   * payments are recoverable. We do the bookkeeping for payment recovery
-   * with this weakmap from recoverable payments to the recovery set they are
-   * in.
-   * A bunch of interesting invariants here:
-   *    * Every payment that is a key in the outer `paymentRecoverySets`
-   *      weakMap is also in the recovery set indexed by that payment.
-   *    * Implied by the above but worth stating: the payment is only
-   *      in at most one recovery set.
-   *    * A recovery set only contains such payments.
-   *    * Every purse is associated with exactly one recovery set unique to
-   *      it.
-   *    * A purse's recovery set only contains payments withdrawn from
-   *      that purse and not yet consumed.
+   * A withdrawn live payment is associated with the recovery set of the purse
+   * it was withdrawn from. Let's call these "recoverable" payments. All
+   * recoverable payments are live, but not all live payments are recoverable.
+   * We do the bookkeeping for payment recovery with this weakmap from
+   * recoverable payments to the recovery set they are in. A bunch of
+   * interesting invariants here:
+   *
+   * - Every payment that is a key in the outer `paymentRecoverySets` weakMap is
+   *   also in the recovery set indexed by that payment.
+   * - Implied by the above but worth stating: the payment is only in at most one
+   *   recovery set.
+   * - A recovery set only contains such payments.
+   * - Every purse is associated with exactly one recovery set unique to it.
+   * - A purse's recovery set only contains payments withdrawn from that purse and
+   *   not yet consumed.
    *
    * @type {WeakMapStore<Payment, SetStore<Payment>>}
    */
@@ -172,8 +171,7 @@ export const preparePaymentLedger = (
 
   /**
    * To maintain the invariants listed in the `paymentRecoverySets` comment,
-   * `initPayment` should contain the only
-   * call to `paymentLedger.init`.
+   * `initPayment` should contain the only call to `paymentLedger.init`.
    *
    * @param {Payment} payment
    * @param {Amount} amount
@@ -189,8 +187,7 @@ export const preparePaymentLedger = (
 
   /**
    * To maintain the invariants listed in the `paymentRecoverySets` comment,
-   * `deletePayment` should contain the only
-   * call to `paymentLedger.delete`.
+   * `deletePayment` should contain the only call to `paymentLedger.delete`.
    *
    * @param {Payment} payment
    */
@@ -203,19 +200,18 @@ export const preparePaymentLedger = (
     }
   };
 
-  /** @type {(left: Amount, right: Amount) => Amount } */
+  /** @type {(left: Amount, right: Amount) => Amount} */
   const add = (left, right) => AmountMath.add(left, right, brand);
-  /** @type {(left: Amount, right: Amount) => Amount } */
+  /** @type {(left: Amount, right: Amount) => Amount} */
   const subtract = (left, right) => AmountMath.subtract(left, right, brand);
   /** @type {(allegedAmount: Amount) => Amount} */
   const coerce = allegedAmount => AmountMath.coerce(brand, allegedAmount);
-  /** @type {(left: Amount, right: Amount) => boolean } */
+  /** @type {(left: Amount, right: Amount) => boolean} */
 
   /**
-   * Methods like deposit() have an optional second parameter
-   * `optAmountShape`
-   * which, if present, is supposed to match the balance of the
-   * payment. This helper function does that check.
+   * Methods like deposit() have an optional second parameter `optAmountShape`
+   * which, if present, is supposed to match the balance of the payment. This
+   * helper function does that check.
    *
    * Note: `optAmountShape` is user-supplied with no previous validation.
    *
@@ -243,10 +239,10 @@ export const preparePaymentLedger = (
   /**
    * Used by the purse code to implement purse.deposit
    *
-   * @param {Amount} currentBalance - the current balance of the purse
-   * before a deposit
-   * @param {(newPurseBalance: Amount) => void} updatePurseBalance -
-   * commit the purse balance
+   * @param {Amount} currentBalance - the current balance of the purse before a
+   *   deposit
+   * @param {(newPurseBalance: Amount) => void} updatePurseBalance - commit the
+   *   purse balance
    * @param {Payment} srcPayment
    * @param {Pattern} [optAmountShape]
    * @returns {Amount}
@@ -282,10 +278,10 @@ export const preparePaymentLedger = (
   /**
    * Used by the purse code to implement purse.withdraw
    *
-   * @param {Amount} currentBalance - the current balance of the purse
-   * before a withdrawal
-   * @param {(newPurseBalance: Amount) => void} updatePurseBalance -
-   * commit the purse balance
+   * @param {Amount} currentBalance - the current balance of the purse before a
+   *   withdrawal
+   * @param {(newPurseBalance: Amount) => void} updatePurseBalance - commit the
+   *   purse balance
    * @param {Amount} amount - the amount to be withdrawn
    * @param {SetStore<Payment>} recoverySet
    * @returns {Payment}
@@ -378,9 +374,9 @@ export const preparePaymentLedger = (
   /**
    * Provides for the recovery of newly minted but not-yet-deposited payments.
    *
-   * Because the `mintRecoveryPurse` is placed in baggage, even if the
-   * caller of `makeIssuerKit` drops it on the floor, it can still be
-   * recovered in an emergency upgrade.
+   * Because the `mintRecoveryPurse` is placed in baggage, even if the caller of
+   * `makeIssuerKit` drops it on the floor, it can still be recovered in an
+   * emergency upgrade.
    *
    * @type {Purse<K>}
    */

package/src/typeGuards.d.ts

@@ -27,14 +27,44 @@ export namespace IssuerKitShape {
     export { IssuerShape as issuer };
     export { DisplayInfoShape as displayInfo };
 }
-export const BrandI: import("@endo/patterns").InterfaceGuard;
+export const BrandI: import("@endo/patterns").InterfaceGuard<{
+    isMyIssuer: any;
+    getAllegedName: any;
+    getDisplayInfo: any;
+    getAmountShape: any;
+}>;
 export function makeIssuerInterfaces(brandShape?: Pattern, assetKindShape?: Pattern, amountShape?: Pattern): {
-    IssuerI: import("@endo/patterns").InterfaceGuard;
-    MintI: import("@endo/patterns").InterfaceGuard;
-    PaymentI: import("@endo/patterns").InterfaceGuard;
+    IssuerI: import("@endo/patterns").InterfaceGuard<{
+        getBrand: any;
+        getAllegedName: any;
+        getAssetKind: any;
+        getDisplayInfo: any;
+        makeEmptyPurse: any;
+        isLive: any;
+        getAmountOf: any;
+        burn: any;
+    }>;
+    MintI: import("@endo/patterns").InterfaceGuard<{
+        getIssuer: any;
+        mintPayment: any;
+    }>;
+    PaymentI: import("@endo/patterns").InterfaceGuard<{
+        getAllegedBrand: any;
+    }>;
     PurseIKit: {
-        purse: import("@endo/patterns").InterfaceGuard;
-        depositFacet: import("@endo/patterns").InterfaceGuard;
+        purse: import("@endo/patterns").InterfaceGuard<{
+            getAllegedBrand: any;
+            getCurrentAmount: any;
+            getCurrentAmountNotifier: any;
+            deposit: any;
+            getDepositFacet: any;
+            withdraw: any;
+            getRecoverySet: any;
+            recoverAll: any;
+        }>;
+        depositFacet: import("@endo/patterns").InterfaceGuard<{
+            receive: any;
+        }>;
     };
 };
 declare const AmountValueShape: import("@endo/patterns").Matcher;

package/src/typeGuards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA,0DAA+C;AAC/C,2DAAiD;AACjD,4DAAmD;AACnD,0DAA+C;AAC/C,iEAA6D;AAC7D,6DAAqD;AACrD,yDAA6C;;;;;;;;;AAqFtC,kCAHI,WAAW,mBAG0C;AASzD,sCAHI,WAAW,yBAGkD;AAYjE,kCAHI,WAAW,qBAG0C;AASzD,sCAHI,WAAW,yBAGkD;AAIxE,8CAA+C;AAE/C,8DAAuE;AAEvE,gEAaE;;;;;;;;AAYF,6DAKG;AAOI,kDAJI,OAAO,mBACP,OAAO,gBACP,OAAO;;;;;;;;EAkEjB;AAlKD,iEAKE"}
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA,0DAA+C;AAC/C,2DAAiD;AACjD,4DAAmD;AACnD,0DAA+C;AAC/C,iEAA6D;AAC7D,6DAAqD;AACrD,yDAA6C;;;;;;;;;AA+EtC,kCAHI,WAAW,mBAG0C;AASzD,sCAHI,WAAW,yBAGkD;AAYjE,kCAHI,WAAW,qBAG0C;AASzD,sCAHI,WAAW,yBAGkD;AAIxE,8CAA+C;AAE/C,8DAAuE;AAEvE,gEAaE;;;;;;;;AAYF;;;;;GAKG;AAOI,kDAJI,OAAO,mBACP,OAAO,gBACP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkEjB;AAlKD,iEAKE"}

package/src/typeGuards.js

@@ -11,62 +11,56 @@ export const NotifierShape = M.remotable('Notifier');
 export const MintShape = M.remotable('Mint');
 
 /**
- * When the AmountValue of an Amount fits the NatValueShape, i.e., when it is
- * a non-negative bigint, then it represents that many units of the
- * fungible asset represented by that amount. The brand of that amount
- * should indeed represent a kind of asset consisting of a countable
- * set of fungible units.
+ * When the AmountValue of an Amount fits the NatValueShape, i.e., when it is a
+ * non-negative bigint, then it represents that many units of the fungible asset
+ * represented by that amount. The brand of that amount should indeed represent
+ * a kind of asset consisting of a countable set of fungible units.
  */
 const NatValueShape = M.nat();
 
 /**
  * When the AmountValue of an Amount fits the CopySetValueShape, i.e., when it
- * is a CopySet, then it represents the set of those
- * keys, where each key represents some individual non-fungible
- * item, like a concert ticket, from the non-fungible asset class
- * represented by that amount's brand. The amount itself represents
- * the set of these items, as opposed to any of the other items
- * from the same asset class.
+ * is a CopySet, then it represents the set of those keys, where each key
+ * represents some individual non-fungible item, like a concert ticket, from the
+ * non-fungible asset class represented by that amount's brand. The amount
+ * itself represents the set of these items, as opposed to any of the other
+ * items from the same asset class.
  *
- * If a given value class represents concert tickets, it seems bizarre
- * that we can form amounts of any key. The hard constraint is that
- * the code that holds the mint for that asset class---the one associated
- * with that brand, only mints the items representing the real units
- * of that asset class as defined by it. Anyone else can put together
- * an amount expressing, for example, that they "want" some items that
- * will never be minted. That want will never be satisfied.
- * "You can't always get..."
+ * If a given value class represents concert tickets, it seems bizarre that we
+ * can form amounts of any key. The hard constraint is that the code that holds
+ * the mint for that asset class---the one associated with that brand, only
+ * mints the items representing the real units of that asset class as defined by
+ * it. Anyone else can put together an amount expressing, for example, that they
+ * "want" some items that will never be minted. That want will never be
+ * satisfied. "You can't always get..."
  */
 const CopySetValueShape = M.set();
 
 /**
- * When the AmountValue of an Amount fits the SetValueShape, i.e., when it
- * is a CopyArray of passable Keys. This representation is deprecated.
+ * When the AmountValue of an Amount fits the SetValueShape, i.e., when it is a
+ * CopyArray of passable Keys. This representation is deprecated.
  *
  * @deprecated Please change from using array-based SetValues to CopySet-based
- * CopySetValues.
+ *   CopySetValues.
  */
 const SetValueShape = M.arrayOf(M.key());
 
 /**
  * When the AmountValue of an Amount fits the CopyBagValueShape, i.e., when it
- * is a CopyBag, then it represents the bag (multiset) of those
- * keys, where each key represents some individual semi-fungible
- * item, like a concert ticket, from the semi-fungible asset class
- * represented by that amount's brand. The number of times that key
- * appears in the bag is the number of fungible units of that key.
- * The amount itself represents
- * the bag of these items, as opposed to any of the other items
- * from the same asset class.
+ * is a CopyBag, then it represents the bag (multiset) of those keys, where each
+ * key represents some individual semi-fungible item, like a concert ticket,
+ * from the semi-fungible asset class represented by that amount's brand. The
+ * number of times that key appears in the bag is the number of fungible units
+ * of that key. The amount itself represents the bag of these items, as opposed
+ * to any of the other items from the same asset class.
  *
- * If a given value class represents concert tickets, it seems bizarre
- * that we can form amounts of any key. The hard constraint is that
- * the code that holds the mint for that asset class---the one associated
- * with that brand, only mints the items representing the real units
- * of that asset class as defined by it. Anyone else can put together
- * an amount expressing, for example, that they "want" some items that
- * will never be minted. That want will never be satisfied.
- * "You can't always get..."
+ * If a given value class represents concert tickets, it seems bizarre that we
+ * can form amounts of any key. The hard constraint is that the code that holds
+ * the mint for that asset class---the one associated with that brand, only
+ * mints the items representing the real units of that asset class as defined by
+ * it. Anyone else can put together an amount expressing, for example, that they
+ * "want" some items that will never be minted. That want will never be
+ * satisfied. "You can't always get..."
  */
 const CopyBagValueShape = M.bag();
 
@@ -106,11 +100,11 @@ export const isCopySetValue = value => matches(value, CopySetValueShape);
 harden(isCopySetValue);
 
 /**
- * Returns true if value is a pass by copy array structure. Does not
- * check for duplicates. To check for duplicates, use setMathHelpers.coerce.
+ * Returns true if value is a pass by copy array structure. Does not check for
+ * duplicates. To check for duplicates, use setMathHelpers.coerce.
  *
  * @deprecated Please change from using array-based SetValues to CopySet-based
- * CopySetValues.
+ *   CopySetValues.
  * @param {AmountValue} value
  * @returns {value is SetValue}
  */