@agoric/zoe 0.26.3-dev-f1638f9.0 → 0.26.3-dev-a477bee.0

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

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

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

package/src/contracts/exported.d.ts

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

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

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

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

@@ -0,0 +1,3 @@
+/** @type {MakeAddCollateralInvitation} */
+export const makeAddCollateralInvitation: MakeAddCollateralInvitation;
+//# 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":"AAUA,0CAA0C;AAC1C,0CADW,2BAA2B,CAwBpC"}

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

@@ -0,0 +1,3 @@
+/** @type {MakeBorrowInvitation} */
+export const makeBorrowInvitation: MakeBorrowInvitation;
+//# 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,mCAAmC;AACnC,mCADW,oBAAoB,CAoI7B"}

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

@@ -0,0 +1,3 @@
+/** @type {MakeCloseLoanInvitation} */
+export const makeCloseLoanInvitation: MakeCloseLoanInvitation;
+//# 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":"AAYA,sCAAsC;AACtC,sCADW,uBAAuB,CAiDhC"}

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

@@ -0,0 +1,64 @@
+/**
+ * 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<unknown, undefined>>;
+}>;
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,2BATW,IAAI;IACd,GAAO,EAAE,KAAK,CAAC;IACf,gBAAoB,EAAE,QAAQ,CAAC;IAC/B,cAAkB,EAAE,cAAc,CAAC;IACnC,cAAkB,EAAE,cAAc,CAAC;IACnC,YAAgB,EAAE,KAAK,CAAC;IACxB,cAAkB,EAAE,MAAM,CAAC;CACxB,CAAC;;GAsCJ"}

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

@@ -0,0 +1,3 @@
+/** @type {MakeLendInvitation} */
+export const makeLendInvitation: MakeLendInvitation;
+//# 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":"AAaA,iCAAiC;AACjC,iCADW,kBAAkB,CA4B3B"}

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

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

