@agoric/zoe 0.26.3-dev-da3b8a8.0 → 0.26.3-dev-afcbcd7.0

package/src/contracts/callSpread/fundedCallSpread.d.ts

@@ -1,60 +0,0 @@
-/**
- * This contract implements a fully collateralized call spread. This is a
- * combination of a call option bought at one strike price and a second call
- * option sold at a higher price. The invitations are produced in pairs, and the
- * instance creator escrows upfront all collateral that will be paid out. The
- * individual options are ERTP invitations that are suitable for resale.
- *
- * This option contract is settled financially. There is no requirement that the
- * creator have ownership of the underlying asset at the start, and
- * the beneficiaries shouldn't expect to take delivery at closing.
- *
- * The issuerKeywordRecord specifies the issuers for three keywords: Underlying,
- * Strike, and Collateral. The payout is in Collateral. Strike amounts are used
- * for the price oracle's quotes as to the value of the Underlying, as well as
- * the strike prices in the terms.
- *
- * The creatorInvitation has customDetails that include the amounts of the
- * two options as longAmount and shortAmount. When the creatorInvitation is
- * exercised, the payout includes the two option positions, which are themselves
- * invitations which can be exercised for free, and provide the option payouts
- * with the keyword Collateral.
- *
- * terms include:
- * `timer` is a timer, and must be recognized by `priceAuthority`.
- * `expiration` is a time recognized by the `timer`.
- * `underlyingAmount` is passed to `priceAuthority`. It could be an NFT or a
- *   fungible amount.
- * `strikePrice2` must be greater than `strikePrice1`.
- * `settlementAmount` is the amount deposited by the funder and split between
- *   the holders of the options. It uses Collateral.
- * `priceAuthority` is an oracle that has a timer so it can respond to requests
- *   for prices as of a stated time. After the deadline, it will issue a
- *   PriceQuote giving the value of the underlying asset in the strike currency.
- *
- * Future enhancements:
- * + issue multiple option pairs with the same expiration from a single instance
- * + increase the precision of the calculations. (use Ratios with
- *   denominator.value=10000)
- */
-/**
- * @param {ZCF<{
- * strikePrice1: Amount,
- * strikePrice2: Amount,
- * settlementAmount: Amount,
- * priceAuthority: PriceAuthority,
- * expiration: bigint,
- * underlyingAmount: Amount,
- * }>} zcf
- */
-export function start(zcf: ZCF<{
-    strikePrice1: Amount;
-    strikePrice2: Amount;
-    settlementAmount: Amount;
-    priceAuthority: PriceAuthority;
-    expiration: bigint;
-    underlyingAmount: Amount;
-}>): Promise<{
-    creatorInvitation: Promise<Invitation<R, A>>;
-}>;
-//# sourceMappingURL=fundedCallSpread.d.ts.map

package/src/contracts/callSpread/fundedCallSpread.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fundedCallSpread.d.ts","sourceRoot":"","sources":["fundedCallSpread.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;GASG;AACH;kBARiB,MAAM;kBACN,MAAM;sBACF,MAAM;oBACR,cAAc;gBAClB,MAAM;sBACA,MAAM;;;GA8E1B"}

package/src/contracts/callSpread/payoffHandler.d.ts

@@ -1,11 +0,0 @@
-/**
- * makePayoffHandler returns an object with methods that are useful for
- * callSpread contracts.
- *
- * @param {ZCF<Record<string, any>>} zcf
- * @param {Record<PositionKind,PromiseRecord<ZCFSeat>>} seatPromiseKits
- * @param {ZCFSeat} collateralSeat
- * @returns {PayoffHandler}
- */
-export function makePayoffHandler(zcf: ZCF<Record<string, any>>, seatPromiseKits: Record<PositionKind, PromiseRecord<ZCFSeat>>, collateralSeat: ZCFSeat): PayoffHandler;
-//# sourceMappingURL=payoffHandler.d.ts.map

package/src/contracts/callSpread/payoffHandler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"payoffHandler.d.ts","sourceRoot":"","sources":["payoffHandler.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH,uCALW,IAAI,OAAO,MAAM,EAAE,GAAG,CAAC,CAAC,mBACxB,OAAO,YAAY,EAAC,cAAc,OAAO,CAAC,CAAC,kBAC3C,OAAO,GACL,aAAa,CAgEzB"}

