@agoric/zoe 0.26.3-dev-fa844b5.0 → 0.26.3-dev-21fe8d9.0

package/src/contractSupport/types.d.ts

@@ -0,0 +1,63 @@
+type SeatGainsLossesRecord = {
+    seat: ZCFSeat;
+    /**
+     * - what the seat will
+     * gain as a result of this trade
+     */
+    gains: AmountKeywordRecord;
+    /**
+     * - what the seat [will]
+     * give up as a result of this trade. Losses is optional, but can
+     * only be omitted if the keywords for both seats are the same.
+     * If losses is not defined, the gains of the other seat is
+     * subtracted.
+     */
+    losses: AmountKeywordRecord;
+};
+/**
+ * If two seats can satisfy each other's wants, trade enough to
+ * satisfy the wants of both seats and exit both seats.
+ *
+ * The surplus remains with the original seat. For example if seat A
+ * gives 5 moola and seat B only wants 3 moola, seat A retains 2
+ * moola.
+ *
+ * If the swap fails, no assets are transferred, both seats will fail,
+ * and the function throws.
+ *
+ * The keywords for both seats must match.
+ */
+type Swap = (zcf: ZCF, leftSeat: ZCFSeat, rightSeat: ZCFSeat) => string;
+/**
+ * Swap such that both seats gain what they want and lose everything
+ * that they gave. Only good for exact and entire swaps where each
+ * seat wants everything that the other seat has. The benefit of using
+ * this method is that the keywords of each seat do not matter.
+ *
+ * If the swap fails, no assets are transferred, both seats will fail,
+ * and the function throws.
+ */
+type SwapExact = (zcf: ZCF, leftSeat: ZCFSeat, rightSeat: ZCFSeat) => string;
+/**
+ * A mapping of keywords to keywords.
+ */
+type KeywordKeywordRecord = Record<Keyword, Keyword>;
+/**
+ * Given a mapping of keywords to keywords, invert the keys and
+ * values. This is used to map the offers made to another contract
+ * back to the keywords used in the first contract.
+ */
+type Reverse = (keywordRecord?: KeywordKeywordRecord | undefined) => KeywordKeywordRecord;
+/**
+ * Remap the keywords of an amountKeywordRecord, issuerKeywordRecord, or a
+ * PaymentPKeywordRecord according to a mapping. This is used to remap
+ * from keywords used in contractA to keywords used in contractB and
+ * vice versa in `offerTo`
+ */
+type MapKeywords = (keywordRecord: AmountKeywordRecord | PaymentPKeywordRecord | IssuerKeywordRecord | undefined, keywordMapping: KeywordKeywordRecord) => any;
+type Ratio = {
+    numerator: Amount<'nat'>;
+    denominator: Amount<'nat'>;
+};
+type ScaleAmount = (amount: Amount<'nat'>, ratio: Ratio) => Amount<'nat'>;
+//# sourceMappingURL=types.d.ts.map

package/src/contractSupport/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";UAMc,OAAO;;;;;WACP,mBAAmB;;;;;;;;YAEnB,mBAAmB;;;;;;;;;;;;;;;kBAqBtB,GAAG,YACH,OAAO,aACP,OAAO,KACL,MAAM;;;;;;;;;;uBAcR,GAAG,YACH,OAAO,aACP,OAAO,KACL,MAAM;;;;4BAIN,OAAO,OAAO,EAAC,OAAO,CAAC;;;;;;qEAYvB,oBAAoB;;;;;;;mCAWtB,mBAAmB,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,SAAS,kBAC7E,oBAAoB;;eAKjB,OAAO,KAAK,CAAC;iBACb,OAAO,KAAK,CAAC;;4BAKhB,OAAO,KAAK,CAAC,SACb,KAAK,KACH,OAAO,KAAK,CAAC"}

package/src/contractSupport/zoeHelpers.d.ts

