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

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

@@ -0,0 +1,176 @@
+/**
+ * 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.
+ */
+export type PeriodNotifier = Notifier<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.
+ */
+export type AutoswapInstance = Instance;
+export 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: RelativeTime;
+    loanBrand: Brand;
+    collateralBrand: Brand;
+};
+export 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.
+ */
+export type LoanConfigWithLender = LoanTerms & LenderSeatProperty;
+export 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>;
+};
+export 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.
+ */
+export type LoanConfigWithBorrower = LoanConfigWithLender & BorrowerConfigProperties;
+export type LoanConfigWithBorrowerMinusDebt = LoanConfigWithLender & BorrowerConfigPropertiesMinusDebt;
+export type ScheduleLiquidation = (zcf: ZCF, config: LoanConfigWithBorrower) => any;
+export type MakeLendInvitation = (zcf: ZCF, config: LoanTerms) => Promise<Invitation>;
+export type MakeBorrowInvitation = (zcf: ZCF, config: LoanConfigWithLender) => Promise<Invitation>;
+export type MakeCloseLoanInvitation = (zcf: ZCF, config: LoanConfigWithBorrower) => Promise<Invitation>;
+/**
+ * Allows holder to add collateral to the contract. Exits the seat
+ * after adding.
+ */
+export type MakeAddCollateralInvitation = (zcf: ZCF, config: LoanConfigWithBorrower) => Promise<Invitation>;
+export type MakeDebtCalculator = (debtCalculatorConfig: DebtCalculatorConfig) => any;
+export type CalcInterestFn = (oldDebt: Amount<"nat">, interestRate: Ratio) => Amount<"nat">;
+export 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: RelativeTime;
+    zcf: ZCF;
+    configMinusGetDebt: LoanConfigWithBorrowerMinusDebt;
+    /**
+     * The starting point from which to calculate
+     * interest.
+     */
+    basetime: Timestamp;
+};
+export type ConfigMinusGetDebt = {
+    collateralSeat: ZCFSeat;
+    liquidationPromiseKit: PromiseRecord<any>;
+    mmr?: bigint | undefined;
+    autoswapInstance: Handle<"Instance">;
+    priceAuthority: PriceAuthority;
+    periodNotifier: PeriodNotifier;
+    interestRate: bigint;
+    interestPeriod: RelativeTime;
+    lenderSeat: ZCFSeat;
+};
+export 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: () => 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;
+};
+import type { TimestampRecord } from '@agoric/time';
+import type { Notifier } from '@agoric/notifier';
+import type { Instance } from '@agoric/zoe';
+import type { Ratio } from '@agoric/ertp';
+import type { PriceAuthority } from '../../../tools/types.js';
+import type { RelativeTime } from '@agoric/time';
+import type { Brand } from '@agoric/ertp';
+import type { ZCFSeat } from '../../types-index.js';
+import type { Amount } from '@agoric/ertp';
+import type { PriceQuote } from '../../../tools/types.js';
+import type { PromiseRecord } from '@endo/promise-kit';
+import type { ZCF } from '../../types-index.js';
+import type { Invitation } from '../../types-index.js';
+import type { Timestamp } from '@agoric/time';
+import type { Handle } from '@agoric/zoe';
+//# 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":";;;;;;;6BAea,SAAS,eAAe,CAAC;;;;;;;+BAUzB,QAAQ;;;;;;SAUP,KAAK;sBAGL,gBAAgB;;;;;oBAEhB,cAAc;oBAKd,cAAc;;;;;kBAEd,KAAK;oBAIL,YAAY;eAEZ,KAAK;qBACL,KAAK;;;;;;gBAKL,OAAO;;;;;mCAMR,SAAS,GAAG,kBAAkB;;;;;;oBAQ7B,OAAO;;;;aAKP,MAAM,OAAO,KAAK,CAAC;;;;;2BAInB,cAAc,UAAU,CAAC;;;;;;;oBASzB,OAAO;;;;;2BAKP,cAAc,UAAU,CAAC;;;;;qCAO1B,oBAAoB,GAAG,wBAAwB;8CAM/C,oBAAoB,GAAG,iCAAiC;wCAM1D,GAAG,UACH,sBAAsB;uCAKtB,GAAG,UACH,SAAS,KACP,OAAO,CAAC,UAAU,CAAC;yCAKrB,GAAG,UACH,oBAAoB,KAClB,OAAO,CAAC,UAAU,CAAC;4CAKrB,GAAG,UACH,sBAAsB,KACpB,OAAO,CAAC,UAAU,CAAC;;;;;gDAQrB,GAAG,UACH,sBAAsB,KACpB,OAAO,CAAC,UAAU,CAAC;wDAKrB,oBAAoB;uCAKpB,OAAO,KAAK,CAAC,gBACb,KAAK,KACH,OAAO,KAAK,CAAC;;;;;;oBAKZ,cAAc;;;;kBAKd,OAAO,KAAK,CAAC;;;;oBAIb,cAAc;kBAId,KAAK;;;;oBACL,YAAY;SAIZ,GAAG;wBAEH,+BAA+B;;;;;cAC/B,SAAS;;;oBAMT,OAAO;2BACP,cAAc,GAAG,CAAC;;sBAElB,OAAO,UAAU,CAAC;oBAClB,cAAc;oBACd,cAAc;kBACd,MAAM;oBACN,YAAY;gBACZ,OAAO;;;;;;;6BAMP,MAAM,OAAO,CAAC,UAAU,CAAC;;;;iCAKzB,MAAM,OAAO,CAAC,UAAU,CAAC;;;;;;;2BAIzB,MAAM,OAAO,CAAC,UAAU,CAAC;;;;iCAOzB,MAAM,SAAS;;;;;qBAIf,MAAM,SAAS,MAAM,CAAC;;;;+BAKtB,MAAM,MAAM;;qCApOQ,cAAc;8BADrB,kBAAkB;8BAWV,aAAa;2BATT,cAAc;oCACpB,yBAAyB;kCAC3B,cAAc;2BAFN,cAAc;6BAG3B,sBAAsB;4BAHT,cAAc;gCAKxB,yBAAyB;mCADtB,mBAAmB;yBAE7B,sBAAsB;gCACf,sBAAsB;+BACvB,cAAc;4BACP,aAAa"}

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

