@agoric/zoe 0.28.0-u23.0 → 0.28.0-u23.1

package/src/contracts/autoswap.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @import {Keyword, OfferHandler, ZCF} from '@agoric/zoe';
+ * @import {AutoswapPublicFacet} from './types.js';
+ * @import {Brand} from '@agoric/ertp';
+ * @import {Amount} from '@agoric/ertp';
+ */
+/**
+ * Autoswap is a rewrite of Uniswap. Please see the documentation for
+ * more https://agoric.com/documentation/zoe/guide/contracts/autoswap.html
+ *
+ * When the contract is instantiated, the two tokens (Central and Secondary) are
+ * specified in the issuerKeywordRecord. There is no behavioral difference
+ * between the two when trading; the names were chosen for consistency with our
+ * constant product AMM. When trading, use the keywords In and Out to specify
+ * the amount to be paid in, and the amount to be received.
+ *
+ * When adding or removing liquidity, the amounts deposited must be in
+ * proportion to the current balances in the pool. The amount of the Central
+ * asset is used as the basis. The Secondary assets must be added in proportion.
+ * If less Secondary is provided than required, we refuse the offer. If more is
+ * provided than is required, we return the excess.
+ *
+ * Before trading can take place, it is necessary to add liquidity using
+ * makeAddLiquidityInvitation(). Separate invitations are available for adding
+ * and removing liquidity, and for doing swaps. Other API operations support
+ * price checks and checking the size of the liquidity pool.
+ *
+ * The swap operation requires either the input amount or the output amount to
+ * be specified. makeSwapInInvitation treats the give amount as definitive,
+ * while makeSwapOutInvitation honors the want amount. With swapIn, a want
+ * amount can be specified, and if the offer can't be satisfied, the offer will
+ * be refunded. Similarly with swapOut, the want amount will be satisfied if
+ * possible. If more is provided as the give amount than necessary, the excess
+ * will be refunded. If not enough is provided, the offer will be refunded.
+ *
+ * The publicFacet can make new invitations (makeSwapInInvitation,
+ * makeSwapOutInvitation, makeAddLiquidityInvitation, and
+ * makeRemoveLiquidityInvitation), tell how much would be paid for a given input
+ * (getInputPrice), or how much would be earned by depositing a specified amount
+ * (getOutputPrice). In addition, there are requests for the LiquidityIssuer
+ * (getLiquidityIssuer), the current outstanding liquidity (getLiquiditySupply),
+ * and the current balances in the pool (getPoolAllocation).
+ *
+ * @param {ZCF} zcf
+ */
+export function start(zcf: ZCF): Promise<{
+    publicFacet: AutoswapPublicFacet;
+}>;
+import type { ZCF } from '@agoric/zoe';
+import type { AutoswapPublicFacet } from './types.js';
+//# sourceMappingURL=autoswap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"autoswap.d.ts","sourceRoot":"","sources":["autoswap.js"],"names":[],"mappings":"AAeA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,2BAFW,GAAG;;GAwVb;yBAnY4C,aAAa;yCACpB,YAAY"}

package/src/contracts/barterExchange.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @import {OfferHandler, ZCF} from '@agoric/zoe';
+ */
+/**
+ * This Barter Exchange accepts offers to trade arbitrary goods for other
+ * things. It doesn't require registration of Issuers. If two offers satisfy
+ * each other, it exchanges the specified amounts in each side's want clause.
+ * https://agoric.com/documentation/zoe/guide/contracts/barter-exchange.html
+ *
+ * The Barter Exchange only accepts offers that look like
+ * { give: { In: amount }, want: { Out: amount} }
+ * The want amount will be matched, while the give amount is a maximum. Each
+ * successful trader gets their `want` and may trade with counter-parties who
+ * specify any amount up to their specified `give`.
+ *
+ * @param {ZCF} zcf
+ */
+export function start(zcf: ZCF): {
+    publicFacet: {
+        makeInvitation: () => Promise<import("@agoric/zoe").Invitation<unknown, never>>;
+    } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeInvitation: () => Promise<import("@agoric/zoe").Invitation<unknown, never>>;
+    }>;
+};
+import type { ZCF } from '@agoric/zoe';
+//# sourceMappingURL=barterExchange.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"barterExchange.d.ts","sourceRoot":"","sources":["barterExchange.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH,2BAFW,GAAG;;;;;;EA+Gb;yBA9HmC,aAAa"}

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