@@ -0,0 +1,30 @@
+export const defaultAcceptanceMsg: "The offer has been accepted. Once the contract has been completed, please check your payout";
+export function assertIssuerKeywords(zcf: any, expected: any): void;
+export function satisfies(zcf: ZCF, seat: ZcfSeatPartial, update: AmountKeywordRecord): 0 | 1;
+/** @type {Swap} */
+export const swap: Swap;
+/** @type {SwapExact} */
+export const swapExact: SwapExact;
+export function fitProposalShape(seat: ZCFSeat, proposalShape: Pattern): void;
+export function assertProposalShape(seat: ZCFSeat, expected: ExpectedRecord): void;
+export function assertNatAssetKind(zcf: any, brand: any): void;
+export const depositToSeatSuccessMsg: "Deposit and reallocation successful.";
+export function depositToSeat(zcf: ZCF, recipientSeat: ZCFSeat, amounts: AmountKeywordRecord, payments: PaymentPKeywordRecord): Promise<string>;
+export function withdrawFromSeat(zcf: ZCF, seat: ZCFSeat, amounts: AmountKeywordRecord): Promise<PaymentPKeywordRecord>;
+export function saveAllIssuers(zcf: ZCF, issuerKeywordRecord?: IssuerKeywordRecord): Promise<(IssuerRecord<any> | undefined)[]>;
+/** @type {MapKeywords} */
+export const mapKeywords: MapKeywords;
+export function offerTo<Args extends unknown, Result extends unknown>(zcf: ZCF, invitation: ERef<Invitation<Result, Args>>, keywordMapping: KeywordKeywordRecord | undefined, proposal: Proposal, fromSeat: ZCFSeat, toSeat?: ZCFSeat | undefined, offerArgs?: Args | undefined): Promise<{
+    userSeatPromise: Promise<UserSeat<Result>>;
+    deposited: Promise<AmountKeywordRecord>;
+}>;
+export type ZcfSeatPartial = {
+    getProposal: () => ProposalRecord;
+    getCurrentAllocation: () => Allocation;
+};
+export type ExpectedRecord = {
+    want?: Record<string, null> | undefined;
+    give?: Record<string, null> | undefined;
+    exit?: Partial<Record<never, null>> | undefined;
+};
+//# sourceMappingURL=zoeHelpers.d.ts.map

package/src/contractSupport/zoeHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoeHelpers.d.ts","sourceRoot":"","sources":["zoeHelpers.js"],"names":[],"mappings":"AASA,iIAAkI;AAM3H,oEAON;AAuBM,+BALI,GAAG,QACH,cAAc,UACd,mBAAmB,GACjB,CAAC,GAAC,CAAC,CAOf;AAED,mBAAmB;AACnB,mBADW,IAAI,CAkBb;AAEF,wBAAwB;AACxB,wBADW,SAAS,CAqBlB;AAiBK,uCAHI,OAAO,iBACP,OAAO,QAIgD;AAsB3D,0CAHI,OAAO,YACP,cAAc,QA+BxB;AAGM,+DAGN;AAED,6EAA8E;AAavE,mCANI,GAAG,iBACH,OAAO,WACP,mBAAmB,YACnB,qBAAqB,GACnB,QAAQ,MAAM,CAAC,CA8B3B;AAYM,sCALI,GAAG,QACH,OAAO,WACP,mBAAmB,GACjB,QAAQ,qBAAqB,CAAC,CAQ1C;AAWM,oCAJI,GAAG,wBACH,mBAAmB,8CAgB7B;AAED,0BAA0B;AAC1B,0BADW,WAAW,CAYpB;AAiDK,2EAjCI,GAAG,8DAMH,oBAAoB,GAAG,SAAS,YAKhC,QAAQ,YAGR,OAAO;;eAU2D,QAAQ,mBAAmB,CAAC;GA+DxG;;iBAzVa,MAAM,cAAc;0BACpB,MAAM,UAAU"}

package/src/contracts/atomicSwap.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Trade one item for another.
+ * https://agoric.com/documentation/zoe/guide/contracts/atomic-swap.html
+ *
+ * The initial offer is { give: { Asset: A }, want: { Price: B } }.
+ * The outcome from the first offer is an invitation for the second party,
+ * who should offer { give: { Price: B }, want: { Asset: A } }, with a want
+ * amount no greater than the original's give, and a give amount at least as
+ * large as the original's want.
+ *
+ * @param {ZCF} zcf
+ */
+export function start(zcf: ZCF): {
+    creatorInvitation: Promise<Invitation<unknown, never>>;
+};
+//# sourceMappingURL=atomicSwap.d.ts.map

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

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

package/src/contracts/auction/assertBidSeat.d.ts

@@ -0,0 +1,2 @@
+export function assertBidSeat(zcf: any, sellSeat: any, bidSeat: any): void;
+//# sourceMappingURL=assertBidSeat.d.ts.map

package/src/contracts/auction/assertBidSeat.d.ts.map

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

package/src/contracts/auction/firstPriceLogic.d.ts

@@ -0,0 +1,2 @@
+export function calcWinnerAndClose(zcf: ZCF, sellSeat: ZCFSeat, bidSeats: Array<ZCFSeat>): void;
+//# sourceMappingURL=firstPriceLogic.d.ts.map

