@agoric/ertp 0.16.3-dev-5dc325b.0 → 0.16.3-getting-started-dev-d127d1d.0

package/src/issuerKit.js

@@ -10,8 +10,6 @@ import { preparePaymentLedger } from './paymentLedger.js';
 
 import './types-ambient.js';
 
-// TODO Why does TypeScript lose the `MapStore` typing of `Baggage` here, even
-// though it knows the correct type at the exporting `@agoric/vat-data`
 /** @typedef {import('@agoric/vat-data').Baggage} Baggage */
 
 /**
@@ -24,18 +22,16 @@ import './types-ambient.js';
  */
 
 /**
- * Used _only_ internally, to make a new issuerKit or to revive an old one.
- *
  * @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 = (
@@ -82,77 +78,64 @@ harden(setupIssuerKit);
 const INSTANCE_KEY = 'issuer';
 
 /**
- * Used _only_ to upgrade a predecessor issuerKit. Use `makeDurableIssuerKit` to
- * make a new one.
- *
  * @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 upgradeIssuerKit = (
+export const prepareIssuerKit = (
   issuerBaggage,
   optShutdownWithFailure = undefined,
 ) => {
   const issuerRecord = issuerBaggage.get(INSTANCE_KEY);
   return setupIssuerKit(issuerRecord, issuerBaggage, optShutdownWithFailure);
 };
-harden(upgradeIssuerKit);
+harden(prepareIssuerKit);
 
 /**
- * Does baggage already have an issuerKit?
+ * 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);
 
 /**
- * `elementShape`, may only be present for collection-style amounts. If present,
- * it is a `Pattern` that every element of this issuerKits's amounts must
- * satisfy. For example, the Zoe Invitation issuerKit uses an elementShape
- * describing the invitation details for an individual invitation. An invitation
- * purse or payment has an amount that can only be a set of these. (Though
- * typically, the amount of an invitation payment is a singleton set. Such a
- * payment is often referred to in the singular as "an invitation".)
- *
- * @typedef {Partial<{
- *   elementShape: Pattern;
- * }>} IssuerOptionsRecord
+ * @typedef {Partial<{elementShape: Pattern}>} IssuerOptionsRecord
  */
 
 /**
- * Used _only_ to make a _new_ durable issuer, i.e., the initial incarnation of
- * that issuer.
+ * @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>}
  */
@@ -172,99 +155,30 @@ export const makeDurableIssuerKit = (
 harden(makeDurableIssuerKit);
 
 /**
- * Used to either revive a predecessor issuerKit, or to make a new durable one
- * if it is absent, and to place it in baggage for the next successor.
- *
- * @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.
- * @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 {IssuerOptionsRecord} [options]
- * @returns {IssuerKit<K>}
- */
-export const prepareIssuerKit = (
-  issuerBaggage,
-  name,
-  // @ts-expect-error K could be instantiated with a different subtype of AssetKind
-  assetKind = AssetKind.NAT,
-  displayInfo = harden({}),
-  optShutdownWithFailure = undefined,
-  options = {},
-) => {
-  if (hasIssuer(issuerBaggage)) {
-    const { elementShape: _ = undefined } = options;
-    const issuerKit = upgradeIssuerKit(issuerBaggage, optShutdownWithFailure);
-
-    // TODO check consistency with name, assetKind, displayInfo, elementShape.
-    // Consistency either means that these are the same, or that they differ
-    // in a direction we are prepared to upgrade.
-
-    // @ts-expect-error Type parameter confusion.
-    return issuerKit;
-  } else {
-    const issuerKit = makeDurableIssuerKit(
-      issuerBaggage,
-      name,
-      assetKind,
-      displayInfo,
-      optShutdownWithFailure,
-      options,
-    );
-    return issuerKit;
-  }
-};
-harden(prepareIssuerKit);
-
-/**
- * Used _only_ to make a new issuerKit that is effectively non-durable. This is
- * currently done by making a durable one in a baggage not reachable from
- * anywhere. TODO Once rebuilt on zones, this should instead just build on the
- * virtual zone. See https://github.com/Agoric/agoric-sdk/pull/7116
- *
- * Currently used for testing only. Should probably continue to be used for
- * testing only.
+ * @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

@@ -0,0 +1,5 @@
+export function claim<K extends AssetKind>(recoveryPurse: ERef<Purse<K>>, srcPaymentP: ERef<Payment<K>>, optAmountShape?: Pattern): Promise<Payment<K>>;
+export function combine<K extends AssetKind>(recoveryPurse: ERef<Purse<K>>, srcPaymentsPs: ERef<Payment<K>>[], optTotalAmount?: Pattern): Promise<Payment<K>>;
+export function split<K extends AssetKind>(recoveryPurse: ERef<Purse<K>>, srcPaymentP: ERef<Payment<K>>, paymentAmountA: Amount<K>): Promise<Payment<K>[]>;
+export function splitMany<K extends AssetKind>(recoveryPurse: ERef<Purse<K>>, srcPaymentP: ERef<Payment<K>>, amounts: Amount<K>[]): Promise<Payment[]>;
+//# sourceMappingURL=legacy-payment-helpers.d.ts.map

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

@@ -0,0 +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"}

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

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

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

@@ -0,0 +1 @@
+{"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');

package/src/mathHelpers/copySetMathHelpers.d.ts

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,14 @@
+/**
+ * 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.
+ *
+ * @type {MathHelpers<NatValue>}
+ */
+export const natMathHelpers: MathHelpers<NatValue>;
+//# sourceMappingURL=natMathHelpers.d.ts.map

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

@@ -0,0 +1 @@
+{"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/mathHelpers/setMathHelpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @deprecated Replace array-based SetMath with CopySet-based CopySetMath
+ * @type {MathHelpers<SetValue>}
+ */
+export const setMathHelpers: MathHelpers<SetValue>;
+//# sourceMappingURL=setMathHelpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setMathHelpers.d.ts","sourceRoot":"","sources":["setMathHelpers.js"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,6BAFU,qBAAqB,CAkB5B"}

package/src/payment.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+{"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/payment.js

@@ -3,11 +3,6 @@
 import { initEmpty } from '@agoric/store';
 import { prepareExoClass } from '@agoric/vat-data';
 
-/** @typedef {import('@endo/patterns').MethodGuard} MethodGuard */
-/**
- * @template {Record<string | symbol, MethodGuard>} [T=Record<string | symbol, MethodGuard>]
- * @typedef {import('@endo/patterns').InterfaceGuard<T>} InterfaceGuard
- */
 /** @typedef {import('@agoric/vat-data').Baggage} Baggage */
 
 /**

package/src/paymentLedger.d.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +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"}

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}
@@ -310,8 +314,6 @@ export const preparePaymentLedger = (
     return payment;
   };
 
-  /** @type {() => Purse<K>} */
-  // @ts-expect-error type parameter confusion
   const makeEmptyPurse = preparePurseKind(
     issuerBaggage,
     name,
@@ -376,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>}
    */