package/src/contracts/callSpread/percent.d.ts

@@ -1,3 +0,0 @@
-export function make100Percent(brand: Brand<AssetKind>): Ratio;
-export function make0Percent(brand: Brand<AssetKind>): Ratio;
-//# sourceMappingURL=percent.d.ts.map

package/src/contracts/callSpread/percent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"percent.d.ts","sourceRoot":"","sources":["percent.js"],"names":[],"mappings":"AAe+9B,+DAAsE;AAAW,6DAAoE"}

package/src/contracts/callSpread/position.d.ts

@@ -1,10 +0,0 @@
-/**
- * Constants for long and short positions.
- *
- * @type {{ LONG: 'long', SHORT: 'short' }}
- */
-export const Position: {
-    LONG: 'long';
-    SHORT: 'short';
-};
-//# sourceMappingURL=position.d.ts.map

package/src/contracts/callSpread/position.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"position.d.ts","sourceRoot":"","sources":["position.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,uBAFU;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAKxC"}

package/src/contracts/callSpread/pricedCallSpread.d.ts

@@ -1,66 +0,0 @@
-/**
- * This contract implements a fully collateralized call spread. This is a
- * combination of a call option bought at one strike price and a second call
- * option sold at a higher price. The invitations are produced in pairs. The
- * creatorFacet has a method makeInvitationPair(longCollateralShare) whose
- * argument must be a number between 0 and 100. makeInvitationPair() returns two
- * invitations which require depositing amounts summing to the settlement amount
- * in the proportions longCollateralShare and (100 - longCollateralShare) to
- * redeem the respective options/invitations. (They are returned under the
- * Keyword 'Option'.) The options are ERTP invitations that are suitable for
- * resale.
- *
- * This option contract is settled financially. There is no requirement that the
- * creator have ownership of the underlying asset at the start, and
- * the beneficiaries shouldn't expect to take delivery at closing.
- *
- * The issuerKeywordRecord specifies the issuers for three keywords: Underlying,
- * Strike, and Collateral. The payout is in Collateral. Strike amounts are used
- * for the price oracle's quotes as to the value of the Underlying, as well as
- * the strike prices in the terms.
- *
- * terms include:
- * `timer` is a timer, and must be recognized by `priceAuthority`.
- * `expiration` is a time recognized by the `timer`.
- * `underlyingAmount` is passed to `priceAuthority`. It could be an NFT or a
- *   fungible amount.
- * `strikePrice2` must be greater than `strikePrice1`.
- * `settlementAmount` is the amount deposited by the funder and split between
- *   the holders of the options. It uses Collateral.
- * `priceAuthority` is an oracle that has a timer so it can respond to requests
- *   for prices as of a stated time. After the deadline, it will issue a
- *   PriceQuote giving the value of the underlying asset in the strike currency.
- *
- * Future enhancements:
- * + issue multiple option pairs with the same expiration from a single instance
- *
- * @param {ZCF<{
- * strikePrice1: Amount<'nat'>,
- * strikePrice2: Amount<'nat'>,
- * settlementAmount: Amount<'nat'>,
- * priceAuthority: PriceAuthority,
- * expiration: bigint,
- * underlyingAmount: Amount<'nat'>,
- * }>} zcf
- */
-export function start(zcf: ZCF<{
-    strikePrice1: Amount<'nat'>;
-    strikePrice2: Amount<'nat'>;
-    settlementAmount: Amount<'nat'>;
-    priceAuthority: PriceAuthority;
-    expiration: bigint;
-    underlyingAmount: Amount<'nat'>;
-}>): {
-    creatorFacet: {
-        makeInvitationPair: (longCollateralShare: any) => {
-            longInvitation: Promise<Invitation<R, A>>;
-            shortInvitation: Promise<Invitation<R, A>>;
-        };
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        makeInvitationPair: (longCollateralShare: any) => {
-            longInvitation: Promise<Invitation<R, A>>;
-            shortInvitation: Promise<Invitation<R, A>>;
-        };
-    }>;
-};
-//# sourceMappingURL=pricedCallSpread.d.ts.map

