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

package/src/types-ambient.d.ts

@@ -1,86 +1,86 @@
 /**
- * Amounts are descriptions of digital assets, answering the questions
- * "how much" and "of what kind". Amounts are values labeled with a brand.
- * AmountMath executes the logic of how amounts are changed when digital
- * assets are merged, separated, or otherwise manipulated. For
- * example, a deposit of 2 bucks into a purse that already has 3 bucks
- * gives a new purse balance of 5 bucks. An empty purse has 0 bucks. AmountMath
- * relies heavily on polymorphic MathHelpers, which manipulate the unbranded
- * portion.
+ * Amounts are descriptions of digital assets,
+ *   answering the questions "how much" and "of what kind". Amounts are values
+ *   labeled with a brand. AmountMath executes the logic of how amounts are
+ *   changed when digital assets are merged, separated, or otherwise
+ *   manipulated. For example, a deposit of 2 bucks into a purse that already
+ *   has 3 bucks gives a new purse balance of 5 bucks. An empty purse has 0
+ *   bucks. AmountMath relies heavily on polymorphic MathHelpers, which
+ *   manipulate the unbranded portion.
  */
 type Amount<K extends AssetKind = AssetKind> = {
     brand: Brand<K>;
     value: AssetValueForKind<K>;
 };
 /**
- * An `AmountValue` describes a set or quantity of assets that can be owned or
- * shared.
+ * An
+ *   `AmountValue` describes a set or quantity of assets that can be owned or
+ *   shared.
  *
- * A fungible `AmountValue` uses a non-negative bigint to represent a quantity
- * of that many assets.
+ *   A fungible `AmountValue` uses a non-negative bigint to represent a quantity
+ *   of that many assets.
  *
- * A non-fungible `AmountValue` uses an array or CopySet of `Key`s to represent
- * a set of whatever asset each key represents. A `Key` is a passable value
- * that can be used as an element in a set (SetStore or CopySet) or as the
- * key in a map (MapStore or CopyMap).
+ *   A non-fungible `AmountValue` uses an array or CopySet of `Key`s to represent
+ *   a set of whatever asset each key represents. A `Key` is a passable value
+ *   that can be used as an element in a set (SetStore or CopySet) or as the key
+ *   in a map (MapStore or CopyMap).
  *
- * `SetValue` is for the deprecated set representation, using an array directly
- * to represent the array of its elements. `CopySet` is the proper
- * representation using a CopySet.
+ *   `SetValue` is for the deprecated set representation, using an array directly
+ *   to represent the array of its elements. `CopySet` is the proper
+ *   representation using a CopySet.
  *
- * A semi-fungible `CopyBag` is represented as a
- * `CopyBag` of `Key` objects. "Bag" is synonymous with MultiSet, where an
- * element of a bag can be present once or more times, i.e., some positive
- * bigint number of times, representing that quantity of the asset represented
- * by that key.
+ *   A semi-fungible `CopyBag` is represented as a `CopyBag` of `Key` objects.
+ *   "Bag" is synonymous with MultiSet, where an element of a bag can be present
+ *   once or more times, i.e., some positive bigint number of times,
+ *   representing that quantity of the asset represented by that key.
  */
 type AmountValue = NatValue | any[] | CopySet | CopyBag;
 /**
- * See doc-comment for `AmountValue`.
+ * See doc-comment
+ *   for `AmountValue`.
  */
 type AssetKind = 'nat' | 'set' | 'copySet' | 'copyBag';
 type AssetValueForKind<K extends AssetKind> = K extends 'nat' ? NatValue : K extends 'set' ? any[] : K extends 'copySet' ? CopySet : K extends 'copyBag' ? CopyBag : never;
 type AssetKindForValue<V extends AmountValue> = V extends NatValue ? 'nat' : V extends any[] ? 'set' : V extends CopySet ? 'copySet' : V extends CopyBag ? 'copyBag' : never;
 type DisplayInfo<K extends AssetKind = AssetKind> = {
     /**
-     * Tells the display software how
-     * many decimal places to move the decimal over to the left, or in
-     * other words, which position corresponds to whole numbers. We
-     * require fungible digital assets to be represented in integers, in
-     * the smallest unit (i.e. USD might be represented in mill, a
-     * thousandth of a dollar. In that case, `decimalPlaces` would be
-     * 3.) This property is optional, and for non-fungible digital
-     * assets, should not be specified. The decimalPlaces property
-     * should be used for *display purposes only*. Any other use is an
+     * Tells the display software how many
+     * decimal places to move the decimal over to the left, or in other words,
+     * which position corresponds to whole numbers. We require fungible digital
+     * assets to be represented in integers, in the smallest unit (i.e. USD might
+     * be represented in mill, a thousandth of a dollar. In that case,
+     * `decimalPlaces` would be 3.) This property is optional, and for
+     * non-fungible digital assets, should not be specified. The decimalPlaces
+     * property should be used for _display purposes only_. Any other use is an
      * anti-pattern.
      */
     decimalPlaces?: number | undefined;
     /**
-     * - the kind of asset, either
-     * AssetKind.NAT (fungible) or
-     * AssetKind.SET or AssetKind.COPY_SET (non-fungible)
+     * - the kind of asset, either AssetKind.NAT (fungible)
+     * or AssetKind.SET or AssetKind.COPY_SET (non-fungible)
      */
     assetKind: K;
 };
 /**
- * The brand identifies the kind of issuer, and has a function to get the
- * alleged name for the kind of asset described. The alleged name (such
- * as 'BTC' or 'moola') is provided by the maker of the issuer and should
- * not be trusted as accurate.
+ * The brand identifies the kind of issuer, and has a
+ *   function to get the alleged name for the kind of asset described. The
+ *   alleged name (such as 'BTC' or 'moola') is provided by the maker of the
+ *   issuer and should not be trusted as accurate.
  *
- * Every amount created by a particular AmountMath will share the same brand,
- * but recipients cannot rely on the brand to verify that a purported amount
- * represents the issuer they intended, since the same brand can be reused by
- * a misbehaving issuer.
+ *   Every amount created by a particular AmountMath will share the same brand,
+ *   but recipients cannot rely on the brand to verify that a purported amount
+ *   represents the issuer they intended, since the same brand can be reused by
+ *   a misbehaving issuer.
  */
 type Brand<K extends AssetKind = AssetKind> = {
     /**
-     * Should be used with `issuer.getBrand` to ensure an issuer and brand match.
+     *   Should be used with `issuer.getBrand` to ensure an issuer and brand match.
      */
     isMyIssuer: (allegedIssuer: ERef<Issuer>) => Promise<boolean>;
     getAllegedName: () => string;
     /**
-     * Give information to UI on how to display the amount.
+     * Give information to UI on how
+     * to display the amount.
      */
     getDisplayInfo: () => DisplayInfo<K>;
     getAmountShape: () => Pattern;
@@ -88,100 +88,91 @@ type Brand<K extends AssetKind = AssetKind> = {
 /**
  * Return true if the payment continues to exist.
  *
- * If the payment is a promise, the operation will proceed upon
- * resolution.
+ *   If the payment is a promise, the operation will proceed upon resolution.
  */
 type IssuerIsLive = (payment: ERef<Payment>) => Promise<boolean>;
 /**
- * Get the amount of digital assets in the payment. Because the
- * payment is not trusted, we cannot call a method on it directly, and
- * must use the issuer instead.
+ * Get the amount of digital assets in the payment.
+ *   Because the payment is not trusted, we cannot call a method on it directly,
+ *   and must use the issuer instead.
  *
- * If the payment is a promise, the operation will proceed upon
- * resolution.
+ *   If the payment is a promise, the operation will proceed upon resolution.
  */
 type IssuerGetAmountOf<K extends AssetKind> = (payment: ERef<Payment>) => Promise<Amount<K>>;
 /**
- * Burn all of the digital assets in the
- * payment. `optAmount` is optional. If `optAmount` is present, the
- * code will insist that the amount of the digital assets in the
- * payment is equal to `optAmount`, to prevent sending the wrong
- * payment and other confusion.
+ * Burn all of the digital assets in the payment.
+ *   `optAmount` is optional. If `optAmount` is present, the code will insist
+ *   that the amount of the digital assets in the payment is equal to
+ *   `optAmount`, to prevent sending the wrong payment and other confusion.
  *
- * If the payment is a promise, the operation will proceed upon
- * resolution.
+ *   If the payment is a promise, the operation will proceed upon resolution.
  */
 type IssuerBurn = (payment: ERef<Payment>, optAmountShape?: Pattern) => Promise<Amount>;
 /**
- * Transfer all digital assets from the payment to a new payment and
- * delete the original. `optAmount` is optional. If `optAmount` is
- * present, the code will insist that the amount of digital assets in
- * the payment is equal to `optAmount`, to prevent sending the wrong
- * payment and other confusion.
+ * Transfer all digital assets from the payment to a new
+ *   payment and delete the original. `optAmount` is optional. If `optAmount` is
+ *   present, the code will insist that the amount of digital assets in the
+ *   payment is equal to `optAmount`, to prevent sending the wrong payment and
+ *   other confusion.
  *
- * If the payment is a promise, the operation will proceed upon
- * resolution.
+ *   If the payment is a promise, the operation will proceed upon resolution.
  */
 type IssuerClaim<K extends AssetKind> = (payment: ERef<Payment<K>>, optAmountShape?: Pattern) => Promise<Payment<K>>;
 /**
  * Combine multiple payments into one payment.
  *
- * If any of the payments is a promise, the operation will proceed
- * upon resolution.
+ *   If any of the payments is a promise, the operation will proceed upon
+ *   resolution.
  */
 type IssuerCombine<K extends AssetKind> = (paymentsArray: ERef<Payment<K>>[], optTotalAmount?: Amount<K> | undefined) => Promise<Payment<K>>;
 /**
- * Split a single payment into two payments,
- * A and B, according to the paymentAmountA passed in.
+ * Split a single payment into two payments, A and B,
+ *   according to the paymentAmountA passed in.
  *
- * If the payment is a promise, the operation will proceed upon
- * resolution.
+ *   If the payment is a promise, the operation will proceed upon resolution.
  */
 type IssuerSplit<K extends AssetKind> = (payment: ERef<Payment<K>>, paymentAmountA: Amount<K>) => Promise<Payment<K>[]>;
 /**
- * Split a single payment into many payments, according to the amounts
- * passed in.
+ * Split a single payment into many payments,
+ *   according to the amounts passed in.
  *
- * If the payment is a promise, the operation will proceed upon
- * resolution.
+ *   If the payment is a promise, the operation will proceed upon resolution.
  */
 type IssuerSplitMany = (payment: ERef<Payment>, amounts: Amount[]) => Promise<Payment[]>;
 /**
- * The issuer cannot mint a new amount, but it can create empty purses
- * and payments. The issuer can also transform payments (splitting
- * payments, combining payments, burning payments, and claiming
- * payments exclusively). The issuer should be gotten from a trusted
- * source and then relied upon as the decider of whether an untrusted
- * payment is valid.
+ * The issuer cannot mint a new amount, but it can
+ *   create empty purses and payments. The issuer can also transform payments
+ *   (splitting payments, combining payments, burning payments, and claiming
+ *   payments exclusively). The issuer should be gotten from a trusted source
+ *   and then relied upon as the decider of whether an untrusted payment is
+ *   valid.
  */
 type Issuer<K extends AssetKind = AssetKind> = {
     /**
-     * Get the Brand for this Issuer. The
-     * Brand indicates the type of digital asset and is shared by the
-     * mint, the issuer, and any purses and payments of this particular
-     * kind. The brand is not closely held, so this function should not be
-     * trusted to identify an issuer alone. Fake digital assets and amount
-     * can use another issuer's brand.
+     * Get the Brand for this Issuer. The Brand
+     * indicates the type of digital asset and is shared by the mint, the issuer,
+     * and any purses and payments of this particular kind. The brand is not
+     * closely held, so this function should not be trusted to identify an issuer
+     * alone. Fake digital assets and amount can use another issuer's brand.
      */
     getBrand: () => Brand<K>;
     /**
-     * Get the allegedName for
-     * this mint/issuer
+     * Get the allegedName for this
+     * mint/issuer
      */
     getAllegedName: () => string;
     /**
-     * Get the kind of
-     * MathHelpers used by this Issuer.
+     * Get the kind of MathHelpers used by
+     * this Issuer.
      */
     getAssetKind: () => AssetKind;
     /**
-     * Give information to UI
-     * on how to display amounts for this issuer.
+     * Give information to UI on how
+     * to display amounts for this issuer.
      */
     getDisplayInfo: () => DisplayInfo<K>;
     /**
-     * Make an empty purse of this
-     * brand.
+     * Make an empty purse of this brand.
      */
     makeEmptyPurse: () => Purse<K>;
     isLive: IssuerIsLive;
@@ -203,15 +194,14 @@ type IssuerKit<K extends AssetKind = AssetKind> = {
 };
 type AdditionalDisplayInfo = {
     /**
-     * Tells the display software how
-     * many decimal places to move the decimal over to the left, or in
-     * other words, which position corresponds to whole numbers. We
-     * require fungible digital assets to be represented in integers, in
-     * the smallest unit (i.e. USD might be represented in mill, a
-     * thousandth of a dollar. In that case, `decimalPlaces` would be
-     * 3.) This property is optional, and for non-fungible digital
-     * assets, should not be specified. The decimalPlaces property
-     * should be used for *display purposes only*. Any other use is an
+     * Tells the display software how many
+     * decimal places to move the decimal over to the left, or in other words,
+     * which position corresponds to whole numbers. We require fungible digital
+     * assets to be represented in integers, in the smallest unit (i.e. USD might
+     * be represented in mill, a thousandth of a dollar. In that case,
+     * `decimalPlaces` would be 3.) This property is optional, and for
+     * non-fungible digital assets, should not be specified. The decimalPlaces
+     * property should be used for _display purposes only_. Any other use is an
      * anti-pattern.
      */
     decimalPlaces?: number | undefined;
@@ -219,8 +209,8 @@ type AdditionalDisplayInfo = {
 };
 type ShutdownWithFailure = import('@agoric/swingset-vat').ShutdownWithFailure;
 /**
- * Holding a Mint carries the right to issue new digital assets. These
- * assets all have the same kind, which is called a Brand.
+ * Holding a Mint carries the right to issue new digital
+ *   assets. These assets all have the same kind, which is called a Brand.
  */
 type Mint<K extends AssetKind = AssetKind> = {
     /**
@@ -228,16 +218,18 @@ type Mint<K extends AssetKind = AssetKind> = {
      */
     getIssuer: () => Issuer<K>;
     /**
-     * Creates a new Payment containing newly minted amount.
+     * Creates a new
+     * Payment containing newly minted amount.
      */
     mintPayment: (newAmount: Amount<K>) => Payment<K>;
 };
 type DepositFacetReceive = (payment: Payment, optAmountShape?: Pattern) => Amount;
 type DepositFacet = {
     /**
-     * Deposit all the contents of payment into the purse that made this facet,
-     * returning the amount. If the optional argument `optAmount` does not equal the
-     * amount of digital assets in the payment, throw an error.
+     * Deposit all the contents of payment
+     * into the purse that made this facet, returning the amount. If the optional
+     * argument `optAmount` does not equal the amount of digital assets in the
+     * payment, throw an error.
      *
      * If payment is a promise, throw an error.
      */
@@ -245,116 +237,125 @@ type DepositFacet = {
 };
 type PurseDeposit<K extends AssetKind> = (payment: Payment<K>, optAmountShape?: Pattern) => Amount<K>;
 /**
- * Purses hold amount of digital assets of the same brand, but unlike Payments,
- * they are not meant to be sent to others. To transfer digital assets, a
- * Payment should be withdrawn from a Purse. The amount of digital
- * assets in a purse can change through the action of deposit() and withdraw().
+ * Purses hold amount of digital assets of the same
+ *   brand, but unlike Payments, they are not meant to be sent to others. To
+ *   transfer digital assets, a Payment should be withdrawn from a Purse. The
+ *   amount of digital assets in a purse can change through the action of
+ *   deposit() and withdraw().
  *
- * The primary use for Purses and Payments is for currency-like and goods-like
- * digital assets, but they can also be used to represent other kinds of rights,
- * such as the right to participate in a particular contract.
+ *   The primary use for Purses and Payments is for currency-like and goods-like
+ *   digital assets, but they can also be used to represent other kinds of
+ *   rights, such as the right to participate in a particular contract.
  */
 type Purse<K extends AssetKind = AssetKind> = {
     /**
-     * Get the alleged Brand for this Purse
+     * Get the alleged Brand for this
+     * Purse
      */
     getAllegedBrand: () => Brand<K>;
     /**
-     * Get the amount contained in this purse.
+     * Get the amount contained in this
+     * purse.
      */
     getCurrentAmount: () => Amount<K>;
     /**
-     * Get a lossy notifier for changes to this purse's balance.
+     * Get a lossy
+     * notifier for changes to this purse's balance.
      */
     getCurrentAmountNotifier: () => LatestTopic<Amount<K>>;
     /**
-     * Deposit all the contents of payment into this purse, returning the
-     * amount. If the optional argument `optAmount` does not equal the
-     * amount of digital assets in the payment, throw an error.
+     * Deposit all the contents of payment into
+     * this purse, returning the amount. If the optional argument `optAmount` does
+     * not equal the amount of digital assets in the payment, throw an error.
      *
      * If payment is a promise, throw an error.
      */
     deposit: PurseDeposit<K>;
     /**
-     * Return an object whose `receive` method deposits to the current Purse.
+     * Return an object whose
+     * `receive` method deposits to the current Purse.
      */
     getDepositFacet: () => DepositFacet;
     /**
-     * Withdraw amount from this purse into a new Payment.
+     * Withdraw amount from
+     * this purse into a new Payment.
      */
     withdraw: (amount: Amount<K>) => Payment<K>;
     /**
-     * The set of payments withdrawn from this purse that are still live. These
-     * are the payments that can still be recovered in emergencies by, for example,
-     * depositing into this purse. Such a deposit action is like canceling an
-     * outstanding check because you're tired of waiting for it. Once your
-     * cancellation is acknowledged, you can spend the assets at stake on other
-     * things. Afterwards, if the recipient of the original check finally gets
-     * around to depositing it, their deposit fails.
+     * The set of payments
+     * withdrawn from this purse that are still live. These are the payments that
+     * can still be recovered in emergencies by, for example, depositing into this
+     * purse. Such a deposit action is like canceling an outstanding check because
+     * you're tired of waiting for it. Once your cancellation is acknowledged, you
+     * can spend the assets at stake on other things. Afterwards, if the recipient
+     * of the original check finally gets around to depositing it, their deposit
+     * fails.
      */
     getRecoverySet: () => CopySet<Payment<K>>;
     /**
-     * For use in emergencies, such as coming back from a traumatic crash and
-     * upgrade. This deposits all the payments in this purse's recovery set
-     * into the purse itself, returning the total amount of assets recovered.
+     * For use in emergencies, such as coming
+     * back from a traumatic crash and upgrade. This deposits all the payments in
+     * this purse's recovery set into the purse itself, returning the total amount
+     * of assets recovered.
      */
     recoverAll: () => Amount<K>;
 };
 /**
- * Payments hold amount of digital assets of the same brand in transit. Payments
- * can be deposited in purses, split into multiple payments, combined, and
- * claimed (getting an exclusive payment). Payments are linear, meaning
- * that either a payment has the same amount of digital assets it
- * started with, or it is used up entirely. It is impossible to partially use a
- * payment.
+ * Payments hold amount of digital assets of the same
+ *   brand in transit. Payments can be deposited in purses, split into multiple
+ *   payments, combined, and claimed (getting an exclusive payment). Payments
+ *   are linear, meaning that either a payment has the same amount of digital
+ *   assets it started with, or it is used up entirely. It is impossible to
+ *   partially use a payment.
  *
- * Payments are often received from other actors and therefore should
- * not be trusted themselves. To get the amount of digital assets in a payment,
- * use the trusted issuer: issuer.getAmountOf(payment),
+ *   Payments are often received from other actors and therefore should not be
+ *   trusted themselves. To get the amount of digital assets in a payment, use
+ *   the trusted issuer: issuer.getAmountOf(payment),
  *
- * Payments can be converted to Purses by getting a trusted issuer and
- * calling `issuer.makeEmptyPurse()` to create a purse, then
- * `purse.deposit(payment)`.
+ *   Payments can be converted to Purses by getting a trusted issuer and calling
+ *   `issuer.makeEmptyPurse()` to create a purse, then
+ *   `purse.deposit(payment)`.
  */
 type Payment<K extends AssetKind = AssetKind> = {
     /**
-     * Get the allegedBrand, indicating the type of digital asset this
-     * payment purports to be, and which issuer to use. Because payments
-     * are not trusted, any method calls on payments should be treated
-     * with suspicion and verified elsewhere.
+     * Get the allegedBrand, indicating
+     * the type of digital asset this payment purports to be, and which issuer to
+     * use. Because payments are not trusted, any method calls on payments should
+     * be treated with suspicion and verified elsewhere.
      */
     getAllegedBrand: () => Brand<K>;
 };
 /**
- * All of the difference in how digital asset amount are manipulated can be
- * reduced to the behavior of the math on values. We extract this
- * custom logic into mathHelpers. MathHelpers are about value
- * arithmetic, whereas AmountMath is about amounts, which are the
- * values labeled with a brand. AmountMath use mathHelpers to do their value
- * arithmetic, and then brand the results, making a new amount.
+ * All of the difference in how digital asset
+ *   amount are manipulated can be reduced to the behavior of the math on
+ *   values. We extract this custom logic into mathHelpers. MathHelpers are
+ *   about value arithmetic, whereas AmountMath is about amounts, which are the
+ *   values labeled with a brand. AmountMath use mathHelpers to do their value
+ *   arithmetic, and then brand the results, making a new amount.
  *
- * The MathHelpers are designed to be called only from AmountMath, and so
- * all methods but coerce can assume their inputs are valid. They only
- * need to do output validation, and only when there is a possibility of
- * invalid output.
+ *   The MathHelpers are designed to be called only from AmountMath, and so all
+ *   methods but coerce can assume their inputs are valid. They only need to do
+ *   output validation, and only when there is a possibility of invalid output.
  */
 type MathHelpers<V extends AmountValue> = {
     /**
-     * Check the kind of this value and throw if it is not the
-     * expected kind.
+     * Check the kind of this value and
+     * throw if it is not the expected kind.
      */
     doCoerce: (allegedValue: V) => V;
     /**
-     * Get the representation for the identity element (often 0 or an
-     * empty array)
+     * Get the representation for the identity
+     * element (often 0 or an empty array)
      */
     doMakeEmpty: () => V;
     /**
-     * Is the value the identity element?
+     * Is the value the identity
+     * element?
      */
     doIsEmpty: (value: V) => boolean;
     /**
-     * Is the left greater than or equal to the right?
+     * Is the left greater than
+     * or equal to the right?
      */
     doIsGTE: (left: V, right: V) => boolean;
     /**
@@ -362,15 +363,17 @@ type MathHelpers<V extends AmountValue> = {
      */
     doIsEqual: (left: V, right: V) => boolean;
     /**
-     * Return the left combined with the right.
+     * Return the left combined with the
+     * right.
      */
     doAdd: (left: V, right: V) => V;
     /**
-     * Return what remains after removing the right from the left. If
-     * something in the right was not in the left, we throw an error.
+     * Return what remains after
+     * removing the right from the left. If something in the right was not in the
+     * left, we throw an error.
      */
     doSubtract: (left: V, right: V) => V;
 };
 type NatValue = bigint;
-type SetValue = Array<Key>;
+type SetValue = Key[];
 //# sourceMappingURL=types-ambient.d.ts.map

package/src/types-ambient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types-ambient.d.ts","sourceRoot":"","sources":["types-ambient.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"types-ambient.d.ts","sourceRoot":"","sources":["types-ambient.js"],"names":[],"mappings":"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"}