@@ -0,0 +1,17 @@
+/**
+ * @import {TimestampRecord} from '@agoric/time';
+ * @import {CalcInterestFn, MakeDebtCalculator} from './types.js';
+ */
+/**
+ * @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;
+import type { CalcInterestFn } from './types.js';
+import type { MakeDebtCalculator } from './types.js';
+//# 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":"AASA;;;GAGG;AAKH;;;;;;GAMG;AACH,gCANU,cAAc,CAOgB;AAExC,iCAAiC;AACjC,iCADW,kBAAkB,CAyE3B;oCAzFmD,YAAY;wCAAZ,YAAY"}

package/src/contracts/mintAndSellNFT.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @import {start as sellItemStart} from './sellItems.js';
+ * @import {Installation, ZCF} from '@agoric/zoe';
+ * @import {MintAndSellNFTCreatorFacet} from './types.js';
+ */
+/**
+ * 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;
+};
+import type { ZCF } from '@agoric/zoe';
+import type { MintAndSellNFTCreatorFacet } from './types.js';
+//# 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;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,2BAJW,IAAI;IACZ,SAAS,EAAE,MAAM,CAAC;CACjB,CAAC;;EA4FJ;yBApHmC,aAAa;gDACJ,YAAY"}

package/src/contracts/mintPayments.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @import {ZCF} from '@agoric/zoe';
+ */
+/**
+ * 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<import("@agoric/zoe").Invitation<string, undefined>>;
+        getTokenIssuer: () => import("@agoric/ertp").Issuer<"nat", import("@endo/patterns").Key>;
+    } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeInvitation: (value?: bigint) => Promise<import("@agoric/zoe").Invitation<string, undefined>>;
+        getTokenIssuer: () => import("@agoric/ertp").Issuer<"nat", import("@endo/patterns").Key>;
+    }>;
+    publicFacet: {
+        getTokenIssuer: () => import("@agoric/ertp").Issuer<"nat", import("@endo/patterns").Key>;
+    } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        getTokenIssuer: () => import("@agoric/ertp").Issuer<"nat", import("@endo/patterns").Key>;
+    }>;
+}>;
+import type { ZCF } from '@agoric/zoe';
+//# 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;;GAEG;AAEH;;;;;;;;;;;;;;GAcG;AACH,2BAFW,GAAG;;;;;;;;;;;;;GAyCb;yBAzDqB,aAAa"}

package/src/contracts/oracle.d.ts

@@ -0,0 +1,38 @@
+export type OracleContract = ContractOf<typeof start>;
+export type OracleStart = typeof start;
+/**
+ * @import {ContractMeta, Invitation, OfferHandler, ZCF, ZCFSeat} from '@agoric/zoe';
+ * @import {ContractOf} from '../zoeService/utils.js';
+ * @import {OracleHandler} from './priceAggregatorTypes.js';
+ * @import {OracleCreatorFacet} from './priceAggregatorTypes.js';
+ * @import {OracleQuery} from './priceAggregatorTypes.js';
+ */
+/**
+ * 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/marshal").RemotableObject<`Alleged: ${string}`> & 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/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        /** @param {OracleQuery} query */
+        query(query: OracleQuery): Promise<unknown>;
+        /** @param {OracleQuery} query */
+        makeQueryInvitation(query: OracleQuery): Promise<Invitation<unknown, never>>;
+    }>;
+}>;
+import type { ContractOf } from '../zoeService/utils.js';
+import type { ZCF } from '@agoric/zoe';
+import type { OracleCreatorFacet } from './priceAggregatorTypes.js';
+import type { OracleQuery } from './priceAggregatorTypes.js';
+import type { Invitation } from '@agoric/zoe';
+//# 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":"6BAgHc,WAAW,OAAO,KAAK,CAAC;0BACxB,OAAO,KAAK;AA1G1B;;;;;;GAMG;AAEH;;;;GAIG;AACH,2BAFW,GAAG;;;;;;;QAkDV,iCAAiC;qBAArB,WAAW;QAgBvB,iCAAiC;mCAArB,WAAW;;QAhBvB,iCAAiC;qBAArB,WAAW;QAgBvB,iCAAiC;mCAArB,WAAW;;GAwB1B;gCAnG4B,wBAAwB;yBADkB,aAAa;wCAG/C,2BAA2B;iCAClC,2BAA2B;gCAJc,aAAa"}