package/src/contracts/callSpread/pricedCallSpread.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pricedCallSpread.d.ts","sourceRoot":"","sources":["pricedCallSpread.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH;kBARiB,OAAO,KAAK,CAAC;kBACb,OAAO,KAAK,CAAC;sBACT,OAAO,KAAK,CAAC;oBACf,cAAc;gBAClB,MAAM;sBACA,OAAO,KAAK,CAAC;;;;;;;;;;;;;EA0GjC"}

package/src/contracts/callSpread/types.d.ts

@@ -1,30 +0,0 @@
-type PositionKind = 'long' | 'short';
-type MakeOptionInvitation = (positionKind: PositionKind) => Promise<Invitation>;
-type PayoffHandler = {
-    schedulePayoffs: () => void;
-    makeOptionInvitation: MakeOptionInvitation;
-};
-/**
- * Return value from calculateShares, which represents the portions assigned to
- * the long and short side of a transaction. These will be two non-negative
- * integers that sum to 100.
- */
-type CalculateSharesReturn = {
-    longShare: Ratio;
-    shortShare: Ratio;
-};
-/**
- * calculate the portion (as a percentage) of the collateral that should be
- * allocated to the long side of a call spread contract. price gives the value
- * of the underlying asset at closing that determines the payouts to the parties
- *
- * if price <= strikePrice1, return Ratio representing 0
- * if price >= strikePrice2, return Ratio representing 1.
- * Otherwise return longShare and shortShare representing ratios between 0% and
- * 100% reflecting the position of the price in the range from strikePrice1 to
- * strikePrice2.
- */
-type CalculateShares = (collateralBrand: Brand, price: Amount<'nat'>, strikePrice1: Amount<'nat'>, strikePrice2: Amount<'nat'>) => CalculateSharesReturn;
-type Make100Percent = (brand: Brand) => Ratio;
-type Make0Percent = (brand: Brand) => Ratio;
-//# sourceMappingURL=types.d.ts.map

package/src/contracts/callSpread/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"oBACa,MAAM,GAAG,OAAO;2CAKlB,YAAY,KACV,QAAQ,UAAU,CAAC;;qBAKlB,MAAM,IAAI;0BACT,oBAAoB;;;;;;;;eAQrB,KAAK;gBACL,KAAK;;;;;;;;;;;;;yCAcR,KAAK,SACL,OAAO,KAAK,CAAC,gBACb,OAAO,KAAK,CAAC,gBACb,OAAO,KAAK,CAAC,KACX,qBAAqB;8BAKvB,KAAK,KACH,KAAK;4BAKP,KAAK,KACH,KAAK"}

package/src/contracts/coveredCall-durable.d.ts

@@ -1,23 +0,0 @@
-/**
- * @see comment on functionality in ./coveredCall.js.
- *
- * This variant has been made durable and upgradeable. The exerciser survives
- * upgrade so the exerciseOption invitation will continue to work after upgrade.
- *
- * The version in
- * zoe/test/swingsetTests/upgradeCoveredCall/coveredCall-durable-V3.js
- * has some minor changes so tests can verify that upgrading from this to that
- * preserves usefulness of the invitation.
- *
- * @param {ZCF} zcf
- * @param {unknown} _privateArgs
- * @param {import('@agoric/vat-data').Baggage} instanceBaggage
- */
-export function start(zcf: ZCF, _privateArgs: unknown, instanceBaggage: MapStore<string, any>): Promise<{
-    creatorFacet: {
-        makeInvitation(): Promise<Invitation<R, A>>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        makeInvitation(): Promise<Invitation<R, A>>;
-    }>;
-}>;
-//# sourceMappingURL=coveredCall-durable.d.ts.map

package/src/contracts/coveredCall-durable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"coveredCall-durable.d.ts","sourceRoot":"","sources":["coveredCall-durable.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;GAcG;AACH,2BAJW,GAAG,gBACH,OAAO;;;;;;GA8EjB"}

package/src/contracts/coveredCall.d.ts