@@ -0,0 +1 @@
+{"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/liquidate.js

@@ -37,7 +37,7 @@ export const doLiquidation = async (
     zcf.shutdown('your loan had to be liquidated');
   };
 
-  /** @type {ShutdownWithFailure} */
+  /** @type {import('@agoric/swingset-vat').ShutdownWithFailure} */
   const closeWithFailure = err => {
     lenderSeat.fail(err);
     collateralSeat.fail(err);

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

@@ -0,0 +1,3 @@
+/** @type {ScheduleLiquidation} */
+export const scheduleLiquidation: ScheduleLiquidation;
+//# 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":"AAWA,kCAAkC;AAClC,kCADW,mBAAmB,CAsD5B"}

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

@@ -0,0 +1,161 @@
+/**
+ * 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').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').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').RelativeTime;
+    zcf: ZCF;
+    configMinusGetDebt: LoanConfigWithBorrowerMinusDebt;
+    /**
+     * The starting point from which to calculate
+     * interest.
+     */
+    basetime: import('@agoric/time').Timestamp;
+};
+type ConfigMinusGetDebt = {
+    collateralSeat: ZCFSeat;
+    liquidationPromiseKit: PromiseRecord<any>;
+    mmr?: bigint | undefined;
+    autoswapInstance: Handle<'Instance'>;
+    priceAuthority: PriceAuthority;
+    periodNotifier: PeriodNotifier;
+    interestRate: bigint;
+    interestPeriod: import('@agoric/time').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').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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";;;;;;;sBACa,SAAS,OAAO,cAAc,EAAE,eAAe,CAAC;;;;;;;wBAUhD,QAAQ;;;;;;SAUP,KAAK;sBAGL,gBAAgB;;;;;oBAEhB,cAAc;oBAKd,cAAc;;;;;kBAEd,KAAK;oBAIL,OAAO,cAAc,EAAE,YAAY;eAEnC,KAAK;qBACL,KAAK;;;;;;gBAKL,OAAO;;;;;4BAMR,SAAS,GAAG,kBAAkB;;;;;;oBAQ7B,OAAO;;;;aAKP,MAAM,OAAO,KAAK,CAAC;;;;;;;;;;;;oBAanB,OAAO;;;;;;;;;;8BAYR,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,cAAc,EAAE,YAAY;SAInC,GAAG;wBAEH,+BAA+B;;;;;cAC/B,OAAO,cAAc,EAAE,SAAS;;;oBAMhC,OAAO;;;sBAGP,OAAO,UAAU,CAAC;oBAClB,cAAc;oBACd,cAAc;kBACd,MAAM;oBACN,OAAO,cAAc,EAAE,YAAY;gBACnC,OAAO;;;;;;;6BAMP,MAAM,QAAQ,UAAU,CAAC;;;;iCAKzB,MAAM,QAAQ,UAAU,CAAC;;;;;;;2BAIzB,MAAM,QAAQ,UAAU,CAAC;;;;iCAOzB,MAAM,OAAO,cAAc,EAAE,SAAS;;;;;qBAItC,MAAM,SAAS,MAAM,CAAC;;;;+BAKtB,MAAM,MAAM"}

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"mintAndSellNFT.d.ts","sourceRoot":"","sources":["mintAndSellNFT.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,2BAJW,IAAI;IACd,SAAW,EAAE,MAAM,CAAC;CACjB,CAAC;;EA4FJ"}

package/src/contracts/mintPayments.d.ts

@@ -0,0 +1,30 @@
+/**
+ * This is a very simple contract that creates a new issuer and mints payments
+ * from it, in order to give an example of how that can be done.  This contract
+ * sends new tokens to anyone who has an invitation.
+ *
+ * The expectation is that most contracts that want to do something similar
+ * would use the ability to mint new payments internally rather than sharing
+ * that ability widely as this one does.
+ *
+ * To pay others in tokens, the creator of the instance can make
+ * invitations for them, which when used to make an offer, will payout
+ * the specified amount of tokens.
+ *
+ * @param {ZCF} zcf
+ */
+export function start(zcf: ZCF): Promise<{
+    creatorFacet: {
+        makeInvitation: (value?: bigint) => Promise<Invitation<string, undefined>>;
+        getTokenIssuer: () => globalThis.Issuer<"nat">;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeInvitation: (value?: bigint) => Promise<Invitation<string, undefined>>;
+        getTokenIssuer: () => globalThis.Issuer<"nat">;
+    }>;
+    publicFacet: {
+        getTokenIssuer: () => globalThis.Issuer<"nat">;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getTokenIssuer: () => globalThis.Issuer<"nat">;
+    }>;
+}>;
+//# sourceMappingURL=mintPayments.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mintPayments.d.ts","sourceRoot":"","sources":["mintPayments.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,2BAFW,GAAG;;;;;;;;;;;;;GAyCb"}

package/src/contracts/oracle.d.ts

@@ -0,0 +1,26 @@
+export type OracleContract = ContractOf<typeof start>;
+export type OracleStart = typeof start;
+/**
+ * This contract provides oracle queries for a fee or for free.
+ *
+ * @param {ZCF} zcf
+ */
+export function start(zcf: ZCF): Promise<{
+    creatorFacet: {
+        initialize(privateParams: any): OracleCreatorFacet;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        initialize(privateParams: any): OracleCreatorFacet;
+    }>;
+    publicFacet: {
+        /** @param {OracleQuery} query */
+        query(query: OracleQuery): Promise<unknown>;
+        /** @param {OracleQuery} query */
+        makeQueryInvitation(query: OracleQuery): Promise<Invitation<unknown, never>>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        /** @param {OracleQuery} query */
+        query(query: OracleQuery): Promise<unknown>;
+        /** @param {OracleQuery} query */
+        makeQueryInvitation(query: OracleQuery): Promise<Invitation<unknown, never>>;
+    }>;
+}>;
+//# sourceMappingURL=oracle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"oracle.d.ts","sourceRoot":"","sources":["oracle.js"],"names":[],"mappings":"6BAyGc,WAAW,YAAY,CAAC;0BACxB,YAAY;AAlG1B;;;;GAIG;AACH,2BAFW,GAAG;;;;;;;QAkDV,iCAAiC;qBAArB,WAAW;QAgBvB,iCAAiC;mCAArB,WAAW;;QAhBvB,iCAAiC;qBAArB,WAAW;QAgBvB,iCAAiC;mCAArB,WAAW;;GAwB1B"}

package/src/contracts/otcDesk.d.ts

@@ -0,0 +1,79 @@
+/**
+ * This contract is inspired by the description of an OTC Desk smart
+ * contract in this article:
+ * https://medium.com/dragonfly-research/unbundling-uniswap-the-future-of-on-chain-market-making-1c7d6948d570
+ *
+ * The creator of this contract instance can take three actions: add
+ * inventory, remove inventory, and make quotes for potential trading
+ * partners.
+ *
+ * To add inventory, the creator of the contract instance can call
+ * `E(creatorFacet).makeAddInventoryInvitation(issuerKeywordRecord)`
+ * and receive an invitation to add inventory. In this call, they must
+ * pass in an issuerKeywordRecord of any issuers they wish to add
+ * inventory for, if these issuers have not yet been saved to ZCF.
+ * When actually escrowing the inventory as an offer, the proposal
+ * must not `want` anything. All of the newly escrowed inventory is
+ * taken and reallocated to the marketMakerSeat in the contract.
+ *
+ * To remove inventory, the creator of the contract instance can call
+ * `E(creatorFacet).makeRemoveInventoryInvitation()` and receive an
+ * invitation to remove inventory. When making an offer to remove
+ * inventory, the proposal should specify the `want`, which will be
+ * removed, but should not give anything.
+ *
+ * To make a quote, the creator can call
+ * `E(creatorFacet).makeQuote(price, assets, timeAuthority,
+ * deadline)`. `price` and `assets` are amountKeywordRecords that will
+ * be used in the coveredCall. The assets are the underlyingAssets in
+ * the call option, and the price is used as the strikePrice. The
+ * timeAuthority should be a timer, and the deadline can be any time
+ * understood by the timer. The quote will be cancelled after the
+ * deadline. `makeQuote` returns a covered call option that can be
+ * given away for free or sold. Importantly, if the recipient chooses
+ * to exercise the option, they can verify that the goods being
+ * offered are already escrowed, and the trade is guaranteed to
+ * succeed if their proposal matches the quote.
+ *
+ * @param {ZCF<Record<string, any>>} zcf
+ */
+export function start(zcf: ZCF<Record<string, any>>): {
+    creatorFacet: {
+        /**
+         * The inventory can be added in bulk before any quotes are made
+         * or can be added immediately before a quote.
+         *
+         * @param {IssuerKeywordRecord} [issuerKeywordRecord]
+         * @returns {Promise<Payment>}
+         */
+        makeAddInventoryInvitation: (issuerKeywordRecord?: IssuerKeywordRecord | undefined) => Promise<Payment>;
+        /**
+         * The inventory can be removed at any time, since the inventory
+         * used for active quotes is escrowed separately within the coveredCall
+         * instance.
+         *
+         * @returns {Promise<Payment>}
+         */
+        makeRemoveInventoryInvitation: () => Promise<Payment>;
+        makeQuote: (price: AmountKeywordRecord, assets: AmountKeywordRecord, timeAuthority: import('@agoric/time').TimerService, deadline: any) => Promise<Payment>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        /**
+         * The inventory can be added in bulk before any quotes are made
+         * or can be added immediately before a quote.
+         *
+         * @param {IssuerKeywordRecord} [issuerKeywordRecord]
+         * @returns {Promise<Payment>}
+         */
+        makeAddInventoryInvitation: (issuerKeywordRecord?: IssuerKeywordRecord | undefined) => Promise<Payment>;
+        /**
+         * The inventory can be removed at any time, since the inventory
+         * used for active quotes is escrowed separately within the coveredCall
+         * instance.
+         *
+         * @returns {Promise<Payment>}
+         */
+        makeRemoveInventoryInvitation: () => Promise<Payment>;
+        makeQuote: (price: AmountKeywordRecord, assets: AmountKeywordRecord, timeAuthority: import('@agoric/time').TimerService, deadline: any) => Promise<Payment>;
+    }>;
+};
+//# sourceMappingURL=otcDesk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"otcDesk.d.ts","sourceRoot":"","sources":["otcDesk.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,2BAFW,IAAI,OAAO,MAAM,EAAE,GAAG,CAAC,CAAC;;QAoE/B;;;;;;WAMG;+FADU,QAAQ,OAAO,CAAC;QAM7B;;;;;;WAMG;6CADU,QAAQ,OAAO,CAAC;2BAzEpB,mBAAmB,UACnB,mBAAmB,iBACnB,OAAO,cAAc,EAAE,YAAY,YACnC,GAAG,KACD,QAAQ,OAAO,CAAC;;QAqD3B;;;;;;WAMG;+FADU,QAAQ,OAAO,CAAC;QAM7B;;;;;;WAMG;6CADU,QAAQ,OAAO,CAAC;2BAzEpB,mBAAmB,UACnB,mBAAmB,iBACnB,OAAO,cAAc,EAAE,YAAY,YACnC,GAAG,KACD,QAAQ,OAAO,CAAC;;EA8E9B"}