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

package/src/purse.d.ts

@@ -0,0 +1,13 @@
+export function preparePurseKind(issuerBaggage: any, name: any, assetKind: any, brand: any, PurseIKit: any, purseMethods: any): () => {
+    deposit(srcPayment: any, optAmountShape?: undefined): any;
+    withdraw(amount: any): any;
+    getCurrentAmount(): Amount<any>;
+    getCurrentAmountNotifier(): Notifier<any>;
+    getAllegedBrand(): any;
+    getDepositFacet(): {
+        receive(...args: any[]): any;
+    };
+    getRecoverySet(): CopySet<Payment<AssetKind>>;
+    recoverAll(): Amount<any>;
+};
+//# sourceMappingURL=purse.d.ts.map

package/src/purse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purse.d.ts","sourceRoot":"","sources":["purse.js"],"names":[],"mappings":"AAOO;;;;;;;;;;;EAkHN"}

package/src/purse.js

@@ -3,26 +3,8 @@ import { prepareExoClassKit, makeScalarBigSetStore } from '@agoric/vat-data';
 import { AmountMath } from './amountMath.js';
 import { makeTransientNotifierKit } from './transientNotifier.js';
 
-// TODO `InterfaceGuard` type parameter
-/** @typedef {import('@endo/patterns').InterfaceGuard} InterfaceGuard */
-/** @typedef {import('@agoric/vat-data').Baggage} Baggage */
-
 const { Fail } = assert;
 
-/**
- * @param {Baggage} issuerBaggage
- * @param {string} name
- * @param {AssetKind} assetKind
- * @param {Brand} brand
- * @param {{
- *   purse: InterfaceGuard;
- *   depositFacet: InterfaceGuard;
- * }} PurseIKit
- * @param {{
- *   depositInternal: any;
- *   withdrawInternal: any;
- * }} purseMethods
- */
 export const preparePurseKind = (
   issuerBaggage,
   name,

package/src/transientNotifier.d.ts

@@ -0,0 +1,5 @@
+export function makeTransientNotifierKit(): {
+    provideNotifier: (key: any) => Notifier<any>;
+    update: (key: any, newValue: any) => void;
+};
+//# sourceMappingURL=transientNotifier.d.ts.map

package/src/transientNotifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transientNotifier.d.ts","sourceRoot":"","sources":["transientNotifier.js"],"names":[],"mappings":"AAQO;;;EAoBN"}

package/src/typeGuards.d.ts

@@ -0,0 +1,42 @@
+export const BrandShape: import("@endo/patterns").Matcher;
+export const IssuerShape: import("@endo/patterns").Matcher;
+export const PaymentShape: import("@endo/patterns").Matcher;
+export const PurseShape: import("@endo/patterns").Matcher;
+export const DepositFacetShape: import("@endo/patterns").Matcher;
+export const NotifierShape: import("@endo/patterns").Matcher;
+export const MintShape: import("@endo/patterns").Matcher;
+export namespace AmountShape {
+    export { BrandShape as brand };
+    export { AmountValueShape as value };
+}
+export namespace RatioShape {
+    export { AmountShape as numerator };
+    export { AmountShape as denominator };
+}
+export function isNatValue(value: AmountValue): value is bigint;
+export function isCopySetValue(value: AmountValue): value is CopySet<any>;
+export function isSetValue(value: AmountValue): value is SetValue;
+export function isCopyBagValue(value: AmountValue): value is CopyBag<any>;
+export const MAX_ABSOLUTE_DECIMAL_PLACES: 100;
+export const AssetKindShape: import("@endo/patterns").Matcher;
+export const DisplayInfoShape: import("@endo/patterns").Matcher;
+export namespace IssuerKitShape {
+    export { BrandShape as brand };
+    export { MintShape as mint };
+    export { PurseShape as mintRecoveryPurse };
+    export { IssuerShape as issuer };
+    export { DisplayInfoShape as displayInfo };
+}
+export const BrandI: import("@endo/patterns").InterfaceGuard;
+export function makeIssuerInterfaces(brandShape?: Pattern, assetKindShape?: Pattern, amountShape?: Pattern): {
+    IssuerI: import("@endo/patterns").InterfaceGuard;
+    MintI: import("@endo/patterns").InterfaceGuard;
+    PaymentI: import("@endo/patterns").InterfaceGuard;
+    PurseIKit: {
+        purse: import("@endo/patterns").InterfaceGuard;
+        depositFacet: import("@endo/patterns").InterfaceGuard;
+    };
+};
+declare const AmountValueShape: import("@endo/patterns").Matcher;
+export {};
+//# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

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

package/src/typeGuards.js

@@ -1,6 +1,6 @@
 // @jessie-check
 
-import { M, matches, getInterfaceGuardPayload } from '@endo/patterns';
+import { M, matches } from '@agoric/store';
 
 export const BrandShape = M.remotable('Brand');
 export const IssuerShape = M.remotable('Issuer');
@@ -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}
  */