@@ -1,64 +0,0 @@
-/**
- * A call option is the right (but not the obligation) to buy digital
- * assets at a pre-determined price, called the strike price. This
- * call option is "covered," meaning that the owner of the digital
- * assets must put the assets in escrow. This guarantees that the
- * assets can be transferred without relying on the owner of the
- * digital assets to keep their promise.
- *
- * https://agoric.com/documentation/zoe/guide/contracts/covered-call.html
- *
- * The call option has an expiration date, when the opportunity is
- * cancelled. The owner of the digital assets cannot remove the assets
- * from escrow before the expiration date.
- *
- * The `creatorInvitation` of this contract is an invitation to escrow
- * the underlying assets. The proposal to escrow assets can have any
- * `give` and `want` with any keywords. Any number of assets of
- * different brands can be escrowed under different keywords. The
- * proposal must have an exit record with the key "afterDeadline":
- * {
- *    give: { ... },
- *    want: { ... },
- *    exit: {
- *      afterDeadline: { deadline: time, timer: myTimer }
- *    },
- * }
- *
- * This deadline serves as the expiration date for the covered call
- * option. After this deadline, if the option has not been exercised,
- * the underlying assets are automatically paid out to the creator of
- * the contract as a refund.
- *
- * After the owner of the digital assets escrows the assets in the
- * initial offer, they receive a seat. The payout for this seat will
- * either be a refund of the underlying assets (as mentioned above) or
- * payments in the amount of the strike price. Zoe's enforcement of
- * offer safety guarantees that the payout is either a refund or
- * payments in the amount of the strike price, regardless of whether
- * this contract is buggy.
- *
- * The offerResult of this initial seat resolves to the call option
- * itself: an inspectable invitation to buy the underlying assets. The
- * call option invitation has this additional information in the
- * value: {expirationDate, timeAuthority, underlyingAssets,
- * strikePrice }
- *
- * The invitation itself can be traded as a valuable digital asset: a
- * covered call option.
- *
- * The recipient of a covered call option (buying it on some other
- * exchange or through some other trading contract) can exercise the
- * option before the deadline by using the option as an invitation to
- * this contract, paying the strike price and receiving the underlying
- * assets. The recipient of a covered call option can use whatever
- * keywords they wish, as long as they give the strike price as
- * specified in the invitation value, and want the underlying assets
- * exactly.
- *
- * @param {ZCF} zcf
- */
-export function start(zcf: ZCF): {
-    creatorInvitation: Promise<Invitation<R, A>>;
-};
-//# sourceMappingURL=coveredCall.d.ts.map

package/src/contracts/coveredCall.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"coveredCall.d.ts","sourceRoot":"","sources":["coveredCall.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,2BAFW,GAAG;;EA6Cb"}

package/src/contracts/exported.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=exported.d.ts.map

package/src/contracts/exported.d.ts.map

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

package/src/contracts/loan/addCollateral.d.ts

@@ -1,3 +0,0 @@
-/** @type {MakeAddCollateralInvitation} */
-export const makeAddCollateralInvitation: MakeAddCollateralInvitation;
-//# sourceMappingURL=addCollateral.d.ts.map

package/src/contracts/loan/addCollateral.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"addCollateral.d.ts","sourceRoot":"","sources":["addCollateral.js"],"names":[],"mappings":"AAUA,0CAA0C;AAC1C,0CADW,2BAA2B,CAwBpC"}

package/src/contracts/loan/borrow.d.ts

@@ -1,3 +0,0 @@
-/** @type {MakeBorrowInvitation} */
-export const makeBorrowInvitation: MakeBorrowInvitation;
-//# sourceMappingURL=borrow.d.ts.map

package/src/contracts/loan/borrow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"borrow.d.ts","sourceRoot":"","sources":["borrow.js"],"names":[],"mappings":"AAkBA,mCAAmC;AACnC,mCADW,oBAAoB,CAiI7B"}

package/src/contracts/loan/close.d.ts

@@ -1,3 +0,0 @@
-/** @type {MakeCloseLoanInvitation} */
-export const makeCloseLoanInvitation: MakeCloseLoanInvitation;
-//# sourceMappingURL=close.d.ts.map