@@ -0,0 +1,2 @@
+export function calculateShares(collateralBrand: import("@agoric/ertp").Brand, price: import("@agoric/ertp").Amount<"nat">, strikePrice1: import("@agoric/ertp").Amount<"nat">, strikePrice2: import("@agoric/ertp").Amount<"nat">): import("./types.js").CalculateSharesReturn;
+//# sourceMappingURL=calculateShares.d.ts.map

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

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

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

@@ -0,0 +1,71 @@
+/**
+ * @import {PriceAuthority} from '@agoric/zoe/tools/types.js';
+ * @import {OfferHandler, ZCF, ZCFSeat} from '@agoric/zoe';
+ * @import {PositionKind} from './types.js';
+ * @import {PayoffHandler} from './types.js';
+ * @import {Amount} from '@agoric/ertp';
+ * @import {PromiseRecord} from '@endo/promise-kit';
+ */
+/**
+ * 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<import("@agoric/zoe").Invitation<unknown, never>>;
+}>;
+import type { Amount } from '@agoric/ertp';
+import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
+import type { ZCF } from '@agoric/zoe';
+//# sourceMappingURL=fundedCallSpread.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fundedCallSpread.d.ts","sourceRoot":"","sources":["fundedCallSpread.js"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;GASG;AACH,2BATW,IAAI;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,cAAc,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CACxB,CAAC;;GA6EJ;4BAjIwB,cAAc;oCAJN,4BAA4B;yBAChB,aAAa"}

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

@@ -0,0 +1,23 @@
+/**
+ * @import {ZCF, ZCFSeat} from '@agoric/zoe';
+ * @import {PositionKind} from './types.js';
+ * @import {PayoffHandler} from './types.js';
+ * @import {MakeOptionInvitation} from './types.js';
+ * @import {PromiseRecord} from '@endo/promise-kit';
+ */
+/**
+ * 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;
+import type { ZCF } from '@agoric/zoe';
+import type { PositionKind } from './types.js';
+import type { ZCFSeat } from '@agoric/zoe';
+import type { PromiseRecord } from '@endo/promise-kit';
+import type { PayoffHandler } from './types.js';
+//# sourceMappingURL=payoffHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"payoffHandler.d.ts","sourceRoot":"","sources":["payoffHandler.js"],"names":[],"mappings":"AAYA;;;;;;GAMG;AAEH;;;;;;;;GAQG;AACH,uCALW,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,mBACxB,MAAM,CAAC,YAAY,EAAC,cAAc,OAAO,CAAC,CAAC,kBAC3C,OAAO,GACL,aAAa,CAgEzB;yBA9E8B,aAAa;kCACb,YAAY;6BADZ,aAAa;mCAIZ,mBAAmB;mCAFnB,YAAY"}

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

@@ -0,0 +1,3 @@
+export function make100Percent(brand: import("@agoric/ertp").Brand): import("@agoric/ertp").Ratio;
+export function make0Percent(brand: import("@agoric/ertp").Brand): import("@agoric/ertp").Ratio;
+//# sourceMappingURL=percent.d.ts.map

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

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

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

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

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

@@ -0,0 +1,69 @@
+/**
+ * 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<import("@agoric/zoe").Invitation<unknown, never>>;
+            shortInvitation: Promise<import("@agoric/zoe").Invitation<unknown, never>>;
+        };
+    } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeInvitationPair: (longCollateralShare: any) => {
+            longInvitation: Promise<import("@agoric/zoe").Invitation<unknown, never>>;
+            shortInvitation: Promise<import("@agoric/zoe").Invitation<unknown, never>>;
+        };
+    }>;
+};
+import type { Amount } from '@agoric/ertp';
+import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
+import type { ZCF } from '@agoric/zoe';
+//# sourceMappingURL=pricedCallSpread.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pricedCallSpread.d.ts","sourceRoot":"","sources":["pricedCallSpread.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,2BATW,IAAI;IACZ,YAAY,EAAE,OAAO,KAAK,CAAC,CAAC;IAC5B,YAAY,EAAE,OAAO,KAAK,CAAC,CAAC;IAC5B,gBAAgB,EAAE,OAAO,KAAK,CAAC,CAAC;IAChC,cAAc,EAAE,cAAc,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,OAAO,KAAK,CAAC,CAAC;CAC/B,CAAC;;;;;;;;;;;;EA0GJ;4BA5JwB,cAAc;oCAJsD,4BAA4B;yBAC5E,aAAa"}

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

@@ -0,0 +1,34 @@
+export type PositionKind = "long" | "short";
+export type MakeOptionInvitation = (positionKind: PositionKind) => Promise<Invitation>;
+export 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.
+ */
+export 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.
+ */
+export type CalculateShares = (collateralBrand: Brand, price: Amount<"nat">, strikePrice1: Amount<"nat">, strikePrice2: Amount<"nat">) => CalculateSharesReturn;
+export type Make100Percent = (brand: Brand) => Ratio;
+export type Make0Percent = (brand: Brand) => Ratio;
+import type { Invitation } from '@agoric/zoe';
+import type { Ratio } from '@agoric/ertp';
+import type { Brand } from '@agoric/ertp';
+import type { Amount } from '@agoric/ertp';
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"2BAEa,MAAM,GAAG,OAAO;kDAUlB,YAAY,KACV,OAAO,CAAC,UAAU,CAAC;;qBAKlB,MAAM,IAAI;0BACT,oBAAoB;;;;;;;;eAQrB,KAAK;gBACL,KAAK;;;;;;;;;;;;;gDAcR,KAAK,SACL,OAAO,KAAK,CAAC,gBACb,OAAO,KAAK,CAAC,gBACb,OAAO,KAAK,CAAC,KACX,qBAAqB;qCAKvB,KAAK,KACH,KAAK;mCAKP,KAAK,KACH,KAAK;gCAnDW,aAAa;2BADH,cAAc;2BAAd,cAAc;4BAAd,cAAc"}

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