package/src/contracts/otcDesk.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @import {TimerService} from '@agoric/time';
+ * @import {Invitation, UserSeat} from '../types-index.js';
+ * @import {AmountKeywordRecord, IssuerKeywordRecord, ZCF} from '@agoric/zoe';
+ * @import {Payment} from '@agoric/ertp';
+ */
+/**
+ * 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) => 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: TimerService, deadline: any) => Promise<Payment>;
+    } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & 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) => 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: TimerService, deadline: any) => Promise<Payment>;
+    }>;
+};
+import type { ZCF } from '@agoric/zoe';
+import type { IssuerKeywordRecord } from '@agoric/zoe';
+import type { Payment } from '@agoric/ertp';
+import type { AmountKeywordRecord } from '@agoric/zoe';
+import type { TimerService } from '@agoric/time';
+//# 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;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,2BAFW,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;;QAoE/B;;;;;;WAMG;2DAFQ,mBAAmB,KACjB,OAAO,CAAC,OAAO,CAAC;QAM7B;;;;;;WAMG;6CADU,OAAO,CAAC,OAAO,CAAC;2BAzEpB,mBAAmB,UACnB,mBAAmB,iBACnB,YAAY,YACZ,GAAG,KACD,OAAO,CAAC,OAAO,CAAC;;QAqD3B;;;;;;WAMG;2DAFQ,mBAAmB,KACjB,OAAO,CAAC,OAAO,CAAC;QAM7B;;;;;;WAMG;6CADU,OAAO,CAAC,OAAO,CAAC;2BAzEpB,mBAAmB,UACnB,mBAAmB,iBACnB,YAAY,YACZ,GAAG,KACD,OAAO,CAAC,OAAO,CAAC;;EA8E9B;yBAtI+D,aAAa;yCAAb,aAAa;6BACnD,cAAc;yCADwB,aAAa;kCAF9C,cAAc"}

package/src/contracts/priceAggregator.d.ts

@@ -0,0 +1,125 @@
+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: TimerService,
+ * POLL_INTERVAL: bigint,
+ * brandIn: Brand<'nat'>,
+ * brandOut: Brand<'nat'>,
+ * unitAmountIn: Amount<'nat'>,
+ * }>} zcf
+ * @param {{
+ * marshaller: Remote<Marshaller>,
+ * quoteMint?: ERef<Mint<'set', PriceDescription>>,
+ * storageNode: Remote<StorageNode>,
+ * }} privateArgs
+ */
+export function start(zcf: ZCF<{
+    timer: TimerService;
+    POLL_INTERVAL: bigint;
+    brandIn: Brand<"nat">;
+    brandOut: Brand<"nat">;
+    unitAmountIn: Amount<"nat">;
+}>, privateArgs: {
+    marshaller: Remote<Marshaller>;
+    quoteMint?: ERef<Mint<"set", PriceDescription>>;
+    storageNode: Remote<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<unknown> | string} [oracleKey]
+         */
+        makeOracleInvitation: (oracleKey?: Instance<unknown> | string) => Promise<Invitation<{
+            admin: OracleAdmin<Price>;
+            invitationMakers: {
+                PushPrice: (price: ParsableNumber) => Promise<Invitation<void>>;
+            };
+        }, {
+            notifier?: Notifier<OraclePriceSubmission> | undefined;
+            scaleValueOut?: number | undefined;
+        } | undefined>>;
+        /** @param {OracleKey} oracleKey */
+        deleteOracle: (oracleKey: OracleKey) => Promise<void>;
+        /**
+         * @param {Instance<unknown> | string} [oracleInstance]
+         * @param {OracleQuery} [query]
+         * @returns {Promise<OracleAdmin<Price>>}
+         */
+        initOracle: (oracleInstance?: Instance<unknown> | string, query?: OracleQuery) => Promise<OracleAdmin<Price>>;
+    } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & 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<unknown> | string} [oracleKey]
+         */
+        makeOracleInvitation: (oracleKey?: Instance<unknown> | string) => Promise<Invitation<{
+            admin: OracleAdmin<Price>;
+            invitationMakers: {
+                PushPrice: (price: ParsableNumber) => Promise<Invitation<void>>;
+            };
+        }, {
+            notifier?: Notifier<OraclePriceSubmission> | undefined;
+            scaleValueOut?: number | undefined;
+        } | undefined>>;
+        /** @param {OracleKey} oracleKey */
+        deleteOracle: (oracleKey: OracleKey) => Promise<void>;
+        /**
+         * @param {Instance<unknown> | string} [oracleInstance]
+         * @param {OracleQuery} [query]
+         * @returns {Promise<OracleAdmin<Price>>}
+         */
+        initOracle: (oracleInstance?: Instance<unknown> | string, query?: OracleQuery) => Promise<OracleAdmin<Price>>;
+    }>;
+    publicFacet: {
+        getPriceAuthority(): import("@agoric/zoe/tools/types.js").PriceAuthority;
+        getSubscriber: () => import("@agoric/notifier").StoredSubscriber<unknown>;
+        /** Diagnostic tool */
+        getRoundCompleteNotifier(): Promise<Notifier<any>>;
+    } & import("@endo/marshal").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        getPriceAuthority(): import("@agoric/zoe/tools/types.js").PriceAuthority;
+        getSubscriber: () => import("@agoric/notifier").StoredSubscriber<unknown>;
+        /** Diagnostic tool */
+        getRoundCompleteNotifier(): Promise<Notifier<any>>;
+    }>;
+}>;
+import type { Ratio } from '@agoric/ertp';
+import type { ContractOf } from '../zoeService/utils.js';
+import type { TimerService } from '@agoric/time';
+import type { Brand } from '@agoric/ertp';
+import type { Amount } from '@agoric/ertp';
+import type { ZCF } from '@agoric/zoe';
+import type { Marshaller } from '@agoric/internal/src/lib-chainStorage.js';
+import type { Remote } from '@agoric/internal';
+import type { PriceDescription } from '@agoric/zoe/tools/types.js';
+import type { Mint } from '@agoric/ertp';
+import type { ERef } from '@agoric/vow';
+import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
+import type { Instance } from '@agoric/zoe';
+import type { OracleAdmin } from './priceAggregatorTypes.js';
+import type { Invitation } from '@agoric/zoe';
+import type { Notifier } from '@agoric/notifier';
+import type { OracleKey } from './priceAggregatorTypes.js';
+import type { OracleQuery } from './priceAggregatorTypes.js';
+//# 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":"6BAqDc,MAAM,GAAG,MAAM,GAAG,MAAM;oCAEzB,QAAQ,CAAC,cAAc,GAAG;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,CAAC;oBAGlD,cAAc,GAAG,KAAK;sCAqlBtB,WAAW,OAAO,KAAK,CAAC;AAhlBtC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2BAbW,IAAI;IACZ,KAAK,EAAE,YAAY,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,KAAK,CAAC,CAAC;IACtB,QAAQ,EAAE,MAAM,KAAK,CAAC,CAAC;IACvB,YAAY,EAAE,OAAO,KAAK,CAAC,CAAC;CAC3B,CAAC,eACM;IACR,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,SAAS,CAAC,EAAE,KAAK,KAAK,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAChD,WAAW,EAAE,OAAO,WAAW,CAAC,CAAC;CAChC;;QAiXA;;;;;;;;;WASG;2CADQ,SAAS,OAAO,CAAC,GAAG,MAAM;mBAaN,YAAY,KAAK,CAAC;8BAAoB;gBAAC,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC,CAAA;aAAC;;;;;QA0CtI,mCAAmC;kCAAvB,SAAS;QAarB;;;;WAIG;sCAHQ,SAAS,OAAO,CAAC,GAAG,MAAM,UAC1B,WAAW,KACT,OAAO,CAAC,YAAY,KAAK,CAAC,CAAC;;QA/ExC;;;;;;;;;WASG;2CADQ,SAAS,OAAO,CAAC,GAAG,MAAM;mBAaN,YAAY,KAAK,CAAC;8BAAoB;gBAAC,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC,CAAA;aAAC;;;;;QA0CtI,mCAAmC;kCAAvB,SAAS;QAarB;;;;WAIG;sCAHQ,SAAS,OAAO,CAAC,GAAG,MAAM,UAC1B,WAAW,KACT,OAAO,CAAC,YAAY,KAAK,CAAC,CAAC;;;;;QAoHxC,sBAAsB;;;;;QAAtB,sBAAsB;;;GAOzB;2BAjmBsC,cAAc;gCARxB,wBAAwB;kCAGtB,cAAc;2BAKN,cAAc;4BAAd,cAAc;yBANA,aAAa;gCAWrC,0CAA0C;4BAhB9C,kBAAkB;sCAIkC,4BAA4B;0BAWlF,cAAc;0BAGd,aAAa;iCADN,0CAA0C;8BAZnB,aAAa;iCAQpC,2BAA2B;gCARJ,aAAa;8BAHzB,kBAAkB;+BAU/B,2BAA2B;iCAEzB,2BAA2B"}

