@agoric/ertp 0.16.3-dev-ae21a7e.0 → 0.16.3-dev-afcbcd7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/ertp",
-  "version": "0.16.3-dev-ae21a7e.0+ae21a7e",
+  "version": "0.16.3-dev-afcbcd7.0+afcbcd7",
   "description": "Electronic Rights Transfer Protocol (ERTP). A smart contract framework for exchanging electronic rights",
   "type": "module",
   "main": "src/index.js",
@@ -9,7 +9,7 @@
   },
   "scripts": {
     "build": "exit 0",
-    "prepack": "echo \"export {}; \" | cat - src/types-ambient.js > src/types.js && tsc --build tsconfig.build.json",
+    "prepack": "echo \"export {}; \" | cat - src/types-ambient.js > src/types.js && tsc --build --clean tsconfig.build.json",
     "postpack": "git clean -f '*.d.ts*' src/types.js",
     "test": "ava",
     "test:c8": "c8 $C8_OPTIONS ava",
@@ -39,10 +39,10 @@
   },
   "homepage": "https://github.com/Agoric/agoric-sdk#readme",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-ae21a7e.0+ae21a7e",
-    "@agoric/notifier": "0.6.3-dev-ae21a7e.0+ae21a7e",
-    "@agoric/store": "0.9.3-dev-ae21a7e.0+ae21a7e",
-    "@agoric/vat-data": "0.5.3-dev-ae21a7e.0+ae21a7e",
+    "@agoric/assert": "0.6.1-dev-afcbcd7.0+afcbcd7",
+    "@agoric/notifier": "0.6.3-dev-afcbcd7.0+afcbcd7",
+    "@agoric/store": "0.9.3-dev-afcbcd7.0+afcbcd7",
+    "@agoric/vat-data": "0.5.3-dev-afcbcd7.0+afcbcd7",
     "@endo/eventual-send": "^0.17.5",
     "@endo/far": "^0.2.21",
     "@endo/marshal": "^0.8.8",
@@ -51,7 +51,7 @@
     "@endo/promise-kit": "^0.2.59"
   },
   "devDependencies": {
-    "@agoric/swingset-vat": "0.32.3-dev-ae21a7e.0+ae21a7e",
+    "@agoric/swingset-vat": "0.32.3-dev-afcbcd7.0+afcbcd7",
     "@endo/bundle-source": "^2.7.0",
     "@fast-check/ava": "^1.1.5",
     "ava": "^5.3.0",
@@ -83,5 +83,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "ae21a7ea4f28e41bab2278e38458a746abc4114f"
+  "typeCoverage": {
+    "atLeast": 90.37
+  },
+  "gitHead": "afcbcd727d7c9a4c6330d619c7846c9963b1e25a"
 }

package/src/types-ambient.js

@@ -142,52 +142,6 @@
  * @returns {Promise<Amount>}
  */
 
-/**
- * @template {AssetKind} K
- * @callback IssuerClaim 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.
- * @param {ERef<Payment<K>>} payment
- * @param {Pattern} [optAmountShape]
- * @returns {Promise<Payment<K>>}
- */
-
-/**
- * @template {AssetKind} K
- * @callback IssuerCombine Combine multiple payments into one payment.
- *
- *   If any of the payments is a promise, the operation will proceed upon
- *   resolution.
- * @param {ERef<Payment<K>>[]} paymentsArray
- * @param {Amount<K>} [optTotalAmount]
- * @returns {Promise<Payment<K>>}
- */
-
-/**
- * @template {AssetKind} K
- * @callback IssuerSplit 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.
- * @param {ERef<Payment<K>>} payment
- * @param {Amount<K>} paymentAmountA
- * @returns {Promise<Payment<K>[]>}
- */
-
-/**
- * @callback IssuerSplitMany 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.
- * @param {ERef<Payment>} payment
- * @param {Amount[]} amounts
- * @returns {Promise<Payment[]>}
- */
-
 /**
  * @template {AssetKind} [K=AssetKind]
  * @typedef {object} Issuer The issuer cannot mint a new amount, but it can

package/src/types.js

@@ -143,52 +143,6 @@ export {};
  * @returns {Promise<Amount>}
  */
 
