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

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/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"}

package/src/contracts/priceAggregator.d.ts

@@ -0,0 +1,107 @@
+export type ParsableNumber = bigint | number | string;
+export type OraclePriceSubmission = Readonly<ParsableNumber | {
+    data: ParsableNumber;
+}>;
+export type Price = ParsableNumber | Ratio;
+export type PriceAggregatorContract = ContractOf<typeof start>;
+/**
+ * @deprecated use fluxAggregator
+ *
+ * This contract aggregates price values from a set of oracles and provides a
+ * PriceAuthority for their median. This naive method is game-able and so this module
+ * is a stub until we complete what is now in `fluxAggregatorKit.js`.
+ *
+ * @param {ZCF<{
+ * timer: import('@agoric/time').TimerService,
+ * POLL_INTERVAL: bigint,
+ * brandIn: Brand<'nat'>,
+ * brandOut: Brand<'nat'>,
+ * unitAmountIn: Amount<'nat'>,
+ * }>} zcf
+ * @param {{
+ * marshaller: Marshaller,
+ * quoteMint?: ERef<Mint<'set'>>,
+ * storageNode: ERef<StorageNode>,
+ * }} privateArgs
+ */
+export function start(zcf: ZCF<{
+    timer: import('@agoric/time').TimerService;
+    POLL_INTERVAL: bigint;
+    brandIn: Brand<'nat'>;
+    brandOut: Brand<'nat'>;
+    unitAmountIn: Amount<'nat'>;
+}>, privateArgs: {
+    marshaller: Marshaller;
+    quoteMint?: ERef<globalThis.Mint<"set">> | undefined;
+    storageNode: ERef<StorageNode>;
+}): Promise<{
+    creatorFacet: {
+        /**
+         * An "oracle invitation" is an invitation to be able to submit data to
+         * include in the priceAggregator's results.
+         *
+         * The offer result from this invitation is a OracleAdmin, which can be used
+         * directly to manage the price submissions as well as to terminate the
+         * relationship.
+         *
+         * @param {Instance | string} [oracleKey]
+         */
+        makeOracleInvitation: (oracleKey?: string | Instance | undefined) => Promise<Invitation<{
+            admin: OracleAdmin<Price>;
+            invitationMakers: {
+                PushPrice: (price: ParsableNumber) => Promise<Invitation<void>>;
+            };
+        }, {
+            notifier?: Notifier<OraclePriceSubmission> | undefined;
+            scaleValueOut?: number | undefined;
+        }>>;
+        /** @param {OracleKey} oracleKey */
+        deleteOracle: (oracleKey: OracleKey) => Promise<void>;
+        /**
+         * @param {Instance | string} [oracleInstance]
+         * @param {OracleQuery} [query]
+         * @returns {Promise<OracleAdmin<Price>>}
+         */
+        initOracle: (oracleInstance?: string | Instance | undefined, query?: OracleQuery | undefined) => Promise<OracleAdmin<Price>>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        /**
+         * An "oracle invitation" is an invitation to be able to submit data to
+         * include in the priceAggregator's results.
+         *
+         * The offer result from this invitation is a OracleAdmin, which can be used
+         * directly to manage the price submissions as well as to terminate the
+         * relationship.
+         *
+         * @param {Instance | string} [oracleKey]
+         */
+        makeOracleInvitation: (oracleKey?: string | Instance | undefined) => Promise<Invitation<{
+            admin: OracleAdmin<Price>;
+            invitationMakers: {
+                PushPrice: (price: ParsableNumber) => Promise<Invitation<void>>;
+            };
+        }, {
+            notifier?: Notifier<OraclePriceSubmission> | undefined;
+            scaleValueOut?: number | undefined;
+        }>>;
+        /** @param {OracleKey} oracleKey */
+        deleteOracle: (oracleKey: OracleKey) => Promise<void>;
+        /**
+         * @param {Instance | string} [oracleInstance]
+         * @param {OracleQuery} [query]
+         * @returns {Promise<OracleAdmin<Price>>}
+         */
+        initOracle: (oracleInstance?: string | Instance | undefined, query?: OracleQuery | undefined) => Promise<OracleAdmin<Price>>;
+    }>;
+    publicFacet: {
+        getPriceAuthority(): PriceAuthority;
+        getSubscriber: () => StoredSubscriber<unknown>;
+        /** Diagnostic tool */
+        getRoundCompleteNotifier(): Promise<Notifier<any>>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        getPriceAuthority(): PriceAuthority;
+        getSubscriber: () => StoredSubscriber<unknown>;
+        /** Diagnostic tool */
+        getRoundCompleteNotifier(): Promise<Notifier<any>>;
+    }>;
+}>;
+//# sourceMappingURL=priceAggregator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"priceAggregator.d.ts","sourceRoot":"","sources":["priceAggregator.js"],"names":[],"mappings":"6BAoCc,MAAM,GAAG,MAAM,GAAG,MAAM;oCAEzB,SAAS,cAAc,GAAG;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,CAAC;oBAGlD,cAAc,GAAG,KAAK;sCAmlBtB,WAAW,YAAY,CAAC;AA9kBtC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2BAbW,IAAI;IACd,KAAO,EAAE,OAAO,cAAc,EAAE,YAAY,CAAC;IAC7C,aAAe,EAAE,MAAM,CAAC;IACxB,OAAS,EAAE,MAAM,KAAK,CAAC,CAAC;IACxB,QAAU,EAAE,MAAM,KAAK,CAAC,CAAC;IACzB,YAAc,EAAE,OAAO,KAAK,CAAC,CAAC;CAC3B,CAAC;gBAEU,UAAU;;;;;QAmXrB;;;;;;;;;WASG;;mBAY4B,YAAY,KAAK,CAAC;8BAAoB;gBAAC,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,QAAQ,WAAW,IAAI,CAAC,CAAC,CAAA;aAAC;;;;;QA0CtI,mCAAmC;kCAAvB,SAAS;QAarB;;;;WAIG;yGADU,QAAQ,YAAY,KAAK,CAAC,CAAC;;QA/ExC;;;;;;;;;WASG;;mBAY4B,YAAY,KAAK,CAAC;8BAAoB;gBAAC,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,QAAQ,WAAW,IAAI,CAAC,CAAC,CAAA;aAAC;;;;;QA0CtI,mCAAmC;kCAAvB,SAAS;QAarB;;;;WAIG;yGADU,QAAQ,YAAY,KAAK,CAAC,CAAC;;;;;QAmHxC,sBAAsB;;;;;QAAtB,sBAAsB;;;GAOzB"}

package/src/contracts/priceAggregator.js

@@ -31,7 +31,6 @@ import {
   ratiosSame,
 } from '../contractSupport/ratio.js';
 
-/// <reference path="../../../ERTP/exported.js" />
 /**
  * @import {LegacyMap} from '@agoric/store/exported.js'
  */