@@ -212,7 +218,7 @@ export const makeIssuerInterfaces = (
   });
 
   const DepositFacetI = M.interface('DepositFacet', {
-    receive: getInterfaceGuardPayload(PurseI).methodGuards.deposit,
+    receive: PurseI.methodGuards.deposit,
   });
 
   const PurseIKit = harden({

package/src/types-ambient.d.ts

@@ -0,0 +1,376 @@
+/**
+ * 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.
+ *
+ * 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).
+ *
+ * `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.
+ */
+type AmountValue = NatValue | any[] | CopySet | CopyBag;
+/**
+ * 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
+     * anti-pattern.
+     */
+    decimalPlaces?: number | undefined;
+    /**
+     * - 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.
+ *
+ * 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.
+     */
+    isMyIssuer: (allegedIssuer: ERef<Issuer>) => Promise<boolean>;
+    getAllegedName: () => string;
+    /**
+     * Give information to UI on how to display the amount.
+     */
+    getDisplayInfo: () => DisplayInfo<K>;
+    getAmountShape: () => Pattern;
+};
+/**
+ * Return true if the payment continues to exist.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+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.
+ *
+ * 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.
+ *
+ * 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.
+ */
+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.
+     */
+    getBrand: () => Brand<K>;
+    /**
+     * Get the allegedName for
+     * this mint/issuer
+     */
+    getAllegedName: () => string;
+    /**
+     * Get the kind of
+     * MathHelpers used by this Issuer.
+     */
+    getAssetKind: () => AssetKind;
+    /**
+     * Give information to UI
+     * on how to display amounts for this issuer.
+     */
+    getDisplayInfo: () => DisplayInfo<K>;
+    /**
+     * Make an empty purse of this
+     * brand.
+     */
+    makeEmptyPurse: () => Purse<K>;
+    isLive: IssuerIsLive;
+    getAmountOf: IssuerGetAmountOf<K>;
+    burn: IssuerBurn;
+};
+type PaymentLedger<K extends AssetKind = AssetKind> = {
+    mint: Mint<K>;
+    mintRecoveryPurse: Purse<K>;
+    issuer: Issuer<K>;
+    brand: Brand<K>;
+};
+type IssuerKit<K extends AssetKind = AssetKind> = {
+    mint: Mint<K>;
+    mintRecoveryPurse: Purse<K>;
+    issuer: Issuer<K>;
+    brand: Brand<K>;
+    displayInfo: DisplayInfo;
+};
+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
+     * anti-pattern.
+     */
+    decimalPlaces?: number | undefined;
+    assetKind?: AssetKind | undefined;
+};
+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.
+ */
+type Mint<K extends AssetKind = AssetKind> = {
+    /**
+     * Gets the Issuer for this mint.
+     */
+    getIssuer: () => Issuer<K>;
+    /**
+     * 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.
+     *
+     * If payment is a promise, throw an error.
+     */
+    receive: DepositFacetReceive;
+};
+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().
+ *
+ * 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
+     */
+    getAllegedBrand: () => Brand<K>;
+    /**
+     * Get the amount contained in this purse.
+     */
+    getCurrentAmount: () => Amount<K>;
+    /**
+     * 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.
+     *
+     * If payment is a promise, throw an error.
+     */
+    deposit: PurseDeposit<K>;
+    /**
+     * Return an object whose `receive` method deposits to the current Purse.
+     */
+    getDepositFacet: () => DepositFacet;
+    /**
+     * 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.
+     */
+    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.
+     */
+    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 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)`.
+ */
+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.
+     */
+    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.
+ *
+ * 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.
+     */
+    doCoerce: (allegedValue: V) => V;
+    /**
+     * Get the representation for the identity element (often 0 or an
+     * empty array)
+     */
+    doMakeEmpty: () => V;
+    /**
+     * Is the value the identity element?
+     */
+    doIsEmpty: (value: V) => boolean;
+    /**
+     * Is the left greater than or equal to the right?
+     */
+    doIsGTE: (left: V, right: V) => boolean;
+    /**
+     * Does left equal right?
+     */
+    doIsEqual: (left: V, right: V) => boolean;
+    /**
+     * 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.
+     */
+    doSubtract: (left: V, right: V) => V;
+};
+type NatValue = bigint;
+type SetValue = Array<Key>;
+//# sourceMappingURL=types-ambient.d.ts.map

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

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