-/**
- * @template {AssetKind} K
- * @callback IssuerClaim 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.
- * @param {ERef<Payment<K>>} payment
- * @param {Pattern} [optAmountShape]
- * @returns {Promise<Payment<K>>}
- */
-
-/**
- * @template {AssetKind} K
- * @callback IssuerCombine Combine multiple payments into one payment.
- *
- *   If any of the payments is a promise, the operation will proceed upon
- *   resolution.
- * @param {ERef<Payment<K>>[]} paymentsArray
- * @param {Amount<K>} [optTotalAmount]
- * @returns {Promise<Payment<K>>}
- */
-
-/**
- * @template {AssetKind} K
- * @callback IssuerSplit 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.
- * @param {ERef<Payment<K>>} payment
- * @param {Amount<K>} paymentAmountA
- * @returns {Promise<Payment<K>[]>}
- */
-
-/**
- * @callback IssuerSplitMany 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.
- * @param {ERef<Payment>} payment
- * @param {Amount[]} amounts
- * @returns {Promise<Payment[]>}
- */
-
 /**
  * @template {AssetKind} [K=AssetKind]
  * @typedef {object} Issuer The issuer cannot mint a new amount, but it can

package/src/amountMath.d.ts

@@ -1,54 +0,0 @@
-export function assertValueGetHelpers<V extends AmountValue>(value: V): MathHelpers<V>;
-export namespace AmountMath {
-    export function make<K extends AssetKind>(brand: Brand<K>, allegedValue: AssetValueForKind<K>): Amount<K>;
-    export function coerce<K extends AssetKind>(brand: Brand<K>, allegedAmount: Amount<K>): Amount<K>;
-    export function getValue<K extends AssetKind>(brand: Brand<K>, amount: Amount<K>): AssetValueForKind<K>;
-    export let makeEmpty: {
-        (brand: Brand<AssetKind>): Amount<"nat">;
-        <K extends AssetKind>(brand: Brand<AssetKind>, assetKind: K): Amount<K>;
-    };
-    export function makeEmptyFromAmount<K extends AssetKind>(amount: Amount<K>): Amount<K>;
-    export function isEmpty(amount: Amount<AssetKind>, brand?: Brand<AssetKind> | undefined): boolean;
-    export { isGTE };
-    export function isEqual<K extends AssetKind>(leftAmount: Amount<K>, rightAmount: Amount<K>, brand?: Brand<K> | undefined): boolean;
-    export function add<K extends AssetKind>(leftAmount: Amount<K>, rightAmount: Amount<K>, brand?: Brand<K> | undefined): Amount<K>;
-    export function subtract<K extends AssetKind>(leftAmount: Amount<K>, rightAmount: Amount<K>, brand?: Brand<K> | undefined): Amount<K>;
-    export function min<K extends AssetKind>(x: Amount<K>, y: Amount<K>, brand?: Brand<K> | undefined): Amount<K>;
-    export function max<K extends AssetKind>(x: Amount<K>, y: Amount<K>, brand?: Brand<K> | undefined): Amount<K>;
-}
-/**
- * Constants for the kinds of assets we support.
- *
- * @type {{
- *   NAT: 'nat';
- *   SET: 'set';
- *   COPY_SET: 'copySet';
- *   COPY_BAG: 'copyBag';
- * }}
- */
-export const AssetKind: {
-    NAT: 'nat';
-    SET: 'set';
-    COPY_SET: 'copySet';
-    COPY_BAG: 'copyBag';
-};
-/** @param {Amount} amount */
-export function getAssetKind(amount: Amount): AssetKindForValue<V>;
-/** @param {AssetKind} allegedAK */
-export function assertAssetKind(allegedAK: AssetKind): void;
-/**
- * Returns true if the leftAmount is greater than or equal to the rightAmount.
- * The notion of "greater than or equal to" depends on the kind of amount, as
- * defined by the MathHelpers. For example, whether rectangle A is greater than
- * rectangle B depends on whether rectangle A includes rectangle B as defined by
- * the logic in MathHelpers.
- *
- * @template {AssetKind} K
- * @param {Amount<K>} leftAmount
- * @param {Amount<K>} rightAmount
- * @param {Brand<K>} [brand]
- * @returns {boolean}
- */
-declare function isGTE<K extends AssetKind>(leftAmount: Amount<K>, rightAmount: Amount<K>, brand?: Brand<K> | undefined): boolean;
-export {};
-//# sourceMappingURL=amountMath.d.ts.map