@@ -0,0 +1,23 @@
+/**
+ * @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 {Baggage} instanceBaggage
+ */
+export function start(zcf: ZCF, _privateArgs: unknown, instanceBaggage: Baggage): Promise<{
+    creatorFacet: import("@endo/exo").Guarded<{
+        makeInvitation(): Promise<import("@agoric/zoe").Invitation<unknown, never>>;
+    }>;
+}>;
+import type { ZCF } from '@agoric/zoe';
+import type { Baggage } from '@agoric/vat-data';
+//# sourceMappingURL=coveredCall-durable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coveredCall-durable.d.ts","sourceRoot":"","sources":["coveredCall-durable.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;GAcG;AACH,2BAJW,GAAG,gBACH,OAAO,mBACP,OAAO;;;;GA6EjB;yBA/FmC,aAAa;6BADvB,kBAAkB"}

package/src/contracts/coveredCall.d.ts

@@ -0,0 +1,68 @@
+/**
+ * @import {OfferHandler, ZCF} from '@agoric/zoe';
+ */
+/**
+ * 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<import("@agoric/zoe").Invitation<unknown, never>>;
+};
+import type { ZCF } from '@agoric/zoe';
+//# sourceMappingURL=coveredCall.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coveredCall.d.ts","sourceRoot":"","sources":["coveredCall.js"],"names":[],"mappings":"AAMA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,2BAFW,GAAG;;EAwCb;yBArGmC,aAAa"}

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

@@ -0,0 +1,8 @@
+/**
+ * @import {OfferHandler} from '@agoric/zoe';
+ * @import {MakeAddCollateralInvitation} from './types.js';
+ */
+/** @type {MakeAddCollateralInvitation} */
+export const makeAddCollateralInvitation: MakeAddCollateralInvitation;
+import type { MakeAddCollateralInvitation } from './types.js';
+//# sourceMappingURL=addCollateral.d.ts.map

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

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

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