package/src/contracts/loan/close.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"close.d.ts","sourceRoot":"","sources":["close.js"],"names":[],"mappings":"AAYA,sCAAsC;AACtC,sCADW,uBAAuB,CAiDhC"}

package/src/contracts/loan/index.d.ts

@@ -1,64 +0,0 @@
-/**
- * Add collateral of a particular brand and get a loan of another
- * brand. Collateral (also known as margin) must be greater than the
- * loan value, at an amount set by the Maintenance Margin Requirement
- * (mmr) in the terms of the contract. The loan does not have a
- * distinct end time. Rather, if the value of the collateral changes
- * such that insufficient margin is provided, the collateral is
- * liquidated, and the loan is closed. At any time, the borrower can
- * add collateral or repay the loan with interest, closing the loan.
- * The borrower can set up their own margin calls by getting the
- * `priceAuthority` from the terms and calling
- * `E(priceAuthority).quoteWhenLT(allCollateral, x)` where x is the
- * value of the collateral in the Loan brand at which they want a
- * reminder to addCollateral.
- *
- * Note that all collateral must be of the same brand and all of the
- * loaned amount and interest must be of the same (separate) brand.
- *
- * Terms:
- *  * mmr (default = 150/100) - the Maintenance Margin Requirement, as a
- *    ratio. The default is 150/100, meaning that collateral should be
- *    worth at least 150% of the loan. If the value of the collateral
- *    drops below mmr, liquidation occurs.
- *  * priceAuthority - will be used for getting the current value of
- *    collateral and setting liquidation triggers.
- *  * autoswapInstance - The running contract instance for an Autoswap
- *    installation. The publicFacet of the
- *    instance is used for producing an invitation to sell the
- *    collateral on liquidation.
- *  * periodNotifier - the Notifier that provides notifications that
- *    periods have passed, on which compound interest will be
- *    calculated using the interestRate. Notifiers don't guarantee
- *    that clients will see all the changes, so the contract must
- *    track when interest last accrued.
- *  * interestRate - the rate in basis points that will be multiplied
- *    with the debt on every period to compound interest.
- *  * interestPeriod - the period at which interest compounds.
- *
- * IssuerKeywordRecord:
- *  * Keyword: 'Collateral' - The issuer for the digital assets to be
- *    escrowed as collateral.
- *  * Keyword: 'Loan' - The issuer for the digital assets to be loaned
- *    out.
- *
- * @param {ZCF<{
- *   mmr: Ratio,
- *   autoswapInstance: Instance,
- *   priceAuthority: PriceAuthority,
- *   periodNotifier: PeriodNotifier,
- *   interestRate: Ratio,
- *   interestPeriod: bigint,
- * }>} zcf
- */
-export function start(zcf: ZCF<{
-    mmr: Ratio;
-    autoswapInstance: Instance;
-    priceAuthority: PriceAuthority;
-    periodNotifier: PeriodNotifier;
-    interestRate: Ratio;
-    interestPeriod: bigint;
-}>): Promise<{
-    creatorInvitation: Promise<Invitation<R, A>>;
-}>;
-//# sourceMappingURL=index.d.ts.map

package/src/contracts/loan/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH;SARU,KAAK;sBACQ,QAAQ;oBACV,cAAc;oBACd,cAAc;kBAChB,KAAK;oBACH,MAAM;;;GAuC1B"}

package/src/contracts/loan/lend.d.ts

@@ -1,3 +0,0 @@
-/** @type {MakeLendInvitation} */
-export const makeLendInvitation: MakeLendInvitation;
-//# sourceMappingURL=lend.d.ts.map

package/src/contracts/loan/lend.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lend.d.ts","sourceRoot":"","sources":["lend.js"],"names":[],"mappings":"AAaA,iCAAiC;AACjC,iCADW,kBAAkB,CA4B3B"}

package/src/contracts/loan/liquidate.d.ts

@@ -1,3 +0,0 @@
-export function doLiquidation(zcf: any, collateralSeat: any, autoswapPublicFacetP: any, lenderSeat: any, loanBrand: any): Promise<void>;
-export function liquidate(zcf: ZCF, config: LoanConfigWithBorrower): Promise<void>;
-//# sourceMappingURL=liquidate.d.ts.map