package/src/amountMath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"amountMath.d.ts","sourceRoot":"","sources":["amountMath.js"],"names":[],"mappings":"AAqHO,uFAEkC;;IAwFjC,0GAKL;IAUO,kGAQP;IASS,wGAAyD;;;;;IAwB9C,uFAOpB;IAQQ,kGAOR;;IAYQ,mIAGR;IAcI,iIAIJ;IAcS,sIAIT;IAUI,8GAMqC;IAUrC,8GAMqC;;AAtW5C;;;;;;;;;GASG;AACH,wBAPU;IACT,GAAO,EAAE,KAAK,CAAC;IACf,GAAO,EAAE,KAAK,CAAC;IACf,QAAY,EAAE,SAAS,CAAC;IACxB,QAAY,EAAE,SAAS,CAAC;CACrB,CAOD;AA2VH,6BAA6B;AAC7B,qCADY,MAAM,wBAMjB;AA9VD,mCAAmC;AACnC,2CADY,SAAS,QAIpB;AA2ID;;;;;;;;;;;;GAYG;AACH,0HAFa,OAAO,CAKnB"}

package/src/displayInfo.d.ts

@@ -1,2 +0,0 @@
-export function coerceDisplayInfo(allegedDisplayInfo: AdditionalDisplayInfo, assetKind: AssetKind): DisplayInfo;
-//# sourceMappingURL=displayInfo.d.ts.map

package/src/displayInfo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"displayInfo.d.ts","sourceRoot":"","sources":["displayInfo.js"],"names":[],"mappings":"AAYO,sDAJI,qBAAqB,aACrB,SAAS,GACP,WAAW,CAiBvB"}

package/src/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./amountMath.js";
-export * from "./issuerKit.js";
-export * from "./typeGuards.js";
-//# sourceMappingURL=index.d.ts.map

package/src/index.d.ts.map

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

package/src/issuerKit.d.ts

@@ -1,19 +0,0 @@
-export function prepareIssuerKit<K extends AssetKind>(issuerBaggage: any, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined): IssuerKit<K>;
-export function hasIssuer(baggage: any): any;
-export function makeDurableIssuerKit<K extends AssetKind>(issuerBaggage: any, name: string, assetKind?: K | undefined, displayInfo?: AdditionalDisplayInfo | undefined, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined, { elementShape }?: Partial<{
-    elementShape: Pattern;
-}> | undefined): IssuerKit<K>;
-export function makeIssuerKit<K extends AssetKind = "nat">(name: string, assetKind?: K | undefined, displayInfo?: AdditionalDisplayInfo | undefined, optShutdownWithFailure?: import("@agoric/swingset-vat").ShutdownWithFailure | undefined, { elementShape }?: Partial<{
-    elementShape: Pattern;
-}> | undefined): IssuerKit<K>;
-export type Baggage = import('@agoric/vat-data').Baggage;
-export type IssuerRecord<K extends AssetKind> = {
-    name: string;
-    assetKind: K;
-    displayInfo: AdditionalDisplayInfo;
-    elementShape: Pattern;
-};
-export type IssuerOptionsRecord = Partial<{
-    elementShape: Pattern;
-}>;
-//# sourceMappingURL=issuerKit.d.ts.map