@@ -0,0 +1,12 @@
+/**
+ * @import {OfferHandler} from '@agoric/zoe';
+ * @import {MakeBorrowInvitation} from './types.js';
+ * @import {DebtCalculatorConfig} from './types.js';
+ * @import {LoanConfigWithBorrower} from './types.js';
+ * @import {BorrowFacet} from './types.js';
+ * @import {Brand} from '@agoric/ertp';
+ */
+/** @type {MakeBorrowInvitation} */
+export const makeBorrowInvitation: MakeBorrowInvitation;
+import type { MakeBorrowInvitation } from './types.js';
+//# sourceMappingURL=borrow.d.ts.map

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

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

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

@@ -0,0 +1,8 @@
+/**
+ * @import {OfferHandler} from '@agoric/zoe';
+ * @import {MakeCloseLoanInvitation} from './types.js';
+ */
+/** @type {MakeCloseLoanInvitation} */
+export const makeCloseLoanInvitation: MakeCloseLoanInvitation;
+import type { MakeCloseLoanInvitation } from './types.js';
+//# sourceMappingURL=close.d.ts.map

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

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

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

@@ -0,0 +1,75 @@
+/**
+ * @import {PriceAuthority, PriceDescription, PriceQuote, PriceQuoteValue, PriceQuery,} from '@agoric/zoe/tools/types.js';
+ * @import {Ratio} from '@agoric/ertp';
+ * @import {Instance, ZCF} from '@agoric/zoe';
+ * @import {LoanTerms, PeriodNotifier} from './types.js';
+ */
+/**
+ * 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<import("@agoric/zoe").Invitation>;
+}>;
+import type { Ratio } from '@agoric/ertp';
+import type { Instance } from '@agoric/zoe';
+import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
+import type { PeriodNotifier } from './types.js';
+import type { ZCF } from '@agoric/zoe';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,2BATW,IAAI;IACV,GAAG,EAAE,KAAK,CAAC;IACX,gBAAgB,EAAE,QAAQ,CAAC;IAC3B,cAAc,EAAE,cAAc,CAAC;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,KAAK,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;;GAsCJ;2BA9FuB,cAAc;8BACN,aAAa;oCAFgD,4BAA4B;oCAG7E,YAAY;yBADxB,aAAa"}

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

@@ -0,0 +1,8 @@
+/**
+ * @import {OfferHandler} from '@agoric/zoe';
+ * @import {MakeLendInvitation} from './types.js';
+ */
+/** @type {MakeLendInvitation} */
+export const makeLendInvitation: MakeLendInvitation;
+import type { MakeLendInvitation } from './types.js';
+//# sourceMappingURL=lend.d.ts.map

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

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

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

@@ -0,0 +1,5 @@
+export function doLiquidation(zcf: any, collateralSeat: any, autoswapPublicFacetP: any, lenderSeat: any, loanBrand: any): Promise<void>;
+export function liquidate(zcf: ZCF, config: LoanConfigWithBorrower): Promise<void>;
+import type { ZCF } from '@agoric/zoe';
+import type { LoanConfigWithBorrower } from './types.js';
+//# sourceMappingURL=liquidate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"liquidate.d.ts","sourceRoot":"","sources":["liquidate.js"],"names":[],"mappings":"AAWO,wIA6CN;AAeM,+BAJI,GAAG,UACH,sBAAsB,GACpB,OAAO,CAAC,IAAI,CAAC,CAiBzB;yBA/EqB,aAAa;4CACM,YAAY"}

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

@@ -0,0 +1,7 @@
+/**
+ * @import {ScheduleLiquidation} from './types.js';
+ */
+/** @type {ScheduleLiquidation} */
+export const scheduleLiquidation: ScheduleLiquidation;
+import type { ScheduleLiquidation } from './types.js';
+//# sourceMappingURL=scheduleLiquidation.d.ts.map

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

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