package/src/contracts/loan/liquidate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"liquidate.d.ts","sourceRoot":"","sources":["liquidate.js"],"names":[],"mappings":"AAKO,wIA6CN;AAeM,+BAJI,GAAG,UACH,sBAAsB,GACpB,QAAQ,IAAI,CAAC,CAiBzB"}

package/src/contracts/loan/scheduleLiquidation.d.ts

@@ -1,3 +0,0 @@
-/** @type {ScheduleLiquidation} */
-export const scheduleLiquidation: ScheduleLiquidation;
-//# sourceMappingURL=scheduleLiquidation.d.ts.map

package/src/contracts/loan/scheduleLiquidation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scheduleLiquidation.d.ts","sourceRoot":"","sources":["scheduleLiquidation.js"],"names":[],"mappings":"AAWA,kCAAkC;AAClC,kCADW,mBAAmB,CAsD5B"}

package/src/contracts/loan/types.d.ts

@@ -1,161 +0,0 @@
-/**
- * The Notifier that provides notifications that periods have passed.
- * Since notifiers can't be relied on to produce an output every time
- * they should, we'll track the time of last payment, and catch up if
- * any times have been missed. Compound interest will be calculated
- * using the interestRate.
- */
-type PeriodNotifier = Notifier<import('@agoric/time/src/types').TimestampRecord>;
-/**
- * The running contract instance for an Autoswap installation.  The
- * publicFacet from the Autoswap
- * instance is used for producing an invitation to sell the
- * collateral on liquidation.
- */
-type AutoswapInstance = Instance;
-type LoanTerms = {
-    /**
-     * - Maintenance Margin Requirement, a Ratio record.
-     * Default is 150%
-     */
-    mmr: Ratio;
-    autoswapInstance: AutoswapInstance;
-    /**
-     *   Used for getting the current value of collateral and setting
-     *   liquidation triggers.
-     */
-    priceAuthority: PriceAuthority;
-    periodNotifier: PeriodNotifier;
-    /**
-     *   The rate in basis points that will be multiplied with the debt on
-     *   every period to compound interest.
-     */
-    interestRate: Ratio;
-    interestPeriod: import('@agoric/time/src/types').RelativeTime;
-    loanBrand: Brand;
-    collateralBrand: Brand;
-};
-type LenderSeatProperty = {
-    /**
-     *   The ZCFSeat representing the lender's position in the contract.
-     */
-    lenderSeat: ZCFSeat;
-};
-/**
- * The loan now has a lenderSeat, which is added to the config.
- */
-type LoanConfigWithLender = LoanTerms & LenderSeatProperty;
-type BorrowerConfigProperties = {
-    /**
-     *   The ZCFSeat holding the collateral in escrow after the borrower
-     *   escrows it
-     */
-    collateralSeat: ZCFSeat;
-    /**
-     *   A function to get the current debt
-     */
-    getDebt: () => Amount<'nat'>;
-    /**
-     *   PromiseKit that includes a promise that resolves to a PriceQuote
-     *   when liquidation is triggered
-     */
-    liquidationPromiseKit: PromiseRecord<PriceQuote>;
-};
-type BorrowerConfigPropertiesMinusDebt = {
-    /**
-     *   The ZCFSeat holding the collateral in escrow after the borrower
-     *   escrows it
-     */
-    collateralSeat: ZCFSeat;
-    /**
-     *   PromiseKit that includes a promise that resolves to a PriceQuote
-     *   when liquidation is triggered
-     */
-    liquidationPromiseKit: PromiseRecord<PriceQuote>;
-};
-/**
- * The loan has a lender, a borrower, and collateral escrowed.
- */
-type LoanConfigWithBorrower = LoanConfigWithLender & BorrowerConfigProperties;
-type LoanConfigWithBorrowerMinusDebt = LoanConfigWithLender & BorrowerConfigPropertiesMinusDebt;
-type ScheduleLiquidation = (zcf: ZCF, config: LoanConfigWithBorrower) => any;
-type MakeLendInvitation = (zcf: ZCF, config: LoanTerms) => Promise<Invitation>;
-type MakeBorrowInvitation = (zcf: ZCF, config: LoanConfigWithLender) => Promise<Invitation>;
-type MakeCloseLoanInvitation = (zcf: ZCF, config: LoanConfigWithBorrower) => Promise<Invitation>;
-/**
- * Allows holder to add collateral to the contract. Exits the seat
- * after adding.
- */
-type MakeAddCollateralInvitation = (zcf: ZCF, config: LoanConfigWithBorrower) => Promise<Invitation>;
-type MakeDebtCalculator = (debtCalculatorConfig: DebtCalculatorConfig) => any;
-type CalcInterestFn = (oldDebt: Amount<'nat'>, interestRate: Ratio) => Amount<'nat'>;
-type DebtCalculatorConfig = {
-    /**
-     *   A function to calculate the interest, given the debt value and an
-     *   interest rate in basis points.
-     */
-    calcInterestFn: CalcInterestFn;
-    /**
-     *   The debt at the start of the loan, in Loan brand
-     */
-    originalDebt: Amount<'nat'>;
-    /**
-     *   The AsyncIterable to notify when a period has occurred
-     */
-    periodNotifier: PeriodNotifier;
-    interestRate: Ratio;
-    /**
-     *  the period at which the outstanding debt increases by the interestRate
-     */
-    interestPeriod: import('@agoric/time/src/types').RelativeTime;
-    zcf: ZCF;
-    configMinusGetDebt: LoanConfigWithBorrowerMinusDebt;
-    /**
-     * The starting point from which to calculate
-     * interest.
-     */
-    basetime: import('@agoric/time/src/types').Timestamp;
-};
-type ConfigMinusGetDebt = {
-    collateralSeat: ZCFSeat;
-    liquidationPromiseKit: PromiseRecord<any>;
-    mmr?: bigint | undefined;
-    autoswapInstance: Handle<'Instance'>;
-    priceAuthority: PriceAuthority;
-    periodNotifier: PeriodNotifier;
-    interestRate: bigint;
-    interestPeriod: import('@agoric/time/src/types').RelativeTime;
-    lenderSeat: ZCFSeat;
-};
-type BorrowFacet = {
-    /**
-     * Make an invitation to close the loan by repaying the debt
-     *   (including interest).
-     */
-    makeCloseLoanInvitation: () => Promise<Invitation>;
-    /**
-     * Make an invitation to add collateral to protect against liquidation
-     */
-    makeAddCollateralInvitation: () => Promise<Invitation>;
-    /**
-     * Get a promise for a priceQuote that will resolve if liquidation
-     * occurs. The priceQuote is for the value of the collateral that
-     * triggered the liquidation. This may be lower than expected if the
-     * price is moving quickly.
-     */
-    getLiquidationPromise: () => Promise<PriceQuote>;
-    /**
-     * Get the timestamp at which the debt was most recently recalculated.
-     */
-    getLastCalculationTimestamp: () => import('@agoric/time/src/types').Timestamp;
-    /**
-     * Get a Notifier that will be updated when the current debt (an Amount with the Loan
-     * Brand) changes. This will increase as interest is added.
-     */
-    getDebtNotifier: () => Notifier<Amount>;
-    /**
-     * Get a recent report of the amount of collateral in the loan
-     */
-    getRecentCollateralAmount: () => Amount;
-};
-//# sourceMappingURL=types.d.ts.map