package/src/issuerKit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"issuerKit.d.ts","sourceRoot":"","sources":["issuerKit.js"],"names":[],"mappings":"AA2FO,iLAMN;AASM,6CAAsD;AA+BtD,oFAbI,MAAM;kBAhBqB,OAAO;8BAyC5C;AA6BM,iEAbI,MAAM;kBAzDqB,OAAO;8BAqF1C;sBArLW,OAAO,kBAAkB,EAAE,OAAO;;UAKlC,MAAM;eACN,CAAC;iBACD,qBAAqB;kBACrB,OAAO;;kCAwFP,QAAQ;IAAE,YAAY,EAAE,OAAO,CAAA;CAAE,CAAC"}

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"legacy-payment-helpers.d.ts","sourceRoot":"","sources":["legacy-payment-helpers.js"],"names":[],"mappings":"AA6BO,0HAHI,OAAO,uBAYjB;AAiBM,gIAHI,OAAO,uBA2BjB;AAgBM,2JAUN;AAgBM,oIAFM,QAAQ,OAAO,EAAE,CAAC,CAoB9B"}

package/src/mathHelpers/copyBagMathHelpers.d.ts

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

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

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

package/src/mathHelpers/copySetMathHelpers.d.ts

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

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

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

package/src/mathHelpers/natMathHelpers.d.ts

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"version":3,"file":"natMathHelpers.d.ts","sourceRoot":"","sources":["natMathHelpers.js"],"names":[],"mappings":"AASA;;;;;;;;;;GAUG;AACH,6BAFU,YAAY,QAAQ,CAAC,CAgB5B"}

package/src/mathHelpers/setMathHelpers.d.ts

