@agoric/ertp 0.16.3-dev-eb7e9eb.0 → 0.16.3-u11.0

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

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

package/src/mathHelpers/copySetMathHelpers.js

@@ -15,7 +15,9 @@ 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,11 +1,12 @@
 /**
- * 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;;;;;;;;;;GAUG;AACH,6BAFU,YAAY,QAAQ,CAAC,CAgB5B"}
+{"version":3,"file":"natMathHelpers.d.ts","sourceRoot":"","sources":["natMathHelpers.js"],"names":[],"mappings":"AASA;;;;;;;;;;;GAWG;AACH,6BAFU,YAAY,QAAQ,CAAC,CAgB5B"}

package/src/mathHelpers/natMathHelpers.js

@@ -8,13 +8,14 @@ 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/payment.d.ts

@@ -1,3 +1,3 @@
-export function preparePaymentKind<K extends AssetKind>(issuerBaggage: any, name: string, brand: Brand<K>, PaymentI: InterfaceGuard): () => Payment<K>;
+export function preparePaymentKind<K extends AssetKind>(issuerBaggage: MapStore<string, unknown>, name: string, brand: Brand<K>, PaymentI: InterfaceGuard): () => Payment<K>;
 export type Baggage = import('@agoric/vat-data').Baggage;
 //# sourceMappingURL=payment.d.ts.map

package/src/payment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payment.d.ts","sourceRoot":"","sources":["payment.js"],"names":[],"mappings":"AAeO,kFALI,MAAM,6BAEN,cAAc,oBAgBxB;sBAvBa,OAAO,kBAAkB,EAAE,OAAO"}
+{"version":3,"file":"payment.d.ts","sourceRoot":"","sources":["payment.js"],"names":[],"mappings":"AAeO,wGALI,MAAM,6BAEN,cAAc,oBAgBxB;sBAvBa,OAAO,kBAAkB,EAAE,OAAO"}

package/src/paymentLedger.d.ts

@@ -1,3 +1,3 @@
-export function preparePaymentLedger<K extends AssetKind>(issuerBaggage: any, name: string, assetKind: K, displayInfo: DisplayInfo<K>, elementShape: Pattern, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined): PaymentLedger<K>;
+export function preparePaymentLedger<K extends AssetKind>(issuerBaggage: MapStore<string, unknown>, name: string, assetKind: K, displayInfo: DisplayInfo<K>, elementShape: Pattern, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined): PaymentLedger<K>;
 export type Baggage = import('@agoric/vat-data').Baggage;
 //# sourceMappingURL=paymentLedger.d.ts.map

package/src/paymentLedger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paymentLedger.d.ts","sourceRoot":"","sources":["paymentLedger.js"],"names":[],"mappings":"AAoFO,oFAPI,MAAM,2DAGN,OAAO,6GA2UjB;sBA1Ya,OAAO,kBAAkB,EAAE,OAAO"}
+{"version":3,"file":"paymentLedger.d.ts","sourceRoot":"","sources":["paymentLedger.js"],"names":[],"mappings":"AAoFO,0GAPI,MAAM,2DAGN,OAAO,6GA+UjB;sBA9Ya,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,21 +146,22 @@ 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>>}
    */
@@ -171,7 +172,8 @@ 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
@@ -187,7 +189,8 @@ 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
    */
@@ -200,18 +203,19 @@ 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.
    *
@@ -239,10 +243,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}
@@ -278,10 +282,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}
@@ -374,9 +378,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,44 +27,14 @@ export namespace IssuerKitShape {
     export { IssuerShape as issuer };
     export { DisplayInfoShape as displayInfo };
 }
-export const BrandI: import("@endo/patterns").InterfaceGuard<{
-    isMyIssuer: any;
-    getAllegedName: any;
-    getDisplayInfo: any;
-    getAmountShape: any;
-}>;
+export const BrandI: import("@endo/patterns").InterfaceGuard;
 export function makeIssuerInterfaces(brandShape?: Pattern, assetKindShape?: Pattern, amountShape?: Pattern): {
-    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;
-    }>;
+    IssuerI: import("@endo/patterns").InterfaceGuard;
+    MintI: import("@endo/patterns").InterfaceGuard;
+    PaymentI: import("@endo/patterns").InterfaceGuard;
     PurseIKit: {
-        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;
-        }>;
+        purse: import("@endo/patterns").InterfaceGuard;
+        depositFacet: import("@endo/patterns").InterfaceGuard;
     };
 };
 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;;;;;;;;;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"}
+{"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"}

package/src/typeGuards.js

@@ -11,56 +11,62 @@ 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();
 
@@ -100,11 +106,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}
  */