package/src/contracts/loan/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";;;;;;;sBACa,SAAS,OAAO,wBAAwB,EAAE,eAAe,CAAC;;;;;;;wBAU1D,QAAQ;;;;;;SAUP,KAAK;sBAGL,gBAAgB;;;;;oBAEhB,cAAc;oBAKd,cAAc;;;;;kBAEd,KAAK;oBAIL,OAAO,wBAAwB,EAAE,YAAY;eAE7C,KAAK;qBACL,KAAK;;;;;;gBAKL,OAAO;;;;;4BAMR,SAAS,GAAG,kBAAkB;;;;;;oBAQ7B,OAAO;;;;aAKP,MAAM,OAAO,KAAK,CAAC;;;;;2BAInB,cAAc,UAAU,CAAC;;;;;;;oBASzB,OAAO;;;;;2BAKP,cAAc,UAAU,CAAC;;;;;8BAO1B,oBAAoB,GAAG,wBAAwB;uCAM/C,oBAAoB,GAAG,iCAAiC;iCAM1D,GAAG,UACH,sBAAsB;gCAKtB,GAAG,UACH,SAAS,KACP,QAAQ,UAAU,CAAC;kCAKrB,GAAG,UACH,oBAAoB,KAClB,QAAQ,UAAU,CAAC;qCAKrB,GAAG,UACH,sBAAsB,KACpB,QAAQ,UAAU,CAAC;;;;;yCAQrB,GAAG,UACH,sBAAsB,KACpB,QAAQ,UAAU,CAAC;iDAKrB,oBAAoB;gCAKpB,OAAO,KAAK,CAAC,gBACb,KAAK,KACH,OAAO,KAAK,CAAC;;;;;;oBAKZ,cAAc;;;;kBAKd,OAAO,KAAK,CAAC;;;;oBAIb,cAAc;kBAId,KAAK;;;;oBACL,OAAO,wBAAwB,EAAE,YAAY;SAI7C,GAAG;wBAEH,+BAA+B;;;;;cAC/B,OAAO,wBAAwB,EAAE,SAAS;;;oBAM1C,OAAO;2BACP,cAAc,GAAG,CAAC;;sBAElB,OAAO,UAAU,CAAC;oBAClB,cAAc;oBACd,cAAc;kBACd,MAAM;oBACN,OAAO,wBAAwB,EAAE,YAAY;gBAC7C,OAAO;;;;;;;6BAMP,MAAM,QAAQ,UAAU,CAAC;;;;iCAKzB,MAAM,QAAQ,UAAU,CAAC;;;;;;;2BAIzB,MAAM,QAAQ,UAAU,CAAC;;;;iCAOzB,MAAM,OAAO,wBAAwB,EAAE,SAAS;;;;;qBAIhD,MAAM,SAAS,MAAM,CAAC;;;;+BAKtB,MAAM,MAAM"}