package/src/contracts/auction/firstPriceLogic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firstPriceLogic.d.ts","sourceRoot":"","sources":["firstPriceLogic.js"],"names":[],"mappings":"AAOO,wCAJI,GAAG,YACH,OAAO,YACP,MAAM,OAAO,CAAC,QAmDxB"}

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

@@ -0,0 +1,78 @@
+/**
+ * NOT TO BE USED IN PRODUCTION CODE. BIDS ARE PUBLIC. An auction
+ * contract in which the seller offers an Asset for sale, and states a
+ * minimum price. The auction closes at the deadline specified by the
+ * timeAuthority, bidDuration, winnerPriceOption parameters in the terms provided by
+ * the creator of the contract instance.
+ * Winner price option can be `first-price` or `second-price`, default to `second-price`.
+ *
+ * startInstance() specifies the issuers and the terms. An invitation
+ * for the seller is returned as the creatorInvitation. The seller's
+ * offer should look like { give: { Asset: asset }, want: { Ask:
+ * minimumBidAmount}} The asset can be non-fungible, but the Ask
+ * amount should be of a fungible brand. The bidder invitations can be
+ * made by calling makeBidInvitation on the object returned from the
+ * seller's offer. Each bidder can submit an offer: { give: { Bid:
+ * null } want: { Asset: null } }.
+ *
+ * @param {ZCF<{
+ * timeAuthority: import('@agoric/time').TimerService,
+ * winnerPriceOption?: FIRST_PRICE | SECOND_PRICE,
+ * bidDuration: bigint,
+ * }>} zcf
+ */
+export function start(zcf: ZCF<{
+    timeAuthority: import('@agoric/time').TimerService;
+    winnerPriceOption?: "first-price" | "second-price";
+    bidDuration: bigint;
+}>): {
+    creatorInvitation: Promise<Invitation<{
+        makeBidInvitation: () => Promise<Invitation<unknown, never>>;
+        getSessionDetails: () => {
+            auctionedAssets: any;
+            minimumBid: any;
+            winnerPriceOption: string;
+            closesAfter: any;
+            bidDuration: bigint;
+            timeAuthority: import("@agoric/time").TimerService;
+            bids: string | any[];
+        };
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeBidInvitation: () => Promise<Invitation<unknown, never>>;
+        getSessionDetails: () => {
+            auctionedAssets: any;
+            minimumBid: any;
+            winnerPriceOption: string;
+            closesAfter: any;
+            bidDuration: bigint;
+            timeAuthority: import("@agoric/time").TimerService;
+            bids: string | any[];
+        };
+    }>, undefined>>;
+    publicFacet: {
+        getCurrentBids: () => any[] | "Bids are hidden for \"second price\" auctions";
+        getSessionDetails: () => {
+            auctionedAssets: any;
+            minimumBid: any;
+            winnerPriceOption: string;
+            closesAfter: any;
+            bidDuration: bigint;
+            timeAuthority: import("@agoric/time").TimerService;
+            bids: string | any[];
+        };
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getCurrentBids: () => any[] | "Bids are hidden for \"second price\" auctions";
+        getSessionDetails: () => {
+            auctionedAssets: any;
+            minimumBid: any;
+            winnerPriceOption: string;
+            closesAfter: any;
+            bidDuration: bigint;
+            timeAuthority: import("@agoric/time").TimerService;
+            bids: string | any[];
+        };
+    }>;
+};
+export const FIRST_PRICE: "first-price";
+export const SECOND_PRICE: "second-price";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,2BANW,IAAI;IACd,aAAe,EAAE,OAAO,cAAc,EAAE,YAAY,CAAC;IACrD,iBAAmB,CAAC,EAAE,8BAA0B,CAAC;IACjD,WAAa,EAAE,MAAM,CAAC;CACnB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0HJ;AAlJD,wCAAkC;AAClC,0CAAoC"}

package/src/contracts/auction/secondPriceLogic.d.ts

@@ -0,0 +1,2 @@
+export function calcWinnerAndClose(zcf: ZCF, sellSeat: ZCFSeat, bidSeats: Array<ZCFSeat>): void;
+//# sourceMappingURL=secondPriceLogic.d.ts.map

package/src/contracts/auction/secondPriceLogic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secondPriceLogic.d.ts","sourceRoot":"","sources":["secondPriceLogic.js"],"names":[],"mappings":"AAOO,wCAJI,GAAG,YACH,OAAO,YACP,MAAM,OAAO,CAAC,QA8DxB"}