package/src/contracts/priceAggregatorTypes.d.ts

@@ -0,0 +1,83 @@
+export type OracleAdmin<R extends unknown> = {
+    /**
+     * Remove the oracle from the aggregator
+     */
+    delete: () => Promise<void>;
+    /**
+     * Rather than waiting for the polling query, push a result directly from this oracle
+     */
+    pushResult: (result: R) => Promise<void>;
+};
+export type OracleKey = {} | string;
+export type PriceAggregatorKit = Pick<PriceAggregatorContract, "creatorFacet" | "publicFacet">;
+export type OracleQuery = Record<string, unknown> & {
+    kind?: string;
+    increment?: bigint;
+};
+/**
+ * The public methods accessible from the contract instance
+ */
+export type OraclePublicFacet = {
+    /**
+     * Create an invitation for an oracle query
+     */
+    makeQueryInvitation: (query: OracleQuery) => ERef<Invitation>;
+    /**
+     * Make an unpaid query
+     */
+    query: (query: OracleQuery) => ERef<unknown>;
+};
+export type OracleCreatorFacetMakeWithdrawInvitation = (total?: boolean | undefined) => ERef<Invitation>;
+/**
+ * The private methods accessible from the contract instance
+ */
+export type OracleCreatorFacet = {
+    /**
+     * Get the current fee amounts
+     */
+    getCurrentFees: () => AmountKeywordRecord;
+    /**
+     * Create an invitation to withdraw fees
+     */
+    makeWithdrawInvitation: OracleCreatorFacetMakeWithdrawInvitation;
+    /**
+     * Make an invitation to withdraw all fees and shutdown
+     */
+    makeShutdownInvitation: () => Promise<Invitation>;
+};
+export type OraclePrivateParameters = {
+    oracleHandler: OracleHandler;
+};
+export type OracleInitializationFacet = {
+    initialize: (privateParams: OraclePrivateParameters) => OracleCreatorFacet;
+};
+export type OracleKit = {
+    creatorFacet: OracleCreatorFacet;
+    publicFacet: OraclePublicFacet;
+    instance: Instance;
+};
+export type OracleReply = {
+    reply: unknown;
+    requiredFee?: Amount | undefined;
+};
+export type OracleHandler = {
+    /**
+     * Callback to reply to a query
+     */
+    onQuery: (query: OracleQuery, fee: Amount) => Promise<OracleReply>;
+    /**
+     * Notice an error
+     */
+    onError: (query: OracleQuery, reason: unknown) => void;
+    /**
+     * Notice a successful reply
+     */
+    onReply: (query: OracleQuery, reply: unknown, requiredFee: Amount | undefined) => void;
+};
+import type { PriceAggregatorContract } from './priceAggregator.js';
+import type { Invitation } from '../types-index.js';
+import type { ERef } from '@agoric/vow';
+import type { AmountKeywordRecord } from '@agoric/zoe';
+import type { Instance } from '@agoric/zoe';
+import type { Amount } from '@agoric/ertp';
+//# sourceMappingURL=priceAggregatorTypes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"priceAggregatorTypes.d.ts","sourceRoot":"","sources":["priceAggregatorTypes.js"],"names":[],"mappings":"wBACsB,CAAC;;;;YAET,MAAM,OAAO,CAAC,IAAI,CAAC;;;;gBAEnB,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC;;wBAa7B,EAAE,GAAG,MAAM;iCAIX,IAAI,CAAC,uBAAuB,EAAE,cAAc,GAAG,aAAa,CAAC;0BAI7D,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;CAClB;;;;;;;;yBAMU,CAAC,KAAK,EAAE,WAAW,KAAK,KAAK,UAAU,CAAC;;;;WAExC,CAAC,KAAK,EAAE,WAAW,KAAK,KAAK,OAAO,CAAC;;wFAOtC,KAAK,UAAU,CAAC;;;;;;;;oBAMf,MAAM,mBAAmB;;;;4BAEzB,wCAAwC;;;;4BAExC,MAAM,OAAO,CAAC,UAAU,CAAC;;;mBAMzB,aAAa;;;gBAKb,CAAC,aAAa,EAAE,uBAAuB,KAC7C,kBAAkB;;;kBAKZ,kBAAkB;iBAClB,iBAAiB;cACjB,QAAQ;;;WAKR,OAAO;;;;;;;aAMP,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC;;;;aAEzD,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI;;;;aAE7C,CAAC,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,MAAM,GAAG,SAAS,KACtC,IAAI;;6CAjF8B,sBAAsB;gCACnC,mBAAmB;0BAGzB,aAAa;yCAFY,aAAa;8BAAb,aAAa;4BACpC,cAAc"}

package/src/contracts/scaledPriceAuthority.d.ts

@@ -0,0 +1,26 @@
+export function prepare(zcf: ZCF<ScaledPriceAuthorityOpts>, privateArgs: object, baggage: Baggage): Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        getPriceAuthority: () => Promise<PriceAuthority>;
+    }>;
+}>;
+export type ScaledPriceAuthorityOpts = {
+    sourcePriceAuthority: ERef<PriceAuthority>;
+    /**
+     * - sourceAmountIn:targetAmountIn
+     */
+    scaleIn: Ratio;
+    /**
+     * - sourceAmountOut:targetAmountOut
+     */
+    scaleOut: Ratio;
+    /**
+     * - targetAmountIn:targetAmountOut
+     */
+    initialPrice?: Ratio | undefined;
+};
+import type { ZCF } from '@agoric/zoe';
+import type { Baggage } from '@agoric/vat-data';
+import type { PriceAuthority } from '@agoric/zoe/tools/types.js';
+import type { ERef } from '@agoric/vow';
+import type { Ratio } from '@agoric/ertp';
+//# sourceMappingURL=scaledPriceAuthority.d.ts.map