package/src/contracts/loan/updateDebt.d.ts

@@ -1,11 +0,0 @@
-/**
- * @type {CalcInterestFn} Calculate the interest using an interest
- * rate in basis points.
- * i.e. oldDebtValue is 40,000
- * interestRate (in basis points) is 5 = 5/10,000
- * interest charged this period is 20 loan brand
- */
-export const calculateInterest: CalcInterestFn;
-/** @type {MakeDebtCalculator} */
-export const makeDebtCalculator: MakeDebtCalculator;
-//# sourceMappingURL=updateDebt.d.ts.map

package/src/contracts/loan/updateDebt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"updateDebt.d.ts","sourceRoot":"","sources":["updateDebt.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,gCANU,cAAc,CAOgB;AAExC,iCAAiC;AACjC,iCADW,kBAAkB,CAyE3B"}

package/src/contracts/mintAndSellNFT.d.ts

@@ -1,28 +0,0 @@
-/**
- * This contract mints non-fungible tokens and creates a selling contract
- * instance to sell the tokens in exchange for some sort of money.
- *
- * startInstance() returns a creatorFacet which is a
- * ticketMaker with a `.sellTokens()` method. `.sellTokens()` takes a
- * specification of what is being sold, such as:
- * {
- *   customValueProperties: { ...arbitrary },
- *   count: 3n,
- *   moneyIssuer: moolaIssuer,
- *   sellItemsInstallationHandle,
- *   pricePerItem: AmountMath.make(moolaBrand, 20n),
- * }
- * The payouts are returned as an offerResult in the `outcome`, and an API that
- * allows selling the tickets that were produced. You can reuse the ticket maker
- * to mint more tickets (e.g. for a separate show.)
- *
- * @param {ZCF<{
- * tokenName: string,
- * }>} zcf
- */
-export function start(zcf: ZCF<{
-    tokenName: string;
-}>): {
-    creatorFacet: MintAndSellNFTCreatorFacet;
-};
-//# sourceMappingURL=mintAndSellNFT.d.ts.map

package/src/contracts/mintAndSellNFT.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mintAndSellNFT.d.ts","sourceRoot":"","sources":["mintAndSellNFT.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;eAHc,MAAM;;;EA6FnB"}