package/src/contracts/automaticRefund.d.ts

@@ -0,0 +1,25 @@
+/**
+ * This is a very trivial contract to explain and test Zoe.
+ * AutomaticRefund just gives you back what you put in.
+ * AutomaticRefund tells Zoe to complete the
+ * offer, which gives the user their payout through Zoe. Other
+ * contracts will use these same steps, but they will have more
+ * sophisticated logic and interfaces.
+ *
+ * Since the contract doesn't attempt any reallocation, the offer can contain
+ * anything in `give` and `want`. The amount in `give` will be returned, and
+ * `want` will be ignored.
+ *
+ * @param {ZCF<{}>} zcf
+ */
+export function start(zcf: ZCF<{}>): {
+    creatorInvitation: Promise<Invitation<unknown, never>>;
+    publicFacet: {
+        getOffersCount: () => bigint;
+        makeInvitation: () => Promise<Invitation<unknown, never>>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getOffersCount: () => bigint;
+        makeInvitation: () => Promise<Invitation<unknown, never>>;
+    }>;
+};
+//# sourceMappingURL=automaticRefund.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"automaticRefund.d.ts","sourceRoot":"","sources":["automaticRefund.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,2BAFW,IAAI,EAAE,CAAC;;;;;;;;;EAqBjB"}

package/src/contracts/autoswap.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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;
+}>;
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,2BAFW,GAAG;;GAoVb"}

package/src/contracts/barterExchange.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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<Invitation<unknown, never>>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeInvitation: () => Promise<Invitation<unknown, never>>;
+    }>;
+};
+//# 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;;;;;;;;;;;;;GAaG;AACH,2BAFW,GAAG;;;;;;EA+Gb"}

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

@@ -0,0 +1,2 @@
+export function calculateShares(collateralBrand: globalThis.Brand, price: globalThis.Amount<"nat">, strikePrice1: globalThis.Amount<"nat">, strikePrice2: globalThis.Amount<"nat">): 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":"AAeM,2MAyBN"}

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

@@ -0,0 +1,60 @@
+/**
+ * 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<unknown, never>>;
+}>;
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;;;GASG;AACH,2BATW,IAAI;IACd,YAAc,EAAE,MAAM,CAAC;IACvB,YAAc,EAAE,MAAM,CAAC;IACvB,gBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAgB,EAAE,cAAc,CAAC;IACjC,UAAY,EAAE,MAAM,CAAC;IACrB,gBAAkB,EAAE,MAAM,CAAC;CACxB,CAAC;;GA6EJ"}

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

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

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

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

@@ -0,0 +1,3 @@
+export function make100Percent(brand: globalThis.Brand): Ratio;
+export function make0Percent(brand: globalThis.Brand): 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":"AAe+9B,+DAAsE;AAAW,6DAAoE"}

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,66 @@
+/**
+ * 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<unknown, never>>;
+            shortInvitation: Promise<Invitation<unknown, never>>;
+        };
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeInvitationPair: (longCollateralShare: any) => {
+            longInvitation: Promise<Invitation<unknown, never>>;
+            shortInvitation: Promise<Invitation<unknown, never>>;
+        };
+    }>;
+};
+//# 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":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,2BATW,IAAI;IACd,YAAc,EAAE,OAAO,KAAK,CAAC,CAAC;IAC9B,YAAc,EAAE,OAAO,KAAK,CAAC,CAAC;IAC9B,gBAAkB,EAAE,OAAO,KAAK,CAAC,CAAC;IAClC,cAAgB,EAAE,cAAc,CAAC;IACjC,UAAY,EAAE,MAAM,CAAC;IACrB,gBAAkB,EAAE,OAAO,KAAK,CAAC,CAAC;CAC/B,CAAC;;;;;;;;;;;;EAyGJ"}

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * @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: import('@agoric/vat-data').Baggage): Promise<{
+    creatorFacet: import("@endo/exo").Guarded<{
+        makeInvitation(): Promise<Invitation<unknown, never>>;
+    }>;
+}>;
+//# 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":"AASA;;;;;;;;;;;;;;GAcG;AACH,2BAJW,GAAG,gBACH,OAAO,mBACP,OAAO,kBAAkB,EAAE,OAAO;;;;GA6E5C"}

package/src/contracts/coveredCall.d.ts

@@ -0,0 +1,64 @@
+/**
+ * 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<unknown, never>>;
+};
+//# sourceMappingURL=coveredCall.d.ts.map