@@ -1,6 +0,0 @@
-/**
- * @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

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

package/src/payment.d.ts

@@ -1,5 +0,0 @@
-export function preparePaymentKind<K extends AssetKind>(issuerBaggage: any, name: string, brand: Brand<K>, PaymentI: InterfaceGuard): () => Payment<K>;
-export type MethodGuard = import('@endo/patterns').MethodGuard;
-export type InterfaceGuard<T extends Record<string | symbol, import("@endo/patterns").MethodGuard> = Record<string | symbol, import("@endo/patterns").MethodGuard>> = import('@endo/patterns').InterfaceGuard<T>;
-export type Baggage = import('@agoric/vat-data').Baggage;
-//# sourceMappingURL=payment.d.ts.map

package/src/payment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payment.d.ts","sourceRoot":"","sources":["payment.js"],"names":[],"mappings":"AAoBO,kFALI,MAAM,6BAEN,cAAc,oBAgBxB;0BA5Ba,OAAO,gBAAgB,EAAE,WAAW;sKAGrC,OAAO,gBAAgB,EAAE,cAAc,CAAC,CAAC,CAAC;sBAEzC,OAAO,kBAAkB,EAAE,OAAO"}

package/src/paymentLedger.d.ts

@@ -1,3 +0,0 @@
-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 type Baggage = import('@agoric/vat-data').Baggage;
-//# sourceMappingURL=paymentLedger.d.ts.map

package/src/paymentLedger.d.ts.map

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

package/src/purse.d.ts

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

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

package/src/transientNotifier.d.ts

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

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

package/src/typeGuards.d.ts

@@ -1,72 +0,0 @@
-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<{
-    isMyIssuer: import("@endo/patterns").MethodGuard;
-    getAllegedName: import("@endo/patterns").MethodGuard;
-    getDisplayInfo: import("@endo/patterns").MethodGuard;
-    getAmountShape: import("@endo/patterns").MethodGuard;
-}>;
-export function makeIssuerInterfaces(brandShape?: Pattern, assetKindShape?: Pattern, amountShape?: Pattern): {
-    IssuerI: import("@endo/patterns").InterfaceGuard<{
-        getBrand: import("@endo/patterns").MethodGuard;
-        getAllegedName: import("@endo/patterns").MethodGuard;
-        getAssetKind: import("@endo/patterns").MethodGuard;
-        getDisplayInfo: import("@endo/patterns").MethodGuard;
-        makeEmptyPurse: import("@endo/patterns").MethodGuard;
-        isLive: import("@endo/patterns").MethodGuard;
-        getAmountOf: import("@endo/patterns").MethodGuard;
-        burn: import("@endo/patterns").MethodGuard;
-    }>;
-    MintI: import("@endo/patterns").InterfaceGuard<{
-        getIssuer: import("@endo/patterns").MethodGuard;
-        mintPayment: import("@endo/patterns").MethodGuard;
-    }>;
-    PaymentI: import("@endo/patterns").InterfaceGuard<{
-        getAllegedBrand: import("@endo/patterns").MethodGuard;
-    }>;
-    PurseIKit: {
-        purse: import("@endo/patterns").InterfaceGuard<{
-            getAllegedBrand: import("@endo/patterns").MethodGuard;
-            getCurrentAmount: import("@endo/patterns").MethodGuard;
-            getCurrentAmountNotifier: import("@endo/patterns").MethodGuard;
-            deposit: import("@endo/patterns").MethodGuard;
-            getDepositFacet: import("@endo/patterns").MethodGuard;
-            withdraw: import("@endo/patterns").MethodGuard;
-            getRecoverySet: import("@endo/patterns").MethodGuard;
-            recoverAll: import("@endo/patterns").MethodGuard;
-        }>;
-        depositFacet: import("@endo/patterns").InterfaceGuard<{
-            receive: any;
-        }>;
-    };
-};
-declare const AmountValueShape: import("@endo/patterns").Matcher;
-export {};
-//# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

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

package/src/types-ambient.d.ts

@@ -1,380 +0,0 @@
-type CopyBag<K extends unknown = any> = import('@endo/patterns').CopyBag<K>;
-/**
- * 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 = Key[];
-//# sourceMappingURL=types-ambient.d.ts.map

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

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

package/src/types.d.ts

@@ -1,380 +0,0 @@
-export type CopyBag<K extends unknown = any> = import('@endo/patterns').CopyBag<K>;
-/**
- * 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.
- */
-export 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.
- */
-export type AmountValue = NatValue | any[] | CopySet | CopyBag;
-/**
- * See doc-comment
- *   for `AmountValue`.
- */
-export type AssetKind = 'nat' | 'set' | 'copySet' | 'copyBag';
-export type AssetValueForKind<K extends AssetKind> = K extends 'nat' ? NatValue : K extends 'set' ? any[] : K extends 'copySet' ? CopySet : K extends 'copyBag' ? CopyBag : never;
-export type AssetKindForValue<V extends AmountValue> = V extends NatValue ? 'nat' : V extends any[] ? 'set' : V extends CopySet ? 'copySet' : V extends CopyBag ? 'copyBag' : never;
-export 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.
- */
-export 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.
- */
-export 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.
- */
-export 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.
- */
-export 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.
- */
-export 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.
- */
-export 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.
- */
-export 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.
- */
-export 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.
- */
-export 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;
-};
-export type PaymentLedger<K extends AssetKind = AssetKind> = {
-    mint: Mint<K>;
-    mintRecoveryPurse: Purse<K>;
-    issuer: Issuer<K>;
-    brand: Brand<K>;
-};
-export type IssuerKit<K extends AssetKind = AssetKind> = {
-    mint: Mint<K>;
-    mintRecoveryPurse: Purse<K>;
-    issuer: Issuer<K>;
-    brand: Brand<K>;
-    displayInfo: DisplayInfo;
-};
-export 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;
-};
-export 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.
- */
-export 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>;
-};
-export type DepositFacetReceive = (payment: Payment, optAmountShape?: Pattern) => Amount;
-export 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;
-};
-export 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.
- */
-export 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)`.
- */
-export 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.
- */
-export 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;
-};
-export type NatValue = bigint;
-export type SetValue = Key